import * as TestApp from '../../../test/App.js'
import * as FundingIdempotency from './fundingIdempotency.js'

const db = TestApp.database()

const now = new Date('2026-01-01T00:00:00.000Z')
const replayTtlMs = 86_400_000
const ttlMs = 60_000

beforeEach(() => vi.useFakeTimers({ now, toFake: ['Date'] }))
afterEach(() => vi.useRealTimers())

function input(overrides: Partial<FundingIdempotency.claim.Input> = {}) {
  return {
    apiKeyId: 'key_test',
    keyHash: `hash_${Math.random().toString(36).slice(2)}`,
    requestHash: 'req_aaaa',
    ttlMs,
    ...overrides,
  }
}

describe('claim', () => {
  test('claims, blocks equivalent concurrent requests, and flags mismatches', async () => {
    const first = input()
    expect(await FundingIdempotency.claim(db, first)).toEqual({
      createdAt: now.toISOString(),
      type: 'claimed',
    })
    expect(await FundingIdempotency.claim(db, first)).toEqual({ type: 'pending' })
    expect(await FundingIdempotency.claim(db, { ...first, requestHash: 'req_bbbb' })).toEqual({
      type: 'mismatch',
    })
  })

  test('replays the stored response after completion', async () => {
    const claimed = input()
    const result = await FundingIdempotency.claim(db, claimed)
    expect(result.type).toBe('claimed')
    if (result.type !== 'claimed') return
    const completedAt = new Date('2026-01-01T00:00:30.000Z')
    vi.setSystemTime(completedAt)
    await FundingIdempotency.complete(db, {
      apiKeyId: claimed.apiKeyId,
      createdAt: result.createdAt,
      keyHash: claimed.keyHash,
      replayTtlMs,
      response: '{"id":"ftr_test"}',
      transferId: 'ftr_test',
    })
    await expect(
      db.kysely
        .selectFrom('funding_idempotency_requests')
        .select('expiresAt')
        .where('apiKeyId', '=', claimed.apiKeyId)
        .where('keyHash', '=', claimed.keyHash)
        .executeTakeFirstOrThrow(),
    ).resolves.toEqual({ expiresAt: '2026-01-02T00:00:30.000Z' })
    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      response: '{"id":"ftr_test"}',
      type: 'replay',
    })
    // A different request against the completed key still conflicts.
    expect(await FundingIdempotency.claim(db, { ...claimed, requestHash: 'req_bbbb' })).toEqual({
      type: 'mismatch',
    })
  })

  test('completes non-transfer resources without a transfer id', async () => {
    const claimed = input()
    const result = await FundingIdempotency.claim(db, claimed)
    expect(result.type).toBe('claimed')
    if (result.type !== 'claimed') return
    await FundingIdempotency.complete(db, {
      apiKeyId: claimed.apiKeyId,
      createdAt: result.createdAt,
      keyHash: claimed.keyHash,
      replayTtlMs,
      response: '{"id":"fda_test"}',
    })

    await expect(
      db.kysely
        .selectFrom('funding_idempotency_requests')
        .select('transferId')
        .where('apiKeyId', '=', claimed.apiKeyId)
        .where('keyHash', '=', claimed.keyHash)
        .executeTakeFirstOrThrow(),
    ).resolves.toEqual({ transferId: null })
  })

  test('reclaims an expired row in place', async () => {
    const claimed = input()
    await FundingIdempotency.claim(db, claimed)
    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
    vi.setSystemTime(afterExpiry)
    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      createdAt: afterExpiry.toISOString(),
      type: 'claimed',
    })
  })

  test('release frees a pending claim for retry', async () => {
    const claimed = input()
    const result = await FundingIdempotency.claim(db, claimed)
    expect(result.type).toBe('claimed')
    if (result.type !== 'claimed') return
    await FundingIdempotency.release(db, {
      apiKeyId: claimed.apiKeyId,
      createdAt: result.createdAt,
      keyHash: claimed.keyHash,
    })
    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      createdAt: now.toISOString(),
      type: 'claimed',
    })
  })

  test('stale completion and release cannot mutate a replacement claim', async () => {
    const claimed = input()
    const original = await FundingIdempotency.claim(db, claimed)
    expect(original.type).toBe('claimed')
    if (original.type !== 'claimed') return

    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
    vi.setSystemTime(afterExpiry)
    const replacement = await FundingIdempotency.claim(db, claimed)
    expect(replacement.type).toBe('claimed')
    if (replacement.type !== 'claimed') return

    const identity = {
      apiKeyId: claimed.apiKeyId,
      createdAt: original.createdAt,
      keyHash: claimed.keyHash,
    }
    expect(
      await FundingIdempotency.complete(db, {
        ...identity,
        replayTtlMs,
        response: '{"id":"ftr_stale"}',
        transferId: 'ftr_stale',
      }),
    ).toBeUndefined()
    await FundingIdempotency.release(db, identity)
    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      type: 'pending',
    })
  })
})

describe('checkpoint', () => {
  test('resumes a provider result and completes it', async () => {
    const claimed = input()
    const result = await FundingIdempotency.claim(db, claimed)
    expect(result.type).toBe('claimed')
    if (result.type !== 'claimed') return
    await FundingIdempotency.checkpoint(db, {
      apiKeyId: claimed.apiKeyId,
      createdAt: result.createdAt,
      keyHash: claimed.keyHash,
      replayTtlMs,
      response: '{"requestId":"relay_request_1"}',
    })

    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      createdAt: now.toISOString(),
      response: '{"requestId":"relay_request_1"}',
      type: 'resume',
    })
    await FundingIdempotency.complete(db, {
      apiKeyId: claimed.apiKeyId,
      createdAt: result.createdAt,
      keyHash: claimed.keyHash,
      replayTtlMs,
      response: '{"id":"fda_test"}',
    })
    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
      response: '{"id":"fda_test"}',
      type: 'replay',
    })
  })
})