import { nanoid } from 'nanoid'

import * as Runtime from '../../../test/runtime.js'
import * as Db from '../Db.js'
import * as SponsorshipReconciliationCursors from './sponsorshipReconciliationCursors.js'

const identity = {
  chainId: 42431,
  feePayer: '0xfee0000000000000000000000000000000000000',
} as const

describe('load', () => {
  test('behavior: concurrent initial reads share a durable revision', async () => {
    const db = create()
    await db.migrate()
    const [first, second] = await Promise.all([
      SponsorshipReconciliationCursors.load(db, identity),
      SponsorshipReconciliationCursors.load(db, identity),
    ])
    expect(first).toStrictEqual(second)
    expect(first).toMatchObject({ complete: true, retryCount: 0, retryKey: null })
    await db.close()
  })
})

describe('save', () => {
  test('behavior: stale passes cannot overwrite progress or reset a newer scan', async () => {
    const db = create()
    await db.migrate()
    const first = await SponsorshipReconciliationCursors.load(db, identity)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...first,
        blockNumber: '10',
        complete: false,
        transactionIndex: 2,
      }),
    ).toBe(true)
    const second = await SponsorshipReconciliationCursors.load(db, identity)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...second,
        blockNumber: '9',
        transactionIndex: 1,
      }),
    ).toBe(true)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...second,
        blockNumber: '10',
        transactionIndex: 1,
      }),
    ).toBe(false)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...first,
        complete: true,
      }),
    ).toBe(false)
    const current = await SponsorshipReconciliationCursors.load(db, identity)
    expect(current).toMatchObject({ blockNumber: '9', complete: false, transactionIndex: 1 })

    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...current,
        complete: true,
      }),
    ).toBe(true)
    const restarted = await SponsorshipReconciliationCursors.load(db, identity)
    expect(restarted.revision).not.toBe(current.revision)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...restarted,
        blockNumber: '20',
        complete: false,
        transactionIndex: 0,
      }),
    ).toBe(true)
    expect(
      await SponsorshipReconciliationCursors.save(db, {
        ...current,
        complete: true,
      }),
    ).toBe(false)
    expect(await SponsorshipReconciliationCursors.save(db, first)).toBe(false)
    expect(await SponsorshipReconciliationCursors.load(db, identity)).toMatchObject({
      blockNumber: '20',
      complete: false,
      transactionIndex: 0,
    })
    await db.close()
  })

  test('behavior: overlapping attempts increment a candidate retry only once', async () => {
    const db = create()
    await db.migrate()
    const first = await SponsorshipReconciliationCursors.load(db, identity)
    const retry = { ...first, retryCount: 1, retryKey: '10:2' }
    const results = await Promise.all([
      SponsorshipReconciliationCursors.save(db, retry),
      SponsorshipReconciliationCursors.save(db, retry),
    ])
    expect(results.sort((left, right) => Number(left) - Number(right))).toStrictEqual([false, true])
    expect(await SponsorshipReconciliationCursors.load(db, identity)).toMatchObject({
      complete: true,
      retryCount: 1,
      retryKey: '10:2',
    })
    await db.close()
  })
})

function create() {
  return Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
}