import { test } from 'node:test';
import assert from 'node:assert/strict';
import { aggregateLedger, classifyOrigin, decisionCents } from './aggregate';
import type { SignedDecisionLogEntry, SpendDecision, Provider } from '../types';
import type { ProvenanceProvider } from '../receipts/schema';

let seq = 0;
function entry(d: Partial<SpendDecision>): SignedDecisionLogEntry {
  const decision: SpendDecision = {
    decisionId: `d${seq}`,
    timestamp: '2026-07-10T14:00:00.000Z',
    action: 'allow',
    triggeredCap: null,
    triggeredScopeKey: null,
    projectedCents: 0,
    windowSpendBefore: 0,
    windowSpendAfter: 0,
    provider: 'openai',
    modelRequested: 'gpt-5',
    modelResolved: 'gpt-5',
    policyId: 'p',
    policyVersion: 1,
    enforcementMode: 'enforce',
    reasons: [],
    ...d,
  };
  return {
    sequence: seq++, decision, previousHash: '0'.repeat(64),
    entryHash: 'x', signature: 'y', signerFingerprint: 'f',
  };
}
function withProvenance(fam: ProvenanceProvider, route = 'api'): SpendDecision['provenance'] {
  return {
    model_identity: { provider: fam, model_id: 'm', model_version: '1', model_family: 'x', weights_origin_country: 'US' },
    hosting: { provider_route: route, jurisdiction_country: 'US', jurisdiction_region: 'us' },
    compliance: {
      baa_in_force: false, baa_vendor: null, hipaa_eligible: false, data_retention_days: null,
      data_residency_attested: false, foreign_origin_weight_flag: false,
      foreign_origin_consent_receipt_id: null, inference_billing: 'customer_managed',
    },
    captured_at: '2026-07-10T14:00:00.000Z',
  };
}

test('classifyOrigin: self-hosted provenance = dark, not inferred', () => {
  const d = entry({ provenance: withProvenance('self_hosted') }).decision;
  assert.deepEqual(classifyOrigin(d), { origin: 'dark', inferred: false });
});

test('classifyOrigin: open-weight family = dark; frontier family = frontier', () => {
  assert.equal(classifyOrigin(entry({ provenance: withProvenance('deepseek') }).decision).origin, 'dark');
  assert.equal(classifyOrigin(entry({ provenance: withProvenance('anthropic') }).decision).origin, 'frontier');
});

test('classifyOrigin: no provenance falls back to provider and is flagged inferred', () => {
  assert.deepEqual(classifyOrigin(entry({ provider: 'anthropic' }).decision), { origin: 'frontier', inferred: true });
  assert.deepEqual(classifyOrigin(entry({ provider: 'unknown' as Provider }).decision), { origin: 'dark', inferred: true });
});

test('decisionCents: blocked = 0, settled actual beats projection', () => {
  assert.equal(decisionCents(entry({ action: 'block', projectedCents: 500 }).decision), 0);
  assert.equal(decisionCents(entry({ projectedCents: 500, actualCents: 420 }).decision), 420);
  assert.equal(decisionCents(entry({ projectedCents: 500 }).decision), 500);
});

test('aggregate: dark share, savings, true-up, and buckets', () => {
  seq = 0;
  const entries = [
    entry({ action: 'allow', provider: 'anthropic', modelResolved: 'claude-5', projectedCents: 100, actualCents: 100, provenance: withProvenance('anthropic') }),
    entry({ action: 'allow', modelResolved: 'glm-5.2', projectedCents: 4, actualCents: 4, provider: 'unknown' as Provider, provenance: withProvenance('self_hosted', 'self-hosted-gpu') }),
    entry({ action: 'downgrade', provider: 'openai', modelResolved: 'gpt-5-mini', projectedCents: 200, actualCents: 20 }),
    entry({ action: 'block', provider: 'openai', modelResolved: 'gpt-5', projectedCents: 300 }),
    entry({ entryType: 'settlement', actualCents: 98, projectedCents: 0 }),
  ];
  const dash = aggregateLedger(entries, { verified: true, entries: entries.length });

  // 4 enforcement decisions (settlement not counted as a call)
  assert.equal(dash.totals.calls, 4);
  // spend = 100 + 4 + 20 + 0(blocked) = 124
  assert.equal(dash.totals.spentCents, 124);
  assert.equal(dash.totals.darkCents, 4);
  assert.equal(dash.totals.frontierCents, 120); // 100 anthropic + 20 downgraded openai(inferred frontier)
  assert.equal(dash.totals.darkSharePct, Math.round((4 / 124) * 1000) / 10);
  // savings = downgrade delta (200-20=180) + blocked projection (300) = 480
  assert.equal(dash.enforcement.estimatedSavedCents, 480);
  assert.equal(dash.enforcement.blocked, 1);
  assert.equal(dash.enforcement.downgraded, 1);
  // true-up: settled actual 98 vs reserved (100+4+200+300=604)
  assert.equal(dash.trueUp.settledCents, 98);
  assert.equal(dash.trueUp.reservedCents, 604);
  assert.equal(dash.trueUp.driftCents, 98 - 604);
  // integrity passthrough
  assert.equal(dash.integrity.verified, true);
  // model bucket present
  assert.ok(dash.byModel.find(b => b.key === 'claude-5' && b.cents === 100));
});

test('aggregate: empty ledger is safe', () => {
  const dash = aggregateLedger([]);
  assert.equal(dash.totals.calls, 0);
  assert.equal(dash.totals.darkSharePct, 0);
  assert.equal(dash.integrity.verified, false);
});