import assert from 'node:assert/strict'
import { it } from 'node:test'
import { CheckLedger } from '../dist/index.js'

const KEY = { artifactUri: 'at://did/artifact/a1', artifactCid: 'cid-a1', commit: 'deadbeef' }
// Same artifact, a different version (cid) — a distinct check key that must never collide with KEY.
const KEY_V2 = { artifactUri: 'at://did/artifact/a1', artifactCid: 'cid-a2', commit: 'deadbeef' }
// Same artifact version, a different commit — also distinct.
const KEY_C2 = { artifactUri: 'at://did/artifact/a1', artifactCid: 'cid-a1', commit: 'feedface' }

it('a fresh key has no row and is eligible', () => {
  const ledger = new CheckLedger()
  assert.equal(ledger.get(KEY), undefined)
  assert.equal(ledger.eligible(KEY), true)
  ledger.close()
})

it('markRunning makes a key ineligible and records the container label', () => {
  const ledger = new CheckLedger()
  ledger.markRunning(KEY, { containerLabel: 'radial.check.abc' })
  assert.equal(ledger.eligible(KEY), false)
  const row = ledger.get(KEY)
  assert.equal(row.state, 'running')
  assert.equal(row.attempts, 0)
  assert.equal(row.containerLabel, 'radial.check.abc')
  ledger.close()
})

it('the composite key distinguishes version and commit', () => {
  const ledger = new CheckLedger()
  ledger.markRunning(KEY, { containerLabel: 'L1' })
  // A different cid or a different commit is a different row: still eligible, no row yet.
  assert.equal(ledger.eligible(KEY_V2), true)
  assert.equal(ledger.eligible(KEY_C2), true)
  assert.equal(ledger.get(KEY_V2), undefined)
  assert.equal(ledger.get(KEY_C2), undefined)
  ledger.close()
})

it('markDone stores the checkrun ref and is terminal (ineligible)', () => {
  const ledger = new CheckLedger()
  ledger.markRunning(KEY, { containerLabel: 'L1' })
  ledger.markDone(KEY, { uri: 'at://did/checkrun/c1', cid: 'cid-c1' })
  const row = ledger.get(KEY)
  assert.equal(row.state, 'done')
  assert.deepEqual(row.checkrunRef, { uri: 'at://did/checkrun/c1', cid: 'cid-c1' })
  assert.equal(ledger.eligible(KEY), false)
  ledger.close()
})

it('markRunning after a crash carries attempts forward (does not reset the counter)', () => {
  const ledger = new CheckLedger()
  ledger.markRunning(KEY, { containerLabel: 'L1' })
  ledger.markCrashed(KEY)
  ledger.markRunning(KEY, { containerLabel: 'L2' })
  assert.equal(ledger.get(KEY).attempts, 1)
  ledger.close()
})

it('crash gates eligibility behind a cooldown, then clears', () => {
  let now = '2026-01-01T00:00:00.000Z'
  const ledger = new CheckLedger(':memory:', { cooldownMs: 300_000, retryBound: 3, now: () => now })
  ledger.markRunning(KEY, { containerLabel: 'L1' })
  const result = ledger.markCrashed(KEY)
  assert.deepEqual(result, { state: 'crashed', attempts: 1 })
  assert.equal(ledger.eligible(KEY), false)
  assert.equal(ledger.eligible(KEY, '2026-01-01T00:04:59.999Z'), false)
  assert.equal(ledger.eligible(KEY, '2026-01-01T00:05:00.000Z'), true)
  ledger.close()
})

it('gives up for good once attempts reach retryBound', () => {
  const ledger = new CheckLedger(':memory:', { retryBound: 3 })
  assert.deepEqual(ledger.markCrashed(KEY), { state: 'crashed', attempts: 1 })
  assert.deepEqual(ledger.markCrashed(KEY), { state: 'crashed', attempts: 2 })
  assert.deepEqual(ledger.markCrashed(KEY), { state: 'gave_up', attempts: 3 })
  // gave_up is terminal regardless of any cooldown having elapsed.
  assert.equal(ledger.eligible(KEY, '2999-01-01T00:00:00.000Z'), false)
  ledger.close()
})

it('running() lists only in-flight rows for orphan reconciliation', () => {
  const ledger = new CheckLedger()
  ledger.markRunning(KEY, { containerLabel: 'L1' })
  ledger.markRunning(KEY_C2, { containerLabel: 'L2' })
  ledger.markDone(KEY_C2, { uri: 'at://did/checkrun/c2', cid: 'cid-c2' })
  const running = ledger.running()
  assert.equal(running.length, 1)
  assert.equal(running[0].artifactUri, KEY.artifactUri)
  assert.equal(running[0].commit, KEY.commit)
  assert.equal(running[0].containerLabel, 'L1')
  ledger.close()
})

it('reset clears every row for an artifact uri (all versions/commits)', () => {
  const ledger = new CheckLedger()
  ledger.markDone(KEY, { uri: 'at://c/1', cid: 'c1' })
  ledger.markDone(KEY_V2, { uri: 'at://c/2', cid: 'c2' })
  ledger.markDone(KEY_C2, { uri: 'at://c/3', cid: 'c3' })
  ledger.reset(KEY.artifactUri)
  assert.equal(ledger.get(KEY), undefined)
  assert.equal(ledger.get(KEY_V2), undefined)
  assert.equal(ledger.get(KEY_C2), undefined)
  assert.equal(ledger.eligible(KEY), true)
  ledger.close()
})