const { test } = require('node:test')
const assert = require('node:assert/strict')
const fs = require('node:fs')
const path = require('node:path')
const vm = require('node:vm')
const policy = require('./wiki_recovery_policy.cjs')

function triggerFixture(overrides = {}) {
  const review = { tenant_id: 10059, dead_letter_id: 10, knowledge_id: 'doc', knowledge_base_id: 'kb', model_id: 'model',
    previous_attempt: 2, previous_error_code: 'PAGE_WRITE_INCOMPLETE', max_attempt: 3, fix_release: 'public-20260919-061500',
    budget_version: 1, api_image_id: `sha256:${'a'.repeat(64)}`, source_fingerprint: 'b'.repeat(64), model_fingerprint: 'c'.repeat(64),
    embedding_model_id: 'embedding', max_provider_requests: 200, deadline_at: new Date(Date.now() + 3600000).toISOString() }
  const manifest = { stage: 'published', release: review.fix_release, api_image_id: `sha256:${'a'.repeat(64)}`,
    published_at: '2026-09-18T22:00:00Z', ...overrides.manifest }
  const runtime = { running: true, release: review.fix_release, image_id: `sha256:${'a'.repeat(64)}`, ...overrides.runtime }
  const source = { id: 10, tenant_id: 10059, knowledge_id: 'doc', knowledge_base_id: 'kb', model_id: 'model',
    source_fingerprint: review.source_fingerprint, model_fingerprint: review.model_fingerprint, embedding_model_id: review.embedding_model_id,
    eligible: true, chunks: 1, pending: 1, ...overrides.source }
  const previous = { tenant_id: 10059, dead_letter_id: 10, knowledge_id: 'doc', knowledge_base_id: 'kb', model_id: 'model',
    attempt_number: 2, pending: false, new_failures: 1, span_status: 'failed', error_code: 'PAGE_WRITE_INCOMPLETE', queued_at: '2026-09-18T21:00:00Z' }
  const receipt = { ...previous, attempt_number: 3, pending_op_id: 99, pending: true, claimed_at: null, new_failures: 0,
    queued_at: '2026-09-18T23:00:00Z', deployed_fix_review: review,
    retry_reason: 'Deployed bounded complete-page repair with persistence regression tests', ...overrides.receipt }
  receipt.recovery_budget = { ...receipt, source_fingerprint: review.source_fingerprint, model_fingerprint: review.model_fingerprint,
    embedding_model_id: review.embedding_model_id, max_provider_requests: review.max_provider_requests, reserved_provider_requests: 0,
    deadline_at: review.deadline_at, reviewed_release: review.fix_release, reviewed_api_image: review.api_image_id, status: 'active' }
  let triggerCalls = 0
  let manifestReads = 0
  const errors = []
  const context = {
    __dirname,
    process: { argv: ['node', 'recover_wiki_deadletters.cjs', '--trigger', '--ids=10'] },
    console: { log() {}, error(message) { errors.push(message) } },
    require(name) {
      if (name === 'node:fs') return {
        readFileSync(file) {
          assert.equal(path.basename(file), 'public-release.json')
          manifestReads++
          return JSON.stringify(manifest)
        },
        mkdirSync() {}, writeFileSync() {},
      }
      if (name === 'node:child_process') return { execFileSync(command, args, options = {}) {
        assert.equal(command, 'docker')
        if (args.includes('psql')) {
          assert.ok(args.includes('PGOPTIONS=-c default_transaction_read_only=on'), 'Trigger must not enqueue another operation')
          if (options.input.includes('to_regclass')) return 't'
          if (options.input.includes('FROM (SELECT ledger.*')) return JSON.stringify([previous, receipt])
          return JSON.stringify([source])
        }
        if (args.includes('inspect')) return JSON.stringify(runtime)
        if (args.includes('cp')) return ''
        if (args.includes('exec') && args.includes('/tmp/wiki-backfill-trigger')) {
          triggerCalls++
          return JSON.stringify({ triggered_scopes: 1 })
        }
        throw new Error('Unexpected Docker operation')
      } }
      if (name === './wiki_recovery_policy.cjs') return policy
      return require(name)
    },
  }
  vm.runInNewContext(fs.readFileSync(path.join(__dirname, 'recover_wiki_deadletters.cjs'), 'utf8'), context)
  return { triggerCalls, manifestReads, errors, exitCode: context.process.exitCode || 0 }
}

test('--trigger rechecks the persisted final review against the published image', () => {
  assert.deepEqual(triggerFixture(), { triggerCalls: 1, manifestReads: 1, errors: [], exitCode: 0 })
  for (const change of [
    { manifest: { release: 'public-20260918-000000' } },
    { manifest: { stage: 'origin-ready' } },
    { runtime: { release: 'public-20260918-000000' } },
    { runtime: { image_id: `sha256:${'b'.repeat(64)}` } },
    { runtime: { running: false } },
    { receipt: { deployed_fix_review: undefined } },
  ]) {
    const result = triggerFixture(change)
    assert.equal(result.triggerCalls, 0)
    assert.equal(result.exitCode, 1)
    assert.equal(result.errors.length, 1)
  }
})

test('--trigger rejects source or receipt changes and mismatched reviewed attempts', () => {
  for (const change of [
    { source: { tenant_id: 10060 } },
    { source: { knowledge_id: 'other' } },
    { source: { knowledge_base_id: 'other' } },
    { source: { model_id: 'other' } },
    { receipt: { knowledge_base_id: 'other' } },
    { receipt: { model_id: 'other' } },
    { receipt: { attempt_number: 4 } },
  ]) {
    const result = triggerFixture(change)
    assert.equal(result.triggerCalls, 0)
    assert.equal(result.exitCode, 1)
    assert.equal(result.errors.length, 1)
  }
})

test('page recovery and window coverage never imply complete source reading without the new map proof', () => {
  assert.equal(policy.describeReadCoverage({ recovery_status: 'wiki_recovered' }), 'not_verified')
  assert.equal(policy.describeReadCoverage({ read_progress: { summary: { status: 'complete', source_windows_complete: true } } }), 'in_progress')
  assert.equal(policy.describeReadCoverage({ read_progress: { candidates: { status: 'paused_budget' } } }), 'paused_budget')
  assert.equal(policy.describeReadCoverage({ read_coverage_version: 'wiki-full-read-v1', source_read_complete: true }), 'source_processed')
  assert.equal(policy.describeReadCoverage({ read_coverage_version: 'old-prefix', source_read_complete: true }), 'not_verified')
})

test('terminal reading failures cannot be reported as an active saved prefix', () => {
  const read_progress = { candidates: { status: 'reading', completed_windows: 1, total_windows: 7 } }
  assert.equal(policy.describeReadCoverage({ read_progress, span_status: 'failed' }), 'failed')
  assert.equal(policy.describeReadCoverage({ read_progress, recovery_budget: { status: 'stopped_budget', stop_reason: 'phase_failed' } }), 'failed')
  assert.equal(policy.describeReadCoverage({ read_progress, recovery_budget: { status: 'stopped_budget', stop_reason: 'deadline' } }), 'stopped_budget')
  assert.equal(policy.describeReadCoverage({ read_progress, recovery_budget: { status: 'stopped_invalid' } }), 'stopped_invalid')
  assert.equal(policy.describeReadCoverage({ read_progress, recovery_budget: { status: 'active' } }), 'in_progress')
  assert.equal(policy.describeReadCoverage({ read_progress, span_status: 'failed', read_coverage_version: 'wiki-full-read-v1', source_read_complete: true }), 'source_processed')
  assert.equal(read_progress.candidates.completed_windows, 1)
})