{
  "account_id": "abc123",
  "name": "My 401k",
  "type": "investment", // Plaid's categorization
  "subtype": "401k", // Plaid's specific type
  "balance": 50000
}

investment
├── 401k
├── 403b
├── ira
├── roth
├── brokerage
└── ...

depository
├── checking
├── savings
├── money market
├── hsa
└── ...

credit
├── credit card
└── ...

loan
├── mortgage
├── auto
├── student
└── ...

{
  "id": "xyz789",
  "name": "Fidelity 401k",
  "type": "401K", // SnapTrade's format (this is really a subtype!)
  "balance": 75000
}

// lib/account-type-mappings.ts
export const SNAPTRADE_TO_PLAID_MAPPING = {
  '401K': { type: 'investment', subtype: '401k' },
  IRA: { type: 'investment', subtype: 'ira' },
  ROTH: { type: 'investment', subtype: 'roth' },
  I: { type: 'investment', subtype: 'brokerage' },
  HSA: { type: 'depository', subtype: 'hsa' },
  // ... etc
}

// 1. Get SnapTrade account
const snapTradeType = account.type // "401K"

// 2. Map to Plaid format
const mapping = SNAPTRADE_TO_PLAID_MAPPING[snapTradeType]
// → { type: "investment", subtype: "401k" }

// 3. Store in database
await supabase.from('snaptrade_accounts').insert({
  source_account_type: '401K', // Original
  source_type: 'investment', // Mapped
  source_subtype: '401k', // Mapped
  type: 'investment', // Current (starts same as source)
  subtype: '401k', // Current (starts same as source)
  account_type: 'investment', // Legacy (mirrors type)
})

// ❌ Can't do this - every account type is different!
if (
  account.account_type === '401K' ||
  account.account_type === 'IRA' ||
  account.account_type === 'ROTH'
) {
  // Add to investments
}

// ✅ Simple and unified!
if (account.type === 'investment') {
  // Add to investments (works for ALL investment accounts)
}

API: app/api/accounts/update-type/route.ts
     Updates: type = "depository", subtype = "checking"
     Preserves: source_type = "investment", source_subtype = "401k"

Note: UI for account type override is not yet implemented.
      The backend API is ready, but no frontend dialog exists currently.

// lib/account-type-utils.ts
const hasUserOverride = account.source_type
  ? account.type !== account.source_type ||
    account.subtype !== account.source_subtype
  : false

// If TRUE: User changed it
// If FALSE: Still using original categorization

// Copy source values back to current
account.type = account.source_type
account.subtype = account.source_subtype

// Scenario A: No override
{
  source_type: "investment",
  type: "investment",
  source_subtype: "401k",
  subtype: "401k"
}
// hasUserOverride = FALSE (type === source_type)

// Scenario B: User override
{
  source_type: "investment",  // What it originally was
  type: "depository",         // What user changed it to
  source_subtype: "401k",
  subtype: "checking"
}
// hasUserOverride = TRUE (type !== source_type)

// Daily Snapshot Cron (simplified)
if (account.type === 'investment') {
  totalInvestments += account.balance
} else if (account.type === 'depository') {
  totalCash += account.balance
} else if (account.type === 'credit' || account.type === 'loan') {
  totalDebts += account.balance
}

Assets:
├── Total Investments (type = 'investment')
│   ├── Plaid investment accounts
│   ├── SnapTrade investment accounts
│   └── Manual investment accounts
│
├── Total Cash (type = 'depository')
│   ├── Plaid checking/savings
│   ├── SnapTrade HSA/cash accounts
│   └── Manual cash accounts
│
└── Other Assets
    ├── Properties
    ├── Vehicles
    └── Crypto

Liabilities:
├── Credit Cards (type = 'credit')
├── Loans (type = 'loan')
└── Mortgages (type = 'loan', subtype = 'mortgage')

Net Worth = Total Assets - Total Liabilities

// components/account-list-view.tsx
const retirementAccounts = accounts.filter((account) => {
  // For all accounts, check if subtype is retirement-related
  return retirementSubtypes.some(
    (st) => st.toLowerCase() === account.subtype?.toLowerCase()
  )
})

const investmentAccounts = accounts.filter((account) => {
  return (
    getEffectiveAccountType(account) === 'investment' && !isRetirement(account)
  )
})

export function getEffectiveAccountType(account: any): string {
  // Step 1: Guard against null
  if (!account) return 'unknown'

  // Step 2: Get the current type
  const accountType = account.type || account.account_type || 'unknown'

  // Step 3: Check if user overrode the type
  const hasUserOverride = account.source_type
    ? account.type !== account.source_type ||
      account.subtype !== account.source_subtype
    : false

  // Step 4: If user override, ALWAYS respect it
  if (hasUserOverride) {
    return accountType // Use what user chose
  }

  // Step 5: Handle edge case - depository with investments
  // (e.g., Merrill Edge checking account that holds stocks)
  if (accountType === 'depository' && account.positions?.length > 0) {
    return 'investment' // Auto-correct
  }

  // Step 6: Return original type
  return accountType
}

// ❌ Miss edge cases
if (account.type === 'depository') {
  totalCash += account.balance
  // But what if it has stocks? Wrong category!
}

// ✅ Handles all cases
const effectiveType = getEffectiveAccountType(account)
if (effectiveType === 'depository') {
  totalCash += account.balance // Only true cash accounts
}

// app/api/cron/process-daily-snapshot/route.ts
const effectiveType = getEffectiveAccountType(account)
if (effectiveType === 'investment') {
  totalMarketValue += account.balance
}

// hooks/queries/use-accounts.ts
const totalCash = accounts.reduce((sum, account) => {
  const effectiveType = getEffectiveAccountType(account)
  if (effectiveType === 'depository') {
    return sum + account.balance_current
  }
  return sum
}, 0)

Plaid API → process-connection
    ↓
    Saves to database:
    ├── source_type (from Plaid)
    ├── source_subtype (from Plaid)
    ├── type (copy of source_type)
    └── subtype (copy of source_subtype)
    ↓
    Used in calculations:
    └── getEffectiveAccountType(account)
        → Returns account.type (or auto-corrects edge cases)

SnapTrade API → process-connection
    ↓
    Receives: type = "401K"
    ↓
    Map via SNAPTRADE_TO_PLAID_MAPPING:
    "401K" → { type: "investment", subtype: "401k" }
    ↓
    Saves to database:
    ├── source_account_type = "401K" (original)
    ├── source_type = "investment" (mapped)
    ├── source_subtype = "401k" (mapped)
    ├── type = "investment" (current)
    ├── subtype = "401k" (current)
    └── account_type = "investment" (legacy, mirrors type)
    ↓
    Used in calculations:
    └── getEffectiveAccountType(account)
        → Returns account.type (respects overrides)

User clicks "Edit Account Type"
    ↓
UI: account-type-dialog.tsx
    Shows: Current (type/subtype)
    Shows: Original (source_type/source_subtype)
    ↓
User selects: "Depository / Checking"
    ↓
API: /api/accounts/update-type
    Updates:
    ├── type = "depository"
    ├── subtype = "checking"
    Preserves:
    ├── source_type = "investment"
    └── source_subtype = "401k"
    ↓
Next calculation:
    getEffectiveAccountType(account)
    ├── Detects: type !== source_type
    ├── hasUserOverride = TRUE
    └── Returns: "depository" (respects user choice)

// DON'T DO THIS:
if (account.account_type === '401K' || account.account_type === 'IRA') {
  // This breaks after migration!
}

// DO THIS:
if (account.type === 'investment') {
  // Works forever!
}

// DON'T DO THIS:
const accountType = account.type // Might be undefined!

// DO THIS:
const accountType = account.type || account.account_type || 'unknown'

// DON'T DO THIS:
if (account.type === 'depository') {
  totalCash += account.balance
  // Misses edge cases!
}

// DO THIS:
const effectiveType = getEffectiveAccountType(account)
if (effectiveType === 'depository') {
  totalCash += account.balance
}

// DON'T DO THIS (for SnapTrade):
const hasOverride = account.account_type !== account.source_account_type
// "investment" !== "401K" → Always TRUE (false positive!)

// DO THIS:
const hasOverride = account.type !== account.source_type
// "investment" !== "investment" → FALSE (correct!)

// DON'T DO THIS:
const total = accounts.reduce((sum, a) => sum + a.balance, 0)
// Includes hidden accounts!

// DO THIS:
const total = accounts
  .filter((a) => !a.is_hidden)
  .reduce((sum, a) => sum + a.balance, 0)

{
  type: "investment",
  subtype: "401k",
  source_type: "investment",
  source_subtype: "401k"
}

{
  type: "depository",
  subtype: "checking",
  source_type: "investment",
  source_subtype: "401k"
}

{
  account_type: "401K",  // Single field, SnapTrade format
}

{
  source_account_type: "401K",    // Original preserved
  source_type: "investment",      // Mapped category
  source_subtype: "401k",         // Mapped specific type
  type: "investment",             // Current (user can change)
  subtype: "401k",                // Current (user can change)
  account_type: "investment"      // Legacy (auto-synced)
}