const test = require('node:test');
const assert = require('node:assert/strict');
const Database = require('better-sqlite3');

const { initAutonomySchema } = require('../src/autonomy/schema');
const { enqueueJob, leaseNextJob, completeJob } = require('../src/autonomy/jobs');
const { normalizeProposal, acceptProposal } = require('../src/autonomy/coordinator');
const { calibrateOutcomes, cohortKey } = require('../src/autonomy/calibration');
const { decide } = require('../src/autonomy/policy');
const { validatePaperIntent, createSimulator } = require('../src/autonomy/execution');
const { calculateOutcome } = require('../src/autonomy/outcomes');
const { createOrderIntent } = require('../src/autonomy/orderIntents');
const { reconcileArchiveBatch, reconcileLiveBatch } = require('../workers/autonomyWorker');

test('autonomy schema and leased jobs are restart-safe', () => {
  const db = new Database(':memory:');
  initAutonomySchema(db);
  assert.equal(enqueueJob(db, {
    jobType: 'enrich', lane: 'live', priority: 10, entityType: 'article', entityId: 42,
    idempotencyKey: 'enrich:42',
  }).inserted, true);
  assert.equal(enqueueJob(db, {
    jobType: 'enrich', lane: 'live', priority: 10, entityType: 'article', entityId: 42,
    idempotencyKey: 'enrich:42',
  }).inserted, false);
  const job = leaseNextJob(db, 'test-worker');
  assert.equal(job.lane, 'live');
  assert.equal(completeJob(db, job.id, 'test-worker'), true);
  assert.equal(db.prepare("SELECT status FROM autonomy_jobs WHERE id = ?").get(job.id).status, 'complete');
});

test('coordinator proposals require evidence and contain no arbitrary numeric confidence', () => {
  const normalized = normalizeProposal({ predictions: [{
    instrument: 'nvda', direction: 'positive', event_type: 'supply_constraint',
    horizon_days: 10, evidence_article_ids: [7],
  }] }, { informationCutoff: '2026-01-01T00:00:00Z', model: 'test-model' });
  assert.equal(normalized.predictions[0].instrument, 'NVDA');
  assert.equal('probability' in normalized.predictions[0], false);
  assert.throws(() => normalizeProposal({ predictions: [{ instrument: 'NVDA', direction: 'positive', horizon_days: 10 }] }));
});

test('accepted proposal preserves evidence and creates immutable prediction', () => {
  const archive = new Database(':memory:');
  archive.exec('CREATE TABLE articles (id INTEGER PRIMARY KEY)');
  archive.prepare('INSERT INTO articles (id) VALUES (?)').run(7);
  const intelligence = new Database(':memory:');
  initAutonomySchema(intelligence);
  intelligence.prepare("INSERT INTO autonomy_instruments(symbol, broker, active, tradable) VALUES ('NVDA', 'test', 1, 1)").run();
  const result = acceptProposal(intelligence, archive, {
    predictions: [{ instrument: 'NVDA', direction: 'positive', event_type: 'earnings', horizon_days: 10, evidence_article_ids: [7] }],
  }, { informationCutoff: '2026-01-01T00:00:00Z', strategyVersion: 'test' });
  assert.equal(result.predictionCount, 1);
  assert.deepEqual(JSON.parse(intelligence.prepare('SELECT evidence_article_ids FROM autonomy_predictions').get().evidence_article_ids), [7]);
});

test('calibration and policy abstain on insufficient evidence', () => {
  const calibration = calibrateOutcomes([
    { excess_return: 0.02, direction_correct: 1 },
    { excess_return: -0.01, direction_correct: 0 },
  ]);
  assert.equal(calibration.sampleSize, 2);
  const result = decide({ ...calibration }, { minSampleSize: 30 });
  assert.equal(result.action, 'ABSTAIN');
  assert.equal(cohortKey({ sector: 'tech', eventType: 'earnings', horizonDays: 10, direction: 'positive' }), 'tech|earnings|10|positive');
  assert.equal(decide({ direction: 'negative', probability: 0.8, expectedExcessReturn: -0.02, lowerReturn: -0.04, sampleSize: 40 }).action, 'SELL');
});

test('paper execution is allowlisted, bounded and idempotent', () => {
  const intent = validatePaperIntent({ decisionId: 12, instrument: 'NVDA', action: 'BUY', notional: 100 }, { tradable: true, maxNotional: 500 });
  const broker = createSimulator();
  assert.deepEqual(broker.submit(intent), broker.submit(intent));
  assert.throws(() => validatePaperIntent({ decisionId: 13, instrument: 'PRIVATE', action: 'BUY', notional: 100 }, { tradable: false }));
  assert.throws(() => validatePaperIntent({ decisionId: 14, instrument: 'NVDA', action: 'BUY', notional: 501 }, { tradable: true, maxNotional: 500 }));
});

test('archive reconciliation prioritizes recent usable events and is bounded', () => {
  const archive = new Database(':memory:');
  archive.exec('CREATE TABLE articles (id INTEGER PRIMARY KEY, event_id INTEGER, ingested_at TEXT, content TEXT, has_embedding INTEGER)');
  archive.prepare('INSERT INTO articles VALUES (1, 99, ?, ?, 1)').run(new Date().toISOString(), 'content');
  const intelligence = new Database(':memory:');
  initAutonomySchema(intelligence);
  const result = reconcileArchiveBatch(archive, intelligence, 1);
  assert.equal(result.scanned, 1);
  const job = intelligence.prepare("SELECT lane, priority FROM autonomy_jobs WHERE job_type='coordinator_event'").get();
  assert.equal(job.lane, 'live');
  assert.equal(job.priority, 100);
  const live = reconcileLiveBatch(archive, intelligence, 1);
  assert.equal(live.scanned, 1);
});

test('outcome calculation uses benchmark-relative return', () => {
  const outcome = calculateOutcome(
    { information_cutoff: '2026-01-02T00:00:00Z', horizon_days: 5, direction: 'positive' },
    [{ date: '2026-01-02', close: 100 }, { date: '2026-01-09', close: 110 }],
    [{ date: '2026-01-02', close: 100 }, { date: '2026-01-09', close: 105 }]
  );
  assert.equal(outcome.directionCorrect, 1);
  assert.equal(outcome.excessReturn, 0.05);
});

test('order intents require the explicit instrument allowlist', () => {
  const db = new Database(':memory:');
  initAutonomySchema(db);
  db.prepare("INSERT INTO autonomy_instruments(symbol, broker, active, tradable) VALUES ('NVDA', 'sim', 1, 1)").run();
  const proposal = db.prepare(`INSERT INTO autonomy_proposals(payload, information_cutoff, status) VALUES ('{}', datetime('now'), 'accepted')`).run();
  const prediction = db.prepare(`INSERT INTO autonomy_predictions(proposal_id, instrument, direction, event_type, horizon_days, information_cutoff, evidence_article_ids, learning_eligible, strategy_version) VALUES (?, 'NVDA', 'positive', 'test', 10, datetime('now'), '[1]', 1, 'test')`).run(proposal.lastInsertRowid);
  const decision = db.prepare(`INSERT INTO autonomy_decisions(prediction_id, action, rationale, strategy_version) VALUES (?, 'BUY', 'test', 'test')`).run(prediction.lastInsertRowid);
  const intent = createOrderIntent(db, decision.lastInsertRowid, 100, { maxNotional: 100 });
  assert.equal(intent.side, 'buy');
  assert.equal(db.prepare('SELECT status FROM autonomy_order_intents').get().status, 'shadow');
});