import * as Transfer from '../../internal/funding/Transfer.js'
import * as TestApp from '../../../test/App.js'
import * as TestFunding from '../../../test/Funding.js'
import * as FundingTransfers from './fundingTransfers.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: TestFunding.transferSnapshot(),
    ...input,
  })
}

describe('list', () => {
  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 FundingTransfers.list(db, owner, { limit: 3 })
    expect(page.map((row) => row.id)).toEqual([third.id, second.id, first.id])

    const rest = await FundingTransfers.list(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 FundingTransfers.list(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 FundingTransfers.list(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: TestFunding.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
    })
    const second = await seed({
      snapshot: TestFunding.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 FundingTransfers.listProcessing(db, { limit: 1, providerId: 'stargate' })
    const rest = await FundingTransfers.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 FundingTransfers.count(db, owner, { cap: 100 })
    expect(total).toBeGreaterThanOrEqual(3)
    expect(await FundingTransfers.count(db, owner, { cap: 2 })).toBe(3)
    expect(await FundingTransfers.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 FundingTransfers.getOwned(db, owner, record.id))?.id).toBe(record.id)
    expect(
      await FundingTransfers.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
    ).toBeUndefined()
    expect(
      await FundingTransfers.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,
      snapshot: record.snapshot,
      status: 'processing',
      statusReason: null,
      updatedAt: '2026-01-01T00:10:00.000Z',
      version: 2,
    } as const
    expect((await FundingTransfers.update(db, options))?.version).toBe(2)
    expect(await FundingTransfers.update(db, options)).toBeUndefined()
  })
})