import { QueryClient } from '@tanstack/react-query'
import { queryKeys } from './query-keys'

/**
 * Get the alias target for an account from cache metadata
 */
export function getAliasTarget(
  queryClient: QueryClient,
  accountId: string
): string | undefined {
  const queryState = queryClient.getQueryState([queryKeys.ACCOUNT, accountId])
  return queryState?.meta?.targetId as string | undefined
}

/**
 * Get all accounts that alias to this target from cache metadata
 */
export function getAliasesForTarget(
  queryClient: QueryClient,
  targetId: string
): string[] {
  const queryState = queryClient.getQueryState([queryKeys.ACCOUNT, targetId])
  const aliasedFrom = queryState?.meta?.aliasedFrom as string[] | undefined
  return aliasedFrom || []
}

/**
 * Follow alias chain by reading from cache until reaching final target.
 * Returns the final target ID, or the original ID if not an alias.
 */
export function followAliasChain(
  queryClient: QueryClient,
  startId: string,
  maxDepth = 10
): string {
  const visited = new Set<string>()
  let currentId = startId
  let depth = 0

  while (depth < maxDepth && !visited.has(currentId)) {
    visited.add(currentId)

    const targetId = getAliasTarget(queryClient, currentId)
    if (!targetId) {
      return currentId // No alias, this is the final target
    }

    currentId = targetId
    depth++
  }

  return currentId // Return last valid ID (handles cycles)
}

/**
 * Get all accounts affected by changes to targetId (target + all its aliases)
 */
export function getAffectedAccounts(
  queryClient: QueryClient,
  targetId: string
): string[] {
  return [targetId, ...getAliasesForTarget(queryClient, targetId)]
}

/**
 * Register an alias relationship in cache metadata.
 * Updates both source (isAlias: true, targetId) and target (aliasedFrom: [...])
 */
export function registerAliasInCache(
  queryClient: QueryClient,
  sourceId: string,
  targetId: string,
  sourceData?: any
) {
  // Update source with alias metadata
  if (sourceData) {
    queryClient.setQueryData(
      [queryKeys.ACCOUNT, sourceId],
      sourceData,
      { meta: { isAlias: true, targetId } }
    )
  }

  // Update target with reverse mapping
  const targetState = queryClient.getQueryState([queryKeys.ACCOUNT, targetId])
  const existingAliases = (targetState?.meta?.aliasedFrom || []) as string[]
  const targetData = queryClient.getQueryData([queryKeys.ACCOUNT, targetId])

  if (targetData) {
    queryClient.setQueryData(
      [queryKeys.ACCOUNT, targetId],
      targetData,
      {
        meta: {
          aliasedFrom: [...new Set([...existingAliases, sourceId])]
        }
      }
    )
  }
}

if (serverAccount.aliasAccount) {
  return await Account.getData(grpcClient, serverAccount.aliasAccount, queryDaemon)
}

export const Account: HMRequestImplementation<HMAccountRequest> = {
  async getData(
    grpcClient: GRPCClient,
    input: string,
    queryDaemon: QueryDaemonFn,
  ): Promise<HMMetadataPayload> {
    const grpcAccount = await grpcClient.documents.getAccount({ id: input })
    const serverAccount = toPlainMessage(grpcAccount)

    // CHANGED: Return the account with aliasAccount field intact
    // Don't resolve recursively here - let the hook layer handle it
    const metadata = prepareHMDocumentMetadata(grpcAccount.metadata)
    const result: HMMetadataPayload = {
      id: hmId(input, { version: serverAccount.homeDocumentInfo?.version }),
      metadata,
    }

    // NEW: Add aliasAccount to result if present
    if (serverAccount.aliasAccount) {
      return {
        ...result,
        aliasAccount: serverAccount.aliasAccount,
      } as HMMetadataPayload & { aliasAccount: string }
    }

    return result
  },
}

export const BatchAccounts: HMRequestImplementation<HMBatchAccountsRequest> = {
  async getData(
    grpcClient: GRPCClient,
    accountUids: string[],
    queryDaemon: QueryDaemonFn,
  ): Promise<Record<string, HMMetadataPayload>> {
    const _accounts = await grpcClient.documents.batchGetAccounts({
      ids: accountUids,
    })

    const result: Record<string, HMMetadataPayload> = {}
    const aliasesToResolve: string[] = []
    const aliasMapping: Record<string, string[]> = {}

    // First pass: process all accounts
    Object.entries(_accounts.accounts).forEach(([id, account]) => {
      const serverAccount = toPlainMessage(account)
      const metadata = prepareHMDocumentMetadata(account.metadata)

      const accountData: HMMetadataPayload = {
        id: hmId(id, { version: serverAccount.homeDocumentInfo?.version }),
        metadata,
      }

      if (serverAccount.aliasAccount) {
        // Store the alias hop with aliasAccount field
        result[id] = {
          ...accountData,
          aliasAccount: serverAccount.aliasAccount,
        } as HMMetadataPayload & { aliasAccount: string }

        // Track for resolution
        if (!aliasMapping[serverAccount.aliasAccount]) {
          aliasMapping[serverAccount.aliasAccount] = []
          aliasesToResolve.push(serverAccount.aliasAccount)
        }
        aliasMapping[serverAccount.aliasAccount].push(id)
      } else {
        // Not an alias, store directly
        result[id] = accountData
      }
    })

    // Second pass: resolve aliases recursively
    if (aliasesToResolve.length > 0) {
      const resolvedAliases = await BatchAccounts.getData(
        grpcClient,
        aliasesToResolve,
        queryDaemon,
      )

      // Add resolved accounts to result
      Object.entries(resolvedAliases).forEach(([resolvedId, resolvedAccount]) => {
        if (!result[resolvedId]) {
          result[resolvedId] = resolvedAccount
        }
      })
    }

    return result
  },
}

import { followAliasChain, registerAliasInCache } from './alias-utils'

export function useAccount(
  id: string | null | undefined,
  options?: UseAccountOptions,
) {
  const client = useUniversalClient()
  const queryClient = useQueryClient()

  return useQuery({
    enabled: options?.enabled ?? !!id,
    queryKey: [queryKeys.ACCOUNT, id],

    queryFn: async (): Promise<HMMetadataPayload | null> => {
      if (!id) return null
      return await client.request<HMAccountRequest>('Account', id)
    },

    // NEW: Track alias relationships after fetch
    onSuccess: (data) => {
      if (!data || !id) return

      // Check if this account is an alias
      const aliasAccount = (data as any).aliasAccount
      if (aliasAccount) {
        // Register the relationship in cache metadata
        registerAliasInCache(queryClient, id, aliasAccount, data)

        // Eagerly fetch the target if not in cache
        const targetInCache = queryClient.getQueryData([queryKeys.ACCOUNT, aliasAccount])
        if (!targetInCache) {
          queryClient.fetchQuery({
            queryKey: [queryKeys.ACCOUNT, aliasAccount],
            queryFn: () => client.request<HMAccountRequest>('Account', aliasAccount),
          })
        }
      }
    },

    // NEW: Resolve aliases in select
    select: (data) => {
      if (!data || !id) return data

      // Check if this account is an alias
      const targetId = followAliasChain(queryClient, id)

      if (targetId === id) {
        // Not an alias or end of chain, return as-is
        return data
      }

      // Get the resolved target data from cache
      const targetData = queryClient.getQueryData<HMMetadataPayload>([
        queryKeys.ACCOUNT,
        targetId,
      ])

      return targetData || data // Fallback to hop data if target not cached yet
    },

    ...options,
  })
}

import { registerAliasInCache } from './alias-utils'

export function useAccountsMetadata(
  uids: string[],
): HMAccountsMetadataResult {
  const client = useUniversalClient()
  const queryClient = useQueryClient()

  const result = useQuery({
    enabled: uids.length > 0,
    queryKey: [queryKeys.BATCH_ACCOUNTS, ...uids.slice().sort()],

    queryFn: async (): Promise<HMAccountsMetadata> => {
      if (uids.length === 0) return {}
      return await client.request<HMBatchAccountsRequest>('BatchAccounts', uids)
    },

    // NEW: Populate individual caches with metadata
    onSuccess: (data) => {
      Object.entries(data).forEach(([accountId, accountData]) => {
        // Store in individual cache
        queryClient.setQueryData(
          [queryKeys.ACCOUNT, accountId],
          accountData
        )

        // Track alias relationships if present
        const aliasAccount = (accountData as any).aliasAccount
        if (aliasAccount) {
          registerAliasInCache(queryClient, accountId, aliasAccount, accountData)
        }
      })
    },
  })

  return {
    data: result.data || {},
    isLoading: result.isLoading,
  }
}

/**
 * Invalidate an account and all accounts that alias to it.
 * Use this in mutations that update account data.
 */
export function invalidateAccountAndAliases(
  queryClient: QueryClient,
  accountId: string
) {
  // Get all affected accounts (target + aliases)
  const affectedAccounts = getAffectedAccounts(queryClient, accountId)

  // Invalidate each individual account query
  affectedAccounts.forEach(id => {
    queryClient.invalidateQueries({
      queryKey: [queryKeys.ACCOUNT, id]
    })
  })

  // Invalidate any batch queries containing these accounts
  queryClient.invalidateQueries({
    predicate: (query) => {
      if (query.queryKey[0] !== queryKeys.BATCH_ACCOUNTS) return false
      const batchIds = query.queryKey.slice(1) as string[]
      return affectedAccounts.some(id => batchIds.includes(id))
    }
  })
}

import { invalidateAccountAndAliases } from './alias-utils'

// In any mutation that updates account data
const updateProfileMutation = useMutation({
  mutationFn: async (input) => {
    // ... update logic
  },

  onSuccess: (updatedAccount, variables) => {
    const accountId = variables.accountId || updatedAccount.id

    // This handles both the account and all its aliases
    invalidateAccountAndAliases(queryClient, accountId)

    // OPTIONAL: Optimistic update
    getAffectedAccounts(queryClient, accountId).forEach(id => {
      queryClient.setQueryData(
        [queryKeys.ACCOUNT, id],
        updatedAccount,
        // Preserve existing metadata
        { meta: queryClient.getQueryState([queryKeys.ACCOUNT, id])?.meta }
      )
    })
  }
})

import { followAliasChain, getAffectedAccounts } from './alias-utils'

/**
 * Returns the final target account ID for an account that might be an alias.
 */
export function useResolvedAccountId(accountId: string | undefined): string | undefined {
  const queryClient = useQueryClient()

  return useMemo(() => {
    if (!accountId) return undefined
    return followAliasChain(queryClient, accountId)
  }, [accountId, queryClient])
}

/**
 * Returns all accounts in this alias group (target + all aliases).
 */
export function useAccountAliasGroup(accountId: string | undefined): string[] {
  const queryClient = useQueryClient()

  return useMemo(() => {
    if (!accountId) return []
    const target = followAliasChain(queryClient, accountId)
    return getAffectedAccounts(queryClient, target)
  }, [accountId, queryClient])
}

queryKey: [queryKeys.ENTITY, docId, version]
meta: { redirectTarget: `${targetId}@${targetVersion}` }

User requests Account A
       ↓
1. Hook fetches A → API returns { id: 'A', aliasAccount: 'B', metadata: {...} }
       ↓
2. onSuccess: Stores in cache with meta: { isAlias: true, targetId: 'B' }
       ↓
3. onSuccess: Triggers fetch of B if not cached
       ↓
4. Hook fetches B → API returns { id: 'B', metadata: {...} }
       ↓
5. onSuccess: Stores in cache with meta: { aliasedFrom: ['A'] }
       ↓
6. select: Reads A's metadata, sees targetId: 'B'
       ↓
7. select: Reads B from cache, returns B's data
       ↓
Component receives B's data when querying A

describe('alias-utils', () => {
  describe('followAliasChain', () => {
    it('returns same ID if not an alias', () => {})
    it('resolves single hop (A -> B)', () => {})
    it('resolves multi-hop (A -> B -> C)', () => {})
    it('handles cycles gracefully', () => {})
    it('respects maxDepth', () => {})
  })

  describe('getAffectedAccounts', () => {
    it('returns target + all aliases', () => {})
    it('handles target with no aliases', () => {})
  })

  describe('registerAliasInCache', () => {
    it('sets metadata on source', () => {})
    it('appends to aliasedFrom on target', () => {})
    it('deduplicates aliasedFrom array', () => {})
  })
})

describe('useAccount with aliases', () => {
  it('stores alias metadata on fetch', async () => {
    // Mock A -> B alias
    // Fetch A
    // Check queryClient.getQueryState(['account', 'A']).meta
    expect(meta).toEqual({ isAlias: true, targetId: 'B' })
  })

  it('returns resolved data in select', async () => {
    // Mock A -> B, ensure B is cached
    // useAccount('A')
    // Expect to receive B's data
  })

  it('eagerly fetches target', async () => {
    // Mock A -> B, B not cached
    // Fetch A
    // Verify B is fetched automatically
  })
})