// tests/kb-eval/test-skill-score.test.mjs
// Unit tests for the PURE skill-quality scoring lib (Spor D).
// scoreSkill(evalObj) consumes the object shape produced by eval.mjs's
// evalSkill() + attachSiblingOverlap() + merged judge results, and returns a
// weighted 0-100 score with a hard floor on the load-bearing criteria (K1, K10).
// See docs/skill-quality-scoring-plan.md §2 for the rubric->score mapping.

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { scoreSkill, TARGET, FLOOR_CAP } from '../../scripts/kb-eval/lib/skill-score.mjs';

// --- fixture builder: a fully-passing eval object (all sub-scores = 1) -------
function perfectEval(overrides = {}) {
  const base = {
    name: 'ms-ai-test',
    deterministic: {
      K2_descriptionFormat: { pass: true },
      K3_bodyLength: { bodyLines: 120, pass: true },
      K5_progressiveDisclosure: { namedRatio: 0.5, pass: true },
      K6_routingTable: { pass: true },
      refCountConsistency: { consistent: true, mismatches: [] },
      K9_timeSensitiveHints: { timeSensitiveTokenHits: 0 },
      K10_siblingScopeOverlap: { maxCombined: 2.0, worstSibling: 'x', pass: true, threshold: 7.0 },
    },
    judgeInputs: { description: 'desc', bodyLines: 120 },
    judge: {
      K1_triggerPrecision: { precision: 1, pass: true },
      K4_noDuplication: { score: 5, pass: true },
      K7_imperativeStyle: { ratio: 1, pass: true },
      K8_sourceCitation: { ratio: 1, pass: true },
      K9_noTimeSensitive: { pass: true, findings: [] },
    },
  };
  // shallow-merge deterministic + judge so a test can override one criterion
  return {
    ...base,
    ...overrides,
    deterministic: { ...base.deterministic, ...(overrides.deterministic || {}) },
    judge: overrides.judge === null ? null : { ...base.judge, ...(overrides.judge || {}) },
  };
}

test('scoreSkill — a fully-passing skill scores 100 and meets the target', () => {
  const r = scoreSkill(perfectEval());
  assert.equal(r.score, 100);
  assert.equal(r.meetsTarget, true);
  assert.equal(r.judged, true);
  assert.equal(r.floored, false);
  assert.equal(r.improvements.length, 0);
});

test('scoreSkill — TARGET is 90 and FLOOR_CAP is below it', () => {
  assert.equal(TARGET, 90);
  assert.ok(FLOOR_CAP < TARGET);
});

test('scoreSkill — failing K10 (deterministic floor) caps the score below target despite a perfect rest', () => {
  const r = scoreSkill(perfectEval({
    deterministic: { K10_siblingScopeOverlap: { maxCombined: 7.4, worstSibling: 'y', pass: false, threshold: 7.0 } },
  }));
  assert.equal(r.score, FLOOR_CAP, 'capped at the floor');
  assert.equal(r.floored, true);
  assert.equal(r.meetsTarget, false);
  assert.ok(r.improvements.some((i) => i.key === 'K10' && i.floor === true));
});

test('scoreSkill — failing K1 (judge floor) caps the score below target', () => {
  const r = scoreSkill(perfectEval({
    judge: { K1_triggerPrecision: { precision: 0.6, pass: false } },
  }));
  assert.equal(r.score, FLOOR_CAP);
  assert.equal(r.meetsTarget, false);
  assert.ok(r.improvements.some((i) => i.key === 'K1' && i.floor === true));
});

test('scoreSkill — partial credit: K3 over-length and K4 mid-score reduce the score proportionally', () => {
  const r = scoreSkill(perfectEval({
    deterministic: { K3_bodyLength: { bodyLines: 600, pass: false } }, // sub = 1-(600-500)/500 = 0.8
    judge: { K4_noDuplication: { score: 3, pass: false } },            // sub = 3/5 = 0.6
  }));
  // Neither K3 nor K4 is a floor criterion, so the score is the weighted mean, not capped.
  assert.ok(r.score < 100 && r.score > FLOOR_CAP, `expected high-but-imperfect, got ${r.score}`);
  assert.equal(r.floored, false);
  const k3 = r.criteria.find((c) => c.key === 'K3');
  const k4 = r.criteria.find((c) => c.key === 'K4');
  assert.ok(Math.abs(k3.sub - 0.8) < 1e-9, `K3 sub was ${k3.sub}`);
  assert.ok(Math.abs(k4.sub - 0.6) < 1e-9, `K4 sub was ${k4.sub}`);
});

test('scoreSkill — degrades gracefully when unjudged: judge criteria excluded, K10 floor still enforced', () => {
  const r = scoreSkill(perfectEval({ judge: null }));
  assert.equal(r.judged, false);
  assert.equal(r.provisional, true, 'K1 floor cannot be enforced without judge → provisional');
  // all deterministic criteria pass → score 100 over the available (det) set
  assert.equal(r.score, 100);
  // no judge criteria should appear as available
  assert.ok(!r.criteria.some((c) => c.available && c.source === 'judge'));
});

test('scoreSkill — unjudged + failing K10 still floors (deterministic floor independent of judge)', () => {
  const r = scoreSkill(perfectEval({
    judge: null,
    deterministic: { K10_siblingScopeOverlap: { maxCombined: 9.0, worstSibling: 'z', pass: false, threshold: 7.0 } },
  }));
  assert.equal(r.score, FLOOR_CAP);
  assert.equal(r.meetsTarget, false);
});

test('scoreSkill — improvements are sorted by weighted points lost (descending)', () => {
  const r = scoreSkill(perfectEval({
    deterministic: { K2_descriptionFormat: { pass: false } },   // weight 1, lose 1.0
    judge: { K4_noDuplication: { score: 0, pass: false } },     // weight 2, lose 2.0 -> first
  }));
  assert.ok(r.improvements.length >= 2);
  assert.equal(r.improvements[0].key, 'K4', 'biggest weighted loss first');
  for (let i = 1; i < r.improvements.length; i++) {
    assert.ok(r.improvements[i - 1].pointsLost >= r.improvements[i].pointsLost);
  }
});

test('scoreSkill — every improvement carries a concrete fix string', () => {
  const r = scoreSkill(perfectEval({
    deterministic: { K3_bodyLength: { bodyLines: 700, pass: false } },
  }));
  const k3 = r.improvements.find((i) => i.key === 'K3');
  assert.ok(k3 && typeof k3.fix === 'string' && k3.fix.length > 0);
});

test('scoreSkill — tolerates a null/garbage eval object without throwing', () => {
  assert.equal(scoreSkill(null), null);
  assert.equal(scoreSkill({}), null);
});