// syklus-rapport.test.mjs
// D5 steg 9: tertialrapport-generatoren. Tester tre bindende krav:
//   (1) committed og aspirational rapporteres HVER FOR SEG (okr-framework.md:557)
//   (2) de tre formateringsinvariantene (okr-offentlig-governance.md:148-156)
//   (3) hook-kontrakten mot hooks/scripts/coaching-hook.mjs:86-92
//
// Offline, zero-dep, node:test. Test-kilden holdes ASCII-ren (bash 3.2 set -u).

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

import { lesSyklus } from '../lib/syklus-data.mjs';
import { arsrapportDelIII, etatsstyringsunderlag, tertialrapport } from '../lib/syklus-rapport.mjs';

const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
const SYKLUS_DIR = join(ROOT, 'tests/fixtures/okf-realistic/syklus/T1-2026');
const NAA = '2026-05-01T10:00:00.000Z';

const rapport = () => tertialrapport(lesSyklus(SYKLUS_DIR), { naa: NAA });

// --- Invariantene gjelder HVER rapportform, ikke bare tertialrapporten ---
//
// Steg 9 hengte alle forbudene paa tertialrapporten. Da ville steg 11-12 levert
// to nye former med NULL dekning paa nettopp de vaktene som baerer doktrinen --
// og (5c), som forbyr generatoren aa utlede confidence, ville dekket 1 av 3
// former. Formene registreres her; en ny form arver hele invariant-settet ved aa
// staa i listen. Radform-vaktene (5a/5b) staar bevisst UTENFOR: de handler om
// tabellen coaching-hook.mjs teller, og aarsrapport/etatsstyring er ikke
// forpliktet til den tabellformen.
const FORMER = [
  ['tertial', (syklus, opts) => tertialrapport(syklus, opts)],
  ['arsrapport', (syklus, opts) => arsrapportDelIII(syklus, opts)],
  ['etatsstyring', (syklus, opts) => etatsstyringsunderlag(syklus, opts)],
];

const byggFor = (bygger, opts = {}) => bygger(lesSyklus(SYKLUS_DIR), { naa: NAA, ...opts });

// --- Hook-kontrakten: predikatene LESES fra hooken, aldri kopieres ---
//
// En kopiert regex beviser at testen er enig med seg selv. Ved aa hente
// literalene ut av coaching-hook.mjs' egen kilde blir en fremtidig endring i
// hooken en ROED suite her, i stedet for en stille inkompatibilitet.
// Hooken er i forbidden_paths for dette steget -- forbudt aa ENDRE, ikke aa LESE.
function hookPredikater() {
  const src = readFileSync(join(ROOT, 'hooks/scripts/coaching-hook.mjs'), 'utf8');
  const funnet = [...src.matchAll(/(\/(?:[^/\\\n]|\\.)+\/[gimsuy]*)\.test\(line\)/g)].map(
    (m) => m[1],
  );
  assert.equal(
    funnet.length,
    2,
    `parser-sanity: forventet 2 rad-predikater i coaching-hook.mjs, fant ${funnet.length}`,
  );
  const kompiler = (lit) => {
    const siste = lit.lastIndexOf('/');
    return new RegExp(lit.slice(1, siste), lit.slice(siste + 1));
  };
  return { radForm: kompiler(funnet[0]), fareOrd: kompiler(funnet[1]) };
}

const erKrRad = (linje) => /^\s*\|/.test(linje) && !/^\s*\|[\s|:-]+\|\s*$/.test(linje)
  && !/\|\s*KR\s*\|/.test(linje);

test('(1) committed og aspirational rapporteres hver for seg', () => {
  const md = rapport();
  assert.match(md, /^##\s+Committed/m, 'mangler committed-seksjon');
  assert.match(md, /^##\s+Aspirational/m, 'mangler aspirational-seksjon');
});

// okr-framework.md:557 -- aa aggregere de to typene til ett tall blander to
// maalestokker og gjoer resultatet tvetydig.
for (const [navn, bygger] of FORMER) {
  test(`(1b/${navn}) rapportformen emitterer ingen felles samlet score`, () => {
    const offenders = byggFor(bygger).split('\n').filter((l) => /samlet\s+score/i.test(l));
    assert.deepEqual(offenders, [], `felles aggregat funnet:\n${offenders.join('\n')}`);
  });
}

test('(2a) invariant 1: typen er merket i rapporteringen', () => {
  const md = rapport();
  assert.match(md, /committed/i);
  assert.match(md, /aspirational/i);
});

test('(2b) invariant 2: committed rapporteres binaert mot kravet', () => {
  const md = rapport();
  // Avvik-kolonnen finnes, og tunnel-KR2 (17 av 20) er et avvik selv om
  // scoren er 0.63 -- et krav er naadd eller ikke.
  assert.match(md, /\|\s*Avvik\s*\|/, 'mangler Avvik-kolonne for committed');
  const rad = md.split('\n').find((l) => l.includes('oppgradert sikkerhetsutrustning'));
  assert.ok(rad, 'fant ikke committed-KR-raden');
  assert.match(rad, /\|\s*Ja\s*\|/, 'committed under target maa merkes som avvik');
});

for (const [navn, bygger] of FORMER) {
  test(`(2c/${navn}) invariant 3: skalaen forklares, og score konverteres ikke til prosent`, () => {
    const md = byggFor(bygger);
    assert.match(md, /skala/i, 'score-skalaen maa forklares eksplisitt');
    const prosentPaaScore = md.split('\n').filter((l) => /score[^|\n]*%|%[^|\n]*score/i.test(l));
    assert.deepEqual(prosentPaaScore, [], 'score skal ikke presenteres som prosent maaloppnaaelse');
  });

  // B-2-kanten moetes her av DATA (fixturens kr1 har target == baseline).
  // Uten en eksplisitt literal ville cellen blitt "undefined" eller kastet.
  test(`(3/${navn}) udefinert score rendres som en literal, ikke som undefined eller NaN`, () => {
    const md = byggFor(bygger);
    assert.match(md, /udefinert/, 'target == baseline maa rendres som "udefinert"');
    assert.doesNotMatch(md, /undefined|NaN/, 'raa JS-verdier lekket til rapporten');
  });

  test(`(4/${navn}) determinisme: to kjoeringer med samme naa gir byte-identisk streng`, () => {
    assert.equal(byggFor(bygger), byggFor(bygger));
  });
}

test('(4b) klokke-soemmen: OKR_NOW styrer tidsstempelet', (t) => {
  const forrige = process.env.OKR_NOW;
  t.after(() => {
    if (forrige === undefined) delete process.env.OKR_NOW;
    else process.env.OKR_NOW = forrige;
  });
  process.env.OKR_NOW = '2026-06-15T08:00:00.000Z';
  const md = tertialrapport(lesSyklus(SYKLUS_DIR));
  assert.match(md, /2026-06-15T08:00:00\.000Z/);
});

// --- (5) Hook-kontrakten, tredelt ---

test('(5a) hook-kontrakt: hver KR-rad matcher hookens radform', () => {
  const { radForm } = hookPredikater();
  const rader = rapport().split('\n').filter(erKrRad);
  assert.ok(rader.length >= 4, `parser-sanity: fant ${rader.length} KR-rader`);
  const avvikende = rader.filter((l) => !radForm.test(l));
  assert.deepEqual(avvikende, [], `rader hooken ikke kan telle:\n${avvikende.join('\n')}`);
});

test('(5b) hook-kontrakt: en kanonisk etikett i Confidence-cellen goer raden tellbar', () => {
  const { radForm, fareOrd } = hookPredikater();
  const rad = rapport().split('\n').filter(erKrRad)[0];
  // Confidence er siste kolonne og staar tom by design -- fyll den slik
  // /okr:sporing ville gjort det.
  const fylt = rad.replace(/\|\s*\|\s*$/, '| At Risk |');
  assert.notEqual(fylt, rad, 'fant ingen tom Confidence-celle aa fylle');
  assert.ok(radForm.test(fylt) && fareOrd.test(fylt), 'hooken ville ikke telt den fylte raden');
});

// LOAD-BEARING. Generatoren eier aritmetikk, aldri confidence:
// okr-framework.md:563 gjoer confidence-tabellen til eneste sannhetskilde, og
// okr-calculator.md:249 avviser mekanisk utledning eksplisitt ("ETT innspill
// ... ikke som en mekanisk regel"). En fremtidig sesjon som "hjelpsomt" utleder
// et trafikklys fra score ville oppfunnet en terskel doktrinen forbyr.
for (const [navn, bygger] of FORMER) {
  test(`(5c/${navn}) generatoren emitterer aldri en confidence-etikett selv`, () => {
    const { fareOrd } = hookPredikater();
    const offenders = byggFor(bygger).split('\n').filter((l) => fareOrd.test(l));
    assert.deepEqual(
      offenders,
      [],
      `generatoren utledet confidence mekanisk -- forbudt av okr-calculator.md:249:\n${offenders.join('\n')}`,
    );
  });
}

test('(6) tertialrapport kaster ved tom eller ufullstendig syklus', () => {
  assert.throws(() => tertialrapport({ id: 'T1-2026', okrer: [] }), /ingen OKR/i);
  assert.throws(() => tertialrapport(undefined), /syklus/i);
});

// --- (8) Aarsrapport del III (steg 11) ---
//
// Ankeret er okr-offentlig-governance.md:125-133: del III «Aarets aktiviteter og
// resultater» er hovedplassen for OKR i den statlige aarsrapporten.
//
// Antipatternet generatoren maa unngaa er kildebelagt i primaerkilden:
// Riksrevisjonen (2020), «Undersoekelse av etats- og virksomhetsstyringen av NIBIO»,
// del av Dokument 1 (2020-2021) s. 107 -- framstillingen «synliggjoer i mindre grad
// NIBIOs analyser av maaloppnaaelsen og framstaar som et oeyeblikksbilde av NIBIOs
// aktiviteter og resultater». En generator som bare dumper tabeller PRODUSERER det
// oeyeblikksbildet. Derfor RESERVERER den plassen til vurderingen -- og fyller den
// aldri selv, siden en vurdering av maaloppnaaelse krever skjoenn.

const delIII = (opts = {}) => arsrapportDelIII(lesSyklus(SYKLUS_DIR), { naa: NAA, ...opts });

// Seksjonskropp: linjene mellom en overskrift og neste overskrift paa samme
// eller hoeyere nivaa.
function seksjonsKropp(md, overskrift) {
  const linjer = md.split('\n');
  const start = linjer.findIndex((l) => l.trim() === overskrift);
  if (start === -1) return null;
  const niva = overskrift.match(/^#+/)[0].length;
  const kropp = [];
  for (const linje of linjer.slice(start + 1)) {
    const m = /^(#+)\s/.exec(linje);
    if (m && m[1].length <= niva) break;
    kropp.push(linje);
  }
  return kropp.join('\n').trim();
}

test('(8a) del III bygger paa aarsrapportens eget anker og en seksjon per Objective', () => {
  const md = delIII();
  assert.match(md, /[Aa]arets aktiviteter og resultater/, 'del III-ankeret mangler');
  const objectives = md.split('\n').filter((l) => /^##\s+(?!Flerarig|Aspirational|Avvik)/.test(l));
  assert.equal(objectives.length, 2, `forventet 2 Objective-seksjoner, fant ${objectives.length}`);
  assert.match(md, /Trafikksikkerhet og tunnelsikkerhet/);
  assert.match(md, /Digitalisering av tjenester/);
});

test('(8b) hvert Objective reserverer et vurderingsfelt generatoren ikke fyller', () => {
  const md = delIII();
  const felt = md.split('\n').filter((l) => /^###\s+Vurdering av maaloppnaaelse\s*$/.test(l));
  assert.equal(felt.length, 2, `forventet ett vurderingsfelt per Objective, fant ${felt.length}`);

  const kropp = seksjonsKropp(md, '### Vurdering av maaloppnaaelse');
  assert.ok(kropp, 'fant ingen kropp under vurderingsfeltet');
  // Plassholderen er merket som plassholder, ikke skrevet som en vurdering.
  assert.match(kropp, /^\[/, 'vurderingsfeltet maa staa som en merket plassholder');
  assert.match(kropp, /\]$/, 'plassholderen maa vaere avgrenset');
  assert.match(kropp, /[Ff]ylles ut av virksomheten/, 'plassholderen maa si hvem som fyller den');
  // En generator som «hjelpsomt» skrev inn tall eller en konklusjon ville
  // gjort seg til vurderingsinstans. Ingen tall i feltet = ingen vurdering.
  assert.doesNotMatch(kropp, /\d/, `generatoren fylte vurderingsfeltet med data:\n${kropp}`);
});

test('(8c) flerarig perspektiv kommer fra historikk, og oppfinnes ikke uten data', () => {
  const utenHistorikk = delIII();
  assert.doesNotMatch(
    utenHistorikk,
    /^##\s+Flerarig perspektiv/m,
    'uten historikk skal seksjonen utelates, ikke staa tom',
  );

  const md = delIII({
    historikk: [
      { tittel: 'Retrospektiv T3-2025', fil: 'retrospektiv-T3-2025.md' },
      { tittel: 'Retrospektiv T2-2025', fil: 'retrospektiv-T2-2025.md' },
    ],
  });
  assert.match(md, /^##\s+Flerarig perspektiv/m, 'historikk skal gi et flerarig perspektiv');
  const kropp = seksjonsKropp(md, '## Flerarig perspektiv');
  assert.match(kropp, /Retrospektiv T3-2025/);
  assert.match(kropp, /Retrospektiv T2-2025/);
  // DFOe-notat 2026:2 kap. 5.3.3 (s. 61): det ettaarige omtales i liten grad i
  // flerarig perspektiv. Generatoren peker paa materialet -- den sammenligner ikke
  // sykluser den ikke har tall fra.
  assert.doesNotMatch(kropp, /\d\.\d\d/, 'generatoren skal ikke regne trend paa tvers av sykluser');
});

test('(8d) arsrapportDelIII kaster ved tom eller ufullstendig syklus', () => {
  assert.throws(() => arsrapportDelIII({ id: 'T1-2026', okrer: [] }), /ingen OKR/i);
  assert.throws(() => arsrapportDelIII(undefined), /syklus/i);
});

// --- (9) Etatsstyringsmoete-underlag (steg 12) ---
//
// Bygget paa styringsdialog-kapittelet i okr-offentlig-governance.md:96-114.
// Hjemmelen for styringsparametere er bestemmelser om oekonomistyring i staten
// («bestemmelsene») punkt 1.5, gjengitt i DFOe-notat 2026:2 s. 49 (fn. 228).

const underlag = (opts = {}) => etatsstyringsunderlag(lesSyklus(SYKLUS_DIR), { naa: NAA, ...opts });

test('(9a) underlaget skiller committed og aspirational', () => {
  const md = underlag();
  assert.match(md, /^###?\s+Committed Key Results/m, 'mangler committed-seksjon');
  assert.match(md, /^###?\s+Aspirational Key Results/m, 'mangler aspirational-seksjon');
});

// F-j fjernet «2-4 etatsstyringsmoeter per aar» fordi paastanden ikke lot seg
// verifisere. Den disiplinen gjelder generatoren ogsaa: antall og form fastsettes
// i departementets hovedinstruks, og et underlag som paastaar en kadens
// foregriper noe det ikke kan vite.
test('(9b) underlaget hardkoder ingen moetefrekvens', () => {
  const md = underlag();
  const paastander = md.split('\n').filter(
    (l) => /(\d+|to|tre|fire)\s*(-\s*\d+\s*)?(etatsstyrings)?m[o]+ter\b/i.test(l)
      || /m[o]+ter?\s+(per|i)\s+(aar|halvaar)/i.test(l)
      || /(halvaarlig|kvartalsvis|maanedlig|ukentlig)[^\n]{0,20}m[o]+te/i.test(l),
  );
  assert.deepEqual(paastander, [], `hardkodet moetefrekvens:\n${paastander.join('\n')}`);
  // Den positive motparten: underlaget sier hvor kadensen faktisk fastsettes.
  assert.match(md, /hovedinstruks/i, 'underlaget maa peke paa hovedinstruksen for antall og form');
});

test('(9c) styringsparametere kobles mot tildelingsbrevet, og oppfinnes ikke', () => {
  const md = underlag();
  const kropp = seksjonsKropp(md, '## Styringsparametere mot tildelingsbrevets krav');
  assert.ok(kropp, 'mangler seksjonen som kobler Objectives til tildelingsbrevets krav');
  assert.match(kropp, /tildelingsbrev/i);
  // Generatoren leser ikke tildelingsbrevet -- den har bare syklusdataene. Da er
  // koblingen et felt den RESERVERER, aldri et den fyller. Hvert Objective staar
  // i tabellen; kravet ved siden av er tomt.
  assert.match(kropp, /Trafikksikkerhet og tunnelsikkerhet/);
  assert.match(kropp, /Digitalisering av tjenester/);
  assert.match(kropp, /[Ff]ylles ut/, 'koblingen maa vaere merket som utfylles av virksomheten');
});

test('(9d) etatsstyringsunderlag kaster ved tom eller ufullstendig syklus', () => {
  assert.throws(() => etatsstyringsunderlag({ id: 'T1-2026', okrer: [] }), /ingen OKR/i);
  assert.throws(() => etatsstyringsunderlag(undefined), /syklus/i);
});

// --- (10) Sandbagging-vakten (steg 13) ---
//
// Briefens navngitte suksesskriterium: en aspirational-OKR med lav score
// presenteres ALDRI som avvik. Regelen staar i okr-offentlig-governance.md:148-156;
// her far den mekanisk handhevelse i alle tre rapportformene.
//
// Vakten er bygget i tre ledd, og rekkefolgen er ikke tilfeldig:
//   (10a) POSITIV  -- et committed KR under kravet STAAR i avviks-seksjonen.
//                     Uten dette leddet ville (10b) bestaatt trivielt paa en
//                     seksjon som ikke finnes eller er tom, og vakten vaert prosa.
//   (10b) NEGATIV  -- fixturens aspirational-KR med lav score staar der ikke.
//   (10c) MUTASJON -- samme KR, flyttet til committed, DUKKER OPP. Det beviser at
//                     filteret henger paa TYPEN og ikke paa navnet, og at
//                     seksjonslokatoren i (10b) faktisk fant noe aa lete i.
//
// De tre formene har strukturelt ulike avviks-regioner, saa lokatoren ankrer paa
// overskriftsformen (`## Avvik...`), som er felles.

function avvikKropp(md) {
  const overskrift = md.split('\n').find((l) => /^##\s+Avvik/.test(l));
  assert.ok(overskrift, 'rapportformen har ingen avviks-seksjon aa filtrere');
  const kropp = seksjonsKropp(md, overskrift.trim());
  assert.ok(kropp && kropp.length > 0, 'avviks-seksjonen er tom');
  return kropp;
}

// Fixturens KR-er, med de rollene steg 7 ga dem.
const COMMITTED_UNDER_KRAV = 'Tunneler med oppgradert sikkerhetsutrustning';
const ASPIRATIONAL_LAV_SCORE = ['Andel digitale soeknader', 'Gjennomsnittlig saksbehandlingstid'];

for (const [navn, bygger] of FORMER) {
  test(`(10a/${navn}) committed KR under kravet STAAR i avviks-seksjonen`, () => {
    const kropp = avvikKropp(byggFor(bygger));
    assert.match(
      kropp,
      new RegExp(COMMITTED_UNDER_KRAV),
      `committed KR under kravet mangler i avviks-seksjonen:\n${kropp}`,
    );
  });

  test(`(10b/${navn}) aspirational KR med lav score staar IKKE i avviks-seksjonen`, () => {
    const kropp = avvikKropp(byggFor(bygger));
    for (const kr of ASPIRATIONAL_LAV_SCORE) {
      assert.doesNotMatch(
        kropp,
        new RegExp(kr),
        `aspirational KR presentert som avvik -- sandbagging-vakten er brutt:\n${kropp}`,
      );
    }
  });

  test(`(10c/${navn}) mutasjon: samme KR som committed ER et avvik`, () => {
    const syklus = lesSyklus(SYKLUS_DIR);
    const mutert = {
      ...syklus,
      okrer: syklus.okrer.map((okr) => ({
        ...okr,
        krer: okr.krer.map((kr) => ({ ...kr, type: 'committed' })),
      })),
    };
    const kropp = avvikKropp(bygger(mutert, { naa: NAA }));
    for (const kr of ASPIRATIONAL_LAV_SCORE) {
      assert.match(
        kropp,
        new RegExp(kr),
        `filteret henger ikke paa typen -- KR-et uteble ogsaa som committed:\n${kropp}`,
      );
    }
  });

  // Uten den kausale begrunnelsen er vakten en norm mottakeren kan overproeve.
  // Bogsnes' poeng (okr-framework.md:158-161) er at re-bundling av
  // aspirational-scoren i rapporteringen henter sandbaggingen tilbake
  // strukturelt -- det argumentet holder for en Riksrevisjon-leser.
  test(`(10d/${navn}) rapporten baerer forventningen til aspirational, ikke bare tallet`, () => {
    const md = byggFor(bygger);
    assert.match(md, /0\.7/, 'forventningen om ~0.7 maa staa eksplisitt');
    assert.match(md, /sandbagging/i, 'begrunnelsen for at lav aspirational-score ikke er avvik mangler');
  });
}

// Avviks-seksjonen viser til «forventningen til aspirational under». Den
// seksjonen finnes bare naar syklusen HAR aspirational-KR. En syklus med bare
// committed -- fullt lovlig, og typisk for en ren etterlevelses-syklus -- ville
// faatt et styringsdokument som peker paa en seksjon som ikke er der. Fixturen
// kan ikke fange det; den har begge typene.
const KUN_COMMITTED = {
  id: 'T-kun-committed',
  okrer: [{
    fil: 'okr-etterlevelse.md',
    tittel: 'Etterlevelse',
    krer: [{ n: 1, navn: 'Palagte tilsyn gjennomfoert (antall)', baseline: 0, target: 12, naa: 9, type: 'committed' }],
  }],
};

for (const [navn, bygger] of FORMER) {
  test(`(10f/${navn}) ingen henvisning til en aspirational-seksjon som ikke finnes`, () => {
    const md = bygger(KUN_COMMITTED, { naa: NAA });
    const viser = /forventningen til aspirational under/i.test(md);
    const finnes = /^##+\s+Aspirational/m.test(md);
    assert.equal(
      viser && !finnes,
      false,
      'avviks-seksjonen viser til en aspirational-seksjon rapporten ikke har',
    );
  });
}

// Generatoren handhever regelen; governance-fila baerer begrunnelsen. Staar
// begrunnelsen bare i koden, kan en leser overproeve vakten uten aa moete
// argumentet -- og det er nettopp en Riksrevisjon-vendt leser som vil sporre.
test('(10e) governance-fila begrunner regelen kausalt, ikke bare normativt', () => {
  const doc = readFileSync(
    join(ROOT, 'skills/okr-offentlig-sektor/references/okr-offentlig-governance.md'),
    'utf8',
  );
  assert.match(doc, /re-bundl/i, 'den kausale mekanismen (re-bundling) mangler');
  assert.match(doc, /okr-framework\.md/, 'begrunnelsen maa peke til kanon, ikke duplisere den');
});

// --- (2d) Avvik-kolonnen maa vaere retningsagnostisk ---
//
// `naa >= target` ser riktig ut for oppadgaaende maal og er FEIL for
// nedadgaaende: et krav om 5 dager, naa 11, gir 11 >= 5 = "ingen avvik" -- et
// brudd rapportert som etterlevd i et Riksrevisjon-vendt dokument. Fixturen kan
// ikke fange det (dens committed-KR er begge oppadgaaende, og dens nedadgaaende
// KR er aspirational, som kortslutter til "-"), saa syklusen konstrueres her.
// Retningen hoerer hjemme i beregnScore, som allerede haandterer den.
const NEDADGAAENDE = {
  id: 'T-avvik',
  okrer: [{
    fil: 'okr-avvik.md',
    tittel: 'Nedadgaaende krav',
    krer: [
      { n: 1, navn: 'Saksbehandlingstid (dager)', baseline: 14, target: 5, naa: 11, type: 'committed' },
      { n: 2, navn: 'Alvorlige hendelser (antall)', baseline: 0, target: 0, naa: 3, type: 'committed' },
      { n: 3, navn: 'Naadd krav (dager)', baseline: 14, target: 5, naa: 4, type: 'committed' },
    ],
  }],
};

const avvikFor = (navn) => {
  const rad = tertialrapport(NEDADGAAENDE, { naa: NAA }).split('\n').find((l) => l.includes(navn));
  assert.ok(rad, `fant ikke raden for ${navn}`);
  return rad.split('|').map((c) => c.trim())[6];
};

test('(2d) committed nedadgaaende KR under kravet merkes som avvik', () => {
  assert.equal(avvikFor('Saksbehandlingstid'), 'Ja', 'naa 11 mot krav 5 er et avvik');
});

test('(2d2) committed KR med target == baseline avviker naar naa ikke er lik kravet', () => {
  assert.equal(avvikFor('Alvorlige hendelser'), 'Ja', '3 hendelser mot krav 0 er et avvik');
});

test('(2d3) committed KR som naar kravet merkes ikke som avvik', () => {
  assert.equal(avvikFor('Naadd krav'), 'Nei', 'naa 4 mot krav 5 (nedadgaaende) er oppfylt');
});

// Rapporten sier selv at "en score under 1.0 er et avvik som skal forklares".
// Avvik-kolonnen maa aldri motsi den setningen paa samme rad.
test('(2d4) Avvik-kolonnen motsier ikke rapportens egen score-setning', () => {
  const md = tertialrapport(NEDADGAAENDE, { naa: NAA });
  const motsigelser = md.split('\n').filter((l) => {
    const c = l.split('|').map((x) => x.trim());
    if (c.length < 8 || c[6] !== 'Nei') return false;
    return c[5] !== 'udefinert' && Number(c[5]) < 1;
  });
  assert.deepEqual(motsigelser, [], `score < 1.0 merket som ikke-avvik:\n${motsigelser.join('\n')}`);
});

// --- (7) CLI-kontrakten (steg 10) ---
//
// Testet BEGGE VEIER i samme fil: direkte import for atferd, execFileSync for
// exit-koden -- fordi exit-koden ER kontrakten kommandofila mapper til norsk
// brukertekst. En atferdstest alene ville ikke fanget at 1 og 2 byttet plass.
// Moenster: tests/innboks-ingest.test.mjs (execFileSync for exit-kode).

const CLI = join(ROOT, 'scripts/syklus-rapport.mjs');

async function kjoerCli(args, opts = {}) {
  const { execFileSync } = await import('node:child_process');
  try {
    const stdout = execFileSync(process.execPath, [CLI, ...args], {
      encoding: 'utf8',
      stdio: ['ignore', 'pipe', 'pipe'],
      env: { ...process.env, OKR_NOW: NAA, ...(opts.env ?? {}) },
    });
    return { code: 0, stdout };
  } catch (e) {
    return { code: e.status, stdout: e.stdout ?? '', stderr: e.stderr ?? '' };
  }
}

// Egen kopi av syklusen per test som skriver -- CLI-en persisterer, og en test
// skal aldri skitne til fixturen den delte med de andre testene.
async function midlertidigSyklus(filer) {
  const { mkdtempSync, writeFileSync, mkdirSync, copyFileSync, readdirSync } = await import('node:fs');
  const { tmpdir } = await import('node:os');
  const rot = mkdtempSync(join(tmpdir(), 'okr-rapport-'));
  const dir = join(rot, 'T1-2026');
  mkdirSync(dir);
  if (filer) {
    for (const [navn, innhold] of Object.entries(filer)) writeFileSync(join(dir, navn), innhold);
  } else {
    for (const f of readdirSync(SYKLUS_DIR)) copyFileSync(join(SYKLUS_DIR, f), join(dir, f));
  }
  return { rot, dir };
}

test('(7a) CLI: exit 2 ved feil aritet', async () => {
  assert.equal((await kjoerCli([])).code, 2);
  assert.equal((await kjoerCli([SYKLUS_DIR])).code, 2);
});

// Alle tre formene er implementert etter steg 12; den gjenvaerende bruksfeilen er
// en form som ikke finnes. Meldingen navngir de gyldige formene, saa exit 2 kan
// handteres uten aa lese kildekoden.
test('(7b) CLI: exit 2 ved ukjent form, med formene navngitt', async () => {
  const r = await kjoerCli([SYKLUS_DIR, 'tullball']);
  assert.equal(r.code, 2);
  for (const form of ['tertial', 'arsrapport', 'etatsstyring']) {
    assert.match(r.stderr, new RegExp(form), `feilmeldingen mangler formen ${form}`);
  }
});

test('(7c) CLI: exit 2 naar syklus-katalogen ikke finnes', async () => {
  assert.equal((await kjoerCli([join(ROOT, 'finnes-ikke'), 'tertial'])).code, 2);
});

test('(7d) CLI: exit 1 ved ufullstendig syklusdata', async (t) => {
  const { rmSync } = await import('node:fs');
  const { rot, dir } = await midlertidigSyklus({
    'okr-ufullstendig.md': ['---', 'type: OKR', 'title: Ufullstendig', 'kr1_navn: Mangler tall', 'kr1_baseline: 3', '---', '# Ufullstendig', ''].join('\n'),
  });
  t.after(() => rmSync(rot, { recursive: true, force: true }));
  const r = await kjoerCli([dir, 'tertial']);
  assert.equal(r.code, 1, 'domenefeil skal gi exit 1, ikke 2');
  assert.match(r.stderr, /kr1/i);
});

test('(7e) CLI: exit 0 og fil paa disk ved gyldig input', async (t) => {
  const { rmSync, existsSync, readFileSync: les } = await import('node:fs');
  const { rot, dir } = await midlertidigSyklus();
  t.after(() => rmSync(rot, { recursive: true, force: true }));
  const r = await kjoerCli([dir, 'tertial']);
  assert.equal(r.code, 0, `forventet exit 0, fikk ${r.code}: ${r.stderr ?? ''}`);
  const ut = join(dir, 'rapport-tertial.md');
  assert.ok(existsSync(ut), 'rapporten ble ikke skrevet');
  const innhold = les(ut, 'utf8');
  assert.match(innhold, /^---\ntype: Status\n/, 'skrevet fil mangler OKF-frontmatter');
  assert.match(innhold, /## Committed Key Results/);
});

// --- (7g/7h) historikk-stien er avledet, og avledningen er en determinisme-risiko ---
//
// historikk/ er SOESKEN av syklus/, altsaa <syklusDir>/../../historikk. Regnet ut
// blindt ville en syklus-katalog utenfor et OKR-tre (som testenes tmp-kopi) pekt paa
// en vilkaarlig katalog paa maskinen -- og rapporten ville variert med hva som
// tilfeldigvis laa der. Derfor avledes historikk KUN naar foreldrekatalogen faktisk
// heter `syklus`. Begge grenene testes: uten tre (7g) og med tre (7h).

test('(7g) CLI: arsrapport skrives, og uten OKR-tre utledes ingen historikk', async (t) => {
  const { rmSync, readFileSync: les } = await import('node:fs');
  const { rot, dir } = await midlertidigSyklus();
  t.after(() => rmSync(rot, { recursive: true, force: true }));
  const r = await kjoerCli([dir, 'arsrapport']);
  assert.equal(r.code, 0, `forventet exit 0, fikk ${r.code}: ${r.stderr ?? ''}`);
  const innhold = les(join(dir, 'rapport-arsrapport.md'), 'utf8');
  assert.match(innhold, /^---\ntype: Status\n/, 'skrevet fil mangler OKF-frontmatter');
  assert.match(innhold, /[Aa]arets aktiviteter og resultater/);
  assert.doesNotMatch(innhold, /^##\s+Flerarig perspektiv/m, 'historikk ble utledet utenfor et OKR-tre');
});

test('(7h) CLI: i et ekte OKR-tre leses historikk-katalogen, ikke index.md', async (t) => {
  const { rmSync, mkdirSync, mkdtempSync, writeFileSync, copyFileSync, readdirSync, readFileSync: les } = await import('node:fs');
  const { tmpdir } = await import('node:os');
  const rot = mkdtempSync(join(tmpdir(), 'okr-tre-'));
  const dir = join(rot, 'syklus', 'T1-2026');
  const hist = join(rot, 'historikk');
  mkdirSync(dir, { recursive: true });
  mkdirSync(hist);
  for (const f of readdirSync(SYKLUS_DIR)) copyFileSync(join(SYKLUS_DIR, f), join(dir, f));
  writeFileSync(join(hist, 'retrospektiv-T3-2025.md'), ['---', 'type: Retrospektiv', 'title: Retrospektiv T3-2025', '---', '# Retrospektiv T3-2025', ''].join('\n'));
  // index.md peker paa en fil som ikke finnes (samme dangling-kant som fixturen).
  // Leser generatoren index.md i stedet for katalogen, dukker den opp i rapporten.
  writeFileSync(join(hist, 'index.md'), ['# Historikk', '', '* [Retrospektiv T2-2025](retrospektiv-T2-2025.md) - finnes ikke', ''].join('\n'));
  t.after(() => rmSync(rot, { recursive: true, force: true }));

  assert.equal((await kjoerCli([dir, 'arsrapport'])).code, 0);
  const innhold = les(join(dir, 'rapport-arsrapport.md'), 'utf8');
  assert.match(innhold, /^##\s+Flerarig perspektiv/m, 'historikk-katalogen ble ikke lest');
  assert.match(innhold, /Retrospektiv T3-2025/);
  assert.doesNotMatch(innhold, /T2-2025/, 'en dangling index.md-lenke ble rapportert som materiale');
  assert.doesNotMatch(innhold, /index\.md/, 'index.md er navigasjon, ikke kildemateriale');
});

test('(7i) CLI: etatsstyring skrives til sin egen fil', async (t) => {
  const { rmSync, readFileSync: les } = await import('node:fs');
  const { rot, dir } = await midlertidigSyklus();
  t.after(() => rmSync(rot, { recursive: true, force: true }));
  const r = await kjoerCli([dir, 'etatsstyring']);
  assert.equal(r.code, 0, `forventet exit 0, fikk ${r.code}: ${r.stderr ?? ''}`);
  const innhold = les(join(dir, 'rapport-etatsstyring.md'), 'utf8');
  assert.match(innhold, /^---\ntype: Status\n/, 'skrevet fil mangler OKF-frontmatter');
  assert.match(innhold, /Styringsparametere mot tildelingsbrevets krav/);
  // Tre former, tre filnavn: en form som overskrev en annens fil ville gjort den
  // siste kjoeringen til den eneste som fantes.
  assert.equal(lesSyklus(dir).okrer.length, 2, 'rapporten ble lest som en OKR');
});

// Fixturens historikk er FLAT prosa-filer. Den EKTE formen kommer fra
// /okr:oppsett arkiver (commands/oppsett.md:514-518), som lager BEGGE deler:
// katalogen `historikk/[id]/` med syklusens filer, OG den flate
// `historikk/[id]-resultater.md` med sammendraget. Sammendraget er riktig
// granularitet for et flerarig perspektiv; katalogen er raamaterialet under.
// Uten denne testen ville fixtur, kode og (7h) vaert tre artefakter som er enige
// med hverandre -- og ingen av dem den kommandoen som faktisk skriver treet.
test('(7j) historikk leses fra arkiveringens EKTE form: sammendragsfil, ikke katalog', async (t) => {
  const { rmSync, mkdirSync, mkdtempSync, writeFileSync, copyFileSync, readdirSync, readFileSync: les } = await import('node:fs');
  const { tmpdir } = await import('node:os');
  const rot = mkdtempSync(join(tmpdir(), 'okr-arkiv-'));
  const dir = join(rot, 'syklus', 'T1-2026');
  const hist = join(rot, 'historikk');
  mkdirSync(dir, { recursive: true });
  mkdirSync(join(hist, 'T3-2025'), { recursive: true });
  for (const f of readdirSync(SYKLUS_DIR)) copyFileSync(join(SYKLUS_DIR, f), join(dir, f));
  // Kopien av syklusen ligger i katalogen; sammendraget flatt ved siden av.
  writeFileSync(join(hist, 'T3-2025', 'okr-gammel.md'), ['---', 'type: OKR', 'title: Gammel OKR', '---', ''].join('\n'));
  writeFileSync(join(hist, 'T3-2025-resultater.md'), ['---', 'type: Retrospektiv', 'title: Resultater T3-2025', '---', '# Resultater T3-2025', ''].join('\n'));
  t.after(() => rmSync(rot, { recursive: true, force: true }));

  assert.equal((await kjoerCli([dir, 'arsrapport'])).code, 0);
  const kropp = les(join(dir, 'rapport-arsrapport.md'), 'utf8');
  assert.match(kropp, /Resultater T3-2025/, 'sammendragsfila fra arkiveringen ble ikke funnet');
  // Den arkiverte syklus-katalogen er raamateriale, ikke en post i det flerarige
  // perspektivet -- og `[id]/` ender ikke paa .md, saa den filtreres bort som seg selv.
  assert.doesNotMatch(kropp, /Gammel OKR/, 'generatoren gikk inn i den arkiverte syklus-katalogen');
});

// Idempotens: rapporten skal kunne kjoeres om igjen uten aa endre bundlen, og
// uten aa bli lest som en OKR neste gang (filnavnet starter ikke med okr-).
test('(7f) CLI: to kjoeringer gir byte-identisk fil', async (t) => {
  const { rmSync, readFileSync: les } = await import('node:fs');
  const { rot, dir } = await midlertidigSyklus();
  t.after(() => rmSync(rot, { recursive: true, force: true }));
  await kjoerCli([dir, 'tertial']);
  const foerste = les(join(dir, 'rapport-tertial.md'), 'utf8');
  await kjoerCli([dir, 'tertial']);
  assert.equal(les(join(dir, 'rapport-tertial.md'), 'utf8'), foerste);
  assert.equal(lesSyklus(dir).okrer.length, 2, 'rapporten ble lest som en OKR');
});