// okf-check.test.mjs
// Tester OKF-mekanismen (Step 6): okf-index genererer index.md per nivaa i ekte
// OKF-form, og okf-check validerer at hver konsept-fil baerer `type:`.
// okf-index kjoeres mot en TEMP-KOPI av okf-realistic (cpSync) saa de committede
// fixturene (lest read-only av okf-retrieval.test.mjs, m/ en bevisst dangling-link)
// forblir uroert. okf-check kjoeres som subprosess for aa fange exit-koden (kontrakt).
// Zero npm deps. Plassert i tests/ (samme moenster som org-profile-write.test.mjs).

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import {
  mkdtempSync, cpSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync, mkdirSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { generateIndexes } from '../scripts/okf-index.mjs';

const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
const CHECK = join(ROOT, 'scripts', 'okf-check.mjs');
const REALISTIC = join(ROOT, 'tests', 'fixtures', 'okf-realistic');

function tmpRoot() {
  return mkdtempSync(join(tmpdir(), 'okf-'));
}

// Kjoer okf-check som subprosess; fang non-zero exit (execFileSync kaster da).
// extra: ekstra CLI-flagg (f.eks. '--strict-ingest').
function runCheck(root, ...extra) {
  try {
    const stdout = execFileSync('node', [CHECK, root, ...extra], { encoding: 'utf8' });
    return { status: 0, stdout };
  } catch (e) {
    return { status: e.status ?? 1, stdout: `${e.stdout || ''}${e.stderr || ''}` };
  }
}

// Bygg en ren ingestion-bundle: kanoniske vokab-typer + en trygg, on-disk relasjon.
function buildCleanIngest(dir) {
  mkdirSync(join(dir, 'strategisk-kontekst'), { recursive: true });
  mkdirSync(join(dir, 'dokumenter'), { recursive: true });
  writeFileSync(join(dir, 'index.md'), '# Bundle\n\nokf_version: kb-layout-2026-06\n');
  writeFileSync(
    join(dir, 'strategisk-kontekst', 'tildelingsbrev.md'),
    '---\ntype: Tildelingsbrev\nresource: urn:okr:tb\ntitle: Tildelingsbrev 2026\n'
      + "description: Styringssignaler.\ntimestamp: '2026-01-15T09:00:00+00:00'\n---\n"
      + '# Tildelingsbrev 2026\n\nHoveddokument.\n',
  );
  writeFileSync(
    join(dir, 'dokumenter', 'notat.md'),
    '---\ntype: Notat\nresource: urn:okr:notat\ntitle: Internt notat\n'
      + "description: Et notat.\ntimestamp: '2026-02-01T09:00:00+00:00'\n---\n"
      + '# Internt notat\n\n## Relaterte dokumenter\n\n'
      + '- [Tildelingsbrev 2026](/strategisk-kontekst/tildelingsbrev.md)\n',
  );
}

// Alle kataloger under root (inkl. root selv), rekursivt.
function allDirs(root) {
  const out = [root];
  for (const e of readdirSync(root, { withFileTypes: true })) {
    if (e.isDirectory()) out.push(...allDirs(join(root, e.name)));
  }
  return out;
}

// Byte-snapshot av alle index.md under root (for idempotens-sammenligning).
function snapshotIndexes(root) {
  return allDirs(root)
    .map((d) => join(d, 'index.md'))
    .filter((p) => existsSync(p))
    .sort()
    .map((p) => `${p}\n${readFileSync(p, 'utf8')}`)
    .join('\n=====\n');
}

// --- okf-index ---

test('okf-index: genererer index.md per nivaa (hver katalog) i temp-kopi', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    generateIndexes(dir);
    for (const d of allDirs(dir)) {
      assert.ok(existsSync(join(d, 'index.md')), `index.md skal finnes i ${d}`);
    }
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-index: entry-linjer matcher OKF-form `* [t](l) - d`, uten frontmatter', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    generateIndexes(dir);
    const sk = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
    assert.ok(!sk.startsWith('---'), 'index.md skal IKKE ha frontmatter');
    const entries = sk.split('\n').filter((l) => l.startsWith('* '));
    assert.ok(entries.length >= 3, 'strategisk-kontekst skal liste sine 3 konsept-filer');
    for (const l of entries) {
      assert.match(l, /^\* \[[^\]]+\]\([^)]+\) - .+$/, `OKF-form: ${l}`);
    }
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-index: rot-index baerer okf_version, undernivaa gjoer ikke', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    generateIndexes(dir);
    const root = readFileSync(join(dir, 'index.md'), 'utf8');
    assert.match(root, /^okf_version:\s*\S+/m, 'rot-index skal ha okf_version');
    const sub = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
    assert.ok(!/^okf_version:/m.test(sub), 'undernivaa skal IKKE ha okf_version');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-index: konsept-tittel/beskrivelse hentes fra frontmatter', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    generateIndexes(dir);
    const sk = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
    assert.match(
      sk,
      /\* \[Tildelingsbrev 2026\]\(tildelingsbrev-2026\.md\) - Departementets/,
      'entry skal bruke frontmatter-title + -description + lenke til konsept-fil',
    );
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

// --- okf-check ---

test('okf-check: gyldig bundle (alle konsept har type:) -> exit 0, «0 filer uten type:»', () => {
  const { status, stdout } = runCheck(REALISTIC);
  assert.equal(status, 0, 'gyldig bundle skal gi exit 0');
  assert.match(stdout, /0 filer uten type:/, 'skal rapportere null manglende type');
});

test('okf-check: konsept-fil uten type: -> exit != 0 + teller > 0 + navngir filen', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    writeFileSync(
      join(dir, 'strategisk-kontekst', 'mangler-type.md'),
      '---\ntitle: Uten type\ndescription: En konsept-fil uten paakrevd type.\n---\n# Uten type\n',
    );
    const { status, stdout } = runCheck(dir);
    assert.notEqual(status, 0, 'type-loes fil skal gi exit != 0');
    assert.match(stdout, /[1-9]\d* filer uten type:/, 'teller skal vaere > 0');
    assert.match(stdout, /mangler-type\.md/, 'skal navngi den feilende filen');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-check: rapporterer okf_version fra rot-index', () => {
  const { stdout } = runCheck(REALISTIC);
  assert.match(stdout, /okf_version:\s*kb-layout-2026-06/, 'skal ekko okf_version for menneskelig sammenligning');
});

// --- okf-check --strict-ingest (Step 8): lukket vokab + lenke-allow-liste ---

test('okf-check --strict-ingest: ren ingestion-bundle (vokab-type + trygg on-disk relasjon) -> exit 0', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    const { status, stdout } = runCheck(dir, '--strict-ingest');
    assert.equal(status, 0, `ren bundle skal gi exit 0:\n${stdout}`);
    assert.match(stdout, /0 strict-ingest-feil/, 'skal rapportere null strict-feil');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-check --strict-ingest: type utenfor vokabular -> exit 1 + navngir filen', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    writeFileSync(
      join(dir, 'dokumenter', 'rar.md'),
      '---\ntype: Tilfeldig\ntitle: Rar\ndescription: x\n---\n# Rar\n',
    );
    const { status, stdout } = runCheck(dir, '--strict-ingest');
    assert.equal(status, 1, 'out-of-vocab type skal gi exit 1');
    assert.match(stdout, /rar\.md: type .* utenfor ingestion-vokabular/, 'skal navngi feilen');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-check --strict-ingest: usikker lenke (escape ut av bundle) -> exit 1', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    writeFileSync(
      join(dir, 'dokumenter', 'ond.md'),
      '---\ntype: Notat\ntitle: Ond\ndescription: x\n---\n# Ond\n\n- [exfil](../../../etc/passwd)\n',
    );
    const { status, stdout } = runCheck(dir, '--strict-ingest');
    assert.equal(status, 1, 'utrygg lenke skal gi exit 1');
    assert.match(stdout, /utrygg lenke/, 'skal rapportere utrygg lenke');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-check --strict-ingest: dangling bundle-lenke (trygg form, mangler on-disk) -> exit 1', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    writeFileSync(
      join(dir, 'dokumenter', 'henger.md'),
      '---\ntype: Notat\ntitle: Henger\ndescription: x\n---\n# Henger\n\n'
        + '- [Mangler](/strategisk-kontekst/finnes-ikke.md)\n',
    );
    const { status, stdout } = runCheck(dir, '--strict-ingest');
    assert.equal(status, 1, 'dangling lenke skal gi exit 1');
    assert.match(stdout, /dangling lenke/, 'skal rapportere dangling lenke');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-check --strict-ingest: lenke-baerende title -> exit 1', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    writeFileSync(
      join(dir, 'dokumenter', 'tittel.md'),
      '---\ntype: Notat\ntitle: "[Klikk her](http://evil.example)"\ndescription: x\n---\n# T\n',
    );
    const { status, stdout } = runCheck(dir, '--strict-ingest');
    assert.equal(status, 1, 'lenke-baerende title skal gi exit 1');
    assert.match(stdout, /lenke-baerende title/, 'skal rapportere lenke-baerende title');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

// --- walk-eksklusjon (Step 8): drop-zone + dot-kataloger skannes aldri ---

test('okf-check: raa filer i innboks/ og .cache/ ignoreres av walk (ingen falsk exit 1)', () => {
  const dir = tmpRoot();
  try {
    buildCleanIngest(dir);
    mkdirSync(join(dir, 'innboks'), { recursive: true });
    mkdirSync(join(dir, '.cache'), { recursive: true });
    // Raa filer UTEN type -- ville gitt exit 1 hvis walk ikke ekskluderte dem.
    writeFileSync(join(dir, 'innboks', 'raa.md'), '# Raa innboks-fil uten frontmatter\n');
    writeFileSync(join(dir, '.cache', 'c.md'), '# Cache uten type\n');
    const { status, stdout } = runCheck(dir);
    assert.equal(status, 0, `drop-zone/dot-filer skal ignoreres:\n${stdout}`);
    assert.match(stdout, /0 filer uten type:/, 'walk skal ikke telle drop-zone-filer');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

// --- okf-index herding (Step 9): saner title/desc + skip innboks/dot ---

test('okf-index: tittel/beskrivelse med ]/) + lenke saneres -> 2x byte-identisk + round-trip-trygg', () => {
  const dir = tmpRoot();
  try {
    mkdirSync(join(dir, 'dokumenter'), { recursive: true });
    writeFileSync(join(dir, 'index.md'), '# Bundle\n\nokf_version: kb-layout-2026-06\n');
    writeFileSync(
      join(dir, 'dokumenter', 'kr.md'),
      '---\ntype: OKR\ntitle: "KR1 [resultat] (maal) [lenke](http://x)"\n'
        + 'description: "Status (delvis) [ref](http://y)"\n---\n# KR\n',
    );
    generateIndexes(dir);
    const run1 = snapshotIndexes(dir);
    generateIndexes(dir);
    const run2 = snapshotIndexes(dir);
    assert.equal(run1, run2, 'generateIndexes skal vaere byte-idempotent');
    const idx = readFileSync(join(dir, 'dokumenter', 'index.md'), 'utf8');
    const entry = idx.split('\n').find((l) => l.startsWith('* '));
    assert.ok(entry, 'kr.md skal ha en entry');
    assert.match(entry, /^\* \[[^\]]*\]\([^)]+\)/, 'entry skal vaere round-trip-trygg OKF-form');
    assert.ok(!entry.includes('http'), 'injisert lenke skal vaere noytralisert');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test('okf-index: innboks/ + dot-katalog -> ingen egen index.md OG ikke listet i rot-index', () => {
  const dir = tmpRoot();
  try {
    cpSync(REALISTIC, dir, { recursive: true });
    mkdirSync(join(dir, 'innboks'), { recursive: true });
    mkdirSync(join(dir, '.cache'), { recursive: true });
    writeFileSync(join(dir, 'innboks', 'raa.md'), '# Raa\n');
    writeFileSync(join(dir, '.cache', 'c.md'), '# Cache\n');
    generateIndexes(dir);
    assert.ok(!existsSync(join(dir, 'innboks', 'index.md')), 'innboks/ skal ikke faa index.md');
    assert.ok(!existsSync(join(dir, '.cache', 'index.md')), 'dot-katalog skal ikke faa index.md');
    const root = readFileSync(join(dir, 'index.md'), 'utf8');
    assert.ok(!root.includes('innboks/index.md'), 'rot-index skal ikke liste innboks/ som peker');
    assert.ok(!root.includes('.cache/index.md'), 'rot-index skal ikke liste dot-katalog som peker');
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});