import * as Transfer from '../../internal/routes/Transfer.js'
import * as TestApp from '../../../test/App.js'
import * as TestRoutes from '../../../test/Routes.js'
import * as RoutesTransferTransactions from './routesTransferTransactions.js'
import * as RoutesTransfers from './routesTransfers.js'

const db = TestApp.database()

const owner = { environment: 'production', orgId: 'org_list' } as const

let counter = 0
function seed(input: Partial<Transfer.create.Input> = {}) {
  // Distinct create times keep ids strictly ordered for paging assertions.
  return Transfer.create(db, {
    apiKeyId: 'key_test',
    environment: 'production',
    id: Transfer.generateId(new Date(Date.UTC(2026, 0, 1, 0, 0, counter++))),
    orgId: owner.orgId,
    snapshot: TestRoutes.transferSnapshot({
      quote: { expiresAt: '2099-01-01T00:01:00.000Z', sampledAt: '2099-01-01T00:00:00.000Z' },
    }),
    ...input,
  })
}

describe('listByOwner', () => {
  test('pages newest-first by id with owner isolation', async () => {
    const first = await seed()
    const second = await seed({ projectId: 'prj_a' })
    const third = await seed()
    await seed({ orgId: 'org_other' })
    await seed({ environment: 'sandbox' })

    const page = await RoutesTransfers.listByOwner(db, owner, { limit: 3 })
    expect(page.map((row) => row.id)).toEqual([third.id, second.id, first.id])

    const rest = await RoutesTransfers.listByOwner(db, owner, { cursor: third.id, limit: 3 })
    expect(rest.map((row) => row.id)).toEqual([second.id, first.id])
  })

  test('narrows project-attributed owners to their project', async () => {
    const rows = await RoutesTransfers.listByOwner(
      db,
      { ...owner, projectId: 'prj_a' },
      { limit: 10 },
    )
    expect(rows.every((row) => row.projectId === 'prj_a')).toBe(true)
    expect(rows.length).toBeGreaterThan(0)
  })

  test('filters by status', async () => {
    const record = await seed()
    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'expired' })
    const rows = await RoutesTransfers.listByOwner(db, owner, {
      limit: 10,
      status: 'expired',
    })
    expect(rows.map((row) => row.id)).toEqual([record.id])
  })
})

describe('listProcessing', () => {
  test('returns only processing transfers for the provider', async () => {
    const first = await seed({
      snapshot: TestRoutes.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
    })
    const second = await seed({
      snapshot: TestRoutes.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
    })
    const relay = await seed()
    await Transfer.transition(db, { expectedVersion: 1, id: first.id, status: 'processing' })
    await Transfer.transition(db, { expectedVersion: 1, id: second.id, status: 'processing' })
    await Transfer.transition(db, { expectedVersion: 1, id: relay.id, status: 'processing' })

    const page = await RoutesTransfers.listProcessing(db, { limit: 1, providerId: 'stargate' })
    const rest = await RoutesTransfers.listProcessing(db, {
      cursor: page[0]!.id,
      limit: 1,
      providerId: 'stargate',
    })
    expect([page.map((row) => row.id), rest.map((row) => row.id)]).toEqual([
      [first.id],
      [second.id],
    ])
  })
})

describe('count', () => {
  test('shares the list filter and stops at the cap', async () => {
    const total = await RoutesTransfers.count(db, owner, { cap: 100 })
    expect(total).toBeGreaterThanOrEqual(3)
    expect(await RoutesTransfers.count(db, owner, { cap: 2 })).toBe(3)
    expect(await RoutesTransfers.count(db, { ...owner, orgId: 'org_none' }, { cap: 100 })).toBe(0)
  })
})

describe('getOwned', () => {
  test('returns owned rows and hides foreign ones', async () => {
    const record = await seed()
    expect((await RoutesTransfers.getOwned(db, owner, record.id))?.id).toBe(record.id)
    expect(
      await RoutesTransfers.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
    ).toBeUndefined()
    expect(
      await RoutesTransfers.getOwned(db, { ...owner, projectId: 'prj_a' }, record.id),
    ).toBeUndefined()
  })
})

describe('update', () => {
  test('applies only against the expected version', async () => {
    const record = await seed()
    const options = {
      expectedVersion: 1,
      id: record.id,
      providerDeliveredAt: null,
      snapshot: record.snapshot,
      status: 'processing',
      statusReason: null,
      statusUpdatedAt: '2026-01-01T00:10:00.000Z',
      subsidyAccount: null,
      subsidyAmount: null,
      subsidyChainId: null,
      subsidyCommitmentAmount: null,
      subsidyNativeAmount: null,
      subsidyTokenAddress: null,
      subsidyTransactionHash: null,
      updatedAt: '2026-01-01T00:10:00.000Z',
      version: 2,
    } as const
    expect((await RoutesTransfers.update(db, options))?.version).toBe(2)
    expect(await RoutesTransfers.update(db, options)).toBeUndefined()
  })
})

describe('subsidies', () => {
  test('keeps prepared liability durable and reports completed production usage once', async () => {
    const record = await seed({ orgId: 'org_transfer_subsidy' })
    const processing = await Transfer.transition(db, {
      expectedVersion: record.version,
      id: record.id,
      status: 'processing',
    })
    if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
    const amount = {
      baseUnits: '3001',
      currency: 'USD',
      decimals: 6,
      formatted: '0.003001',
    }
    const prepared = await Transfer.transition(db, {
      expectedVersion: processing.record.version,
      id: record.id,
      subsidyAmount: amount,
      subsidyTransactionHash: `0x${'ab'.repeat(32)}`,
    })
    if (prepared.type !== 'applied') throw new Error('Expected prepared subsidy.')

    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_transfer_subsidy')).toBe(true)
    expect(await RoutesTransfers.listUnreportedSubsidies(db)).toEqual([])

    const completed = await Transfer.transition(db, {
      expectedVersion: prepared.record.version,
      id: record.id,
      status: 'completed',
    })
    if (completed.type !== 'applied') throw new Error('Expected completed subsidy.')
    expect(RoutesTransfers.subsidies(completed.record)).toMatchObject([
      { amount: { baseUnits: '3001' }, provider: 'tempo' },
    ])
    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toContain(
      record.id,
    )
    expect(
      await RoutesTransfers.subsidyUsage(db, {
        environment: 'production',
        from: record.createdAt,
        orgId: 'org_transfer_subsidy',
        to: new Date().toISOString(),
      }),
    ).toEqual({ amount: 3001n, count: 1 })

    await RoutesTransfers.markSubsidyReported(db, record.id, new Date().toISOString())
    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_transfer_subsidy')).toBe(false)
    expect((await RoutesTransfers.get(db, record.id))?.subsidyMeterReportedAt).not.toBeNull()
  })

  test('releases abandoned commitments only after their expiry transition', async () => {
    const amount = {
      baseUnits: '3001',
      currency: 'USD',
      decimals: 6,
      formatted: '0.003001',
    } as const
    const commitment = {
      account: `0x${'55'.repeat(20)}`,
      amount,
      chainId: 'eip155:8453',
      nativeAmount: '100',
      tokenAddress: `0x${'66'.repeat(20)}`,
    }
    const expired = await seed({
      orgId: 'org_expired_transfer_subsidy',
      snapshot: TestRoutes.transferSnapshot({
        quote: { expiresAt: '2026-01-01T00:01:00.000Z', sampledAt: '2026-01-01T00:00:00.000Z' },
      }),
      subsidyCommitment: commitment,
    })
    const active = await seed({
      orgId: 'org_active_transfer_subsidy',
      subsidyCommitment: commitment,
    })

    expect(
      await RoutesTransfers.subsidyReservations(db, {
        account: commitment.account,
        chainId: commitment.chainId,
        tokenAddress: commitment.tokenAddress,
      }),
    ).toEqual({ nativeAmount: 200n, tokenAmount: 6002n })
    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_expired_transfer_subsidy')).toBe(
      true,
    )
    expect(await RoutesTransfers.hasUnreportedSubsidies(db, active.orgId)).toBe(true)
    expect(
      (
        await RoutesTransfers.listExpiredSubsidyCommitments(db, {
          expiredBefore: new Date(
            Date.now() - RoutesTransfers.subsidyCommitmentRecoveryTtlMs,
          ).toISOString(),
          limit: 10,
        })
      ).map(({ id }) => id),
    ).toContain(expired.id)

    await Transfer.transition(db, {
      expectedVersion: expired.version,
      id: expired.id,
      status: 'expired',
    })
    expect(
      await RoutesTransfers.subsidyReservations(db, {
        account: commitment.account,
        chainId: commitment.chainId,
        tokenAddress: commitment.tokenAddress,
      }),
    ).toEqual({ nativeAmount: 100n, tokenAmount: 3001n })
    expect(await RoutesTransfers.hasUnreportedSubsidies(db, expired.orgId)).toBe(false)
  })
})

describe('list', () => {
  test('filters across owners and searches transaction references', async () => {
    const record = await seed({
      orgId: 'org_admin_transfer',
      snapshot: TestRoutes.transferSnapshot({
        provider: { id: 'stargate_admin_list', name: 'Stargate' },
      }),
    })
    const transactionRef = 'ad'.repeat(32)
    await RoutesTransferTransactions.insert(db, {
      chainId: 'tron:mainnet',
      createdAt: record.createdAt,
      role: 'source',
      transactionRef,
      transferId: record.id,
    })

    const rows = await RoutesTransfers.list(db, {
      limit: 10,
      providerId: 'stargate_admin_list',
      query: transactionRef.toUpperCase(),
    })

    expect(rows.map(({ id }) => id)).toEqual([record.id])
  })

  test('filters to positive transfer subsidies', async () => {
    const snapshot = TestRoutes.transferSnapshot({
      provider: { id: 'subsidy_filter', name: 'Subsidy filter' },
    })
    const subsidized = await seed({ orgId: 'org_admin_transfer_subsidy', snapshot })
    await seed({ orgId: 'org_admin_transfer_subsidy', snapshot })
    const result = await Transfer.transition(db, {
      expectedVersion: subsidized.version,
      id: subsidized.id,
      subsidyAmount: {
        baseUnits: '3001',
        currency: 'USD',
        decimals: 6,
        formatted: '0.003001',
      },
    })
    if (result.type !== 'applied') throw new Error('Expected subsidized transfer.')

    expect(
      (
        await RoutesTransfers.list(db, {
          hasSubsidy: true,
          limit: 10,
          providerId: snapshot.provider.id,
        })
      ).map(({ id }) => id),
    ).toEqual([subsidized.id])
  })
})

describe('summarize', () => {
  test('counts processing and action-required transfers without overlap', async () => {
    const processing = await seed({
      orgId: 'org_admin_transfer_summary',
      snapshot: TestRoutes.transferSnapshot({
        provider: { id: 'stargate_admin_summary', name: 'Stargate' },
      }),
    })
    const actionRequired = await seed({
      orgId: 'org_admin_transfer_summary',
      snapshot: TestRoutes.transferSnapshot({
        provider: { id: 'stargate_admin_summary', name: 'Stargate' },
      }),
    })
    await Transfer.transition(db, {
      expectedVersion: processing.version,
      id: processing.id,
      status: 'processing',
    })
    await Transfer.transition(db, {
      expectedVersion: actionRequired.version,
      id: actionRequired.id,
      status: 'action-required',
      statusReason: { code: 'manual_recovery_required', message: 'Needs review.' },
    })

    expect(
      await RoutesTransfers.summarize(db, { providerId: 'stargate_admin_summary' }),
    ).toMatchObject({ actionRequired: 1, inProgress: 1 })
  })
})