#!/usr/bin/env node
/**
 * assessment-log.mjs — Skills-assessment event logger (eSkill, HackerRank, Criteria, ...)
 *
 * "Received a skills assessment" is its own pipeline event — not Applied /
 * Interview / Rejected — so it gets logged structurally instead of buried in
 * free-text notes. Each event is an append-only observation, never mutated:
 *   { date, company, report#, platform, subject, threshold, score, stale_note }
 *
 * The staleness signal is candidate-observed and self-reported (e.g. "test
 * content references Adobe Acrobat 9, a 2008-era version") — an empty
 * stale_note means no staleness was observed, not that the bank is current.
 *
 * Log lives in data/assessments.tsv (user layer, append-only, created on first
 * `add`). Threshold/score are percentages; both optional — vendors often hide
 * the threshold, and some platforms never reveal the score.
 *
 * Take-home / demo-recording assignments (#5733) share the file as an optional
 * `kind` (default skills-test) plus trailing columns 9-14:
 *   kind, deadline, deliverable, requirements_url, submitted_at, proof
 * Rows from before this change have 8 or fewer cells and parse as skills-test.
 * The log stays append-only: recording a submission appends a second row for the
 * same company+report#+subject (`submit`), and the newest non-empty value wins
 * when `open` folds the rows. Nothing is ever submitted by this tool.
 *
 * Future work (out of scope here): fold per-vendor staleness rates into
 * analyze-patterns.mjs the way ATS channel yield is analyzed today.
 *
 * Run: node assessment-log.mjs add --company <name> [--report <num>] \
 *        --platform <vendor> --subject <topic> [--threshold <pct>] \
 *        [--score <pct>] [--stale "<observed staleness note>"]
 *      node assessment-log.mjs add --kind take-home --company <name> \
 *        --platform <channel> --subject <topic> --deadline <ISO with offset> \
 *        [--deliverable video|file|link] [--requirements-url <url>] \
 *        [--submitted-at <ISO>] [--proof "<text or path>"]
 *      node assessment-log.mjs submit --company <name> --subject <topic> \
 *        [--report <num>] --submitted-at <ISO> [--proof "<text or path>"]
 *      node assessment-log.mjs open [--tz <IANA zone>] [--json]
 *      node assessment-log.mjs             (JSON)
 *      node assessment-log.mjs --summary   (human-readable)
 *      node assessment-log.mjs --self-test
 */

import { readFileSync, existsSync, appendFileSync, mkdirSync } from 'fs';
import { join, dirname } from 'path';
import { fileURLToPath, pathToFileURL } from 'url';
import { getCareerOpsRoot, getProfilePath } from './path-resolver.mjs';
import { loadYaml } from './lib/yaml-document.mjs';
import { localToday } from './lib/local-today.mjs';
import { isMainModule } from './lib/is-main-module.mjs';

const CAREER_OPS = getCareerOpsRoot();
const LOG_PATH = join(CAREER_OPS, 'data/assessments.tsv');

const KNOWN_FLAGS = ['--self-test', '--summary', '--help', '-h'];
const ADD_VALUE_FLAGS = ['--company', '--report', '--platform', '--subject', '--threshold', '--score', '--stale',
  '--kind', '--deadline', '--deliverable', '--requirements-url', '--submitted-at', '--proof'];
const OPEN_VALUE_FLAGS = ['--tz'];
const OPEN_FLAGS = ['--json'];
export const KINDS = ['skills-test', 'take-home'];
export const DELIVERABLES = ['video', 'file', 'link'];
export const WARN_HOURS = 48;

const USAGE = `Usage:
  node assessment-log.mjs add --company <name> [--report <num>] --platform <vendor> --subject <topic> [--threshold <pct>] [--score <pct>] [--stale "<note>"]
  node assessment-log.mjs add --kind take-home --company <name> --platform <channel> --subject <topic> --deadline <ISO with offset> [--deliverable video|file|link] [--requirements-url <url>] [--submitted-at <ISO>] [--proof "<text|path>"]
  node assessment-log.mjs submit --company <name> --subject <topic> [--report <num>] --submitted-at <ISO> [--proof "<text|path>"]   # records a submission you already made; submits nothing
  node assessment-log.mjs open [--tz <IANA zone>] [--json]   # open take-homes by deadline, converted to your timezone
  node assessment-log.mjs                         # print the assessment log as JSON
  node assessment-log.mjs --summary               # print a human-readable summary
  node assessment-log.mjs --self-test             # run the in-memory test suite
  node assessment-log.mjs --help                  # print this usage block and exit (-h is an alias)`;

const HEADER_COMMENT = [
  '# assessments.tsv — append-only skills-assessment log (user layer). Never rewrite rows.',
  '# {YYYY-MM-DD}\\t{company}\\t{report#|-}\\t{platform}\\t{subject}\\t{threshold%|-}\\t{score%|-}\\t{stale_note}',
  '# optional trailing cells: \\t{kind}\\t{deadline}\\t{deliverable}\\t{requirements_url}\\t{submitted_at}\\t{proof}  (kind: skills-test|take-home)',
].join('\n');

// --- Percent parsing ---
// Tolerant: "70", "70%", "70.5 %" all parse; blank/-/? -> null (unknown, not zero).
export function parsePct(raw) {
  const s = String(raw ?? '').trim().replace(/%\s*$/, '').trim();
  if (!s || s === '-' || s === '?' || /^(n\/?a|null)$/i.test(s)) return null;
  const n = Number(s);
  return Number.isFinite(n) ? n : null;
}

// --- Log parsing (TSV) ---
// line: {YYYY-MM-DD}\t{company}\t{report#|-}\t{platform}\t{subject}\t{threshold|-}\t{score|-}\t{stale_note}
// Optional trailing cells may be absent entirely (hand-written rows) — parsing
// stays tolerant; only date+company+platform+subject are structurally required.
export function parseAssessments(content) {
  const rows = [];
  const malformed = [];
  for (const line of String(content || '').split('\n')) {
    const t = line.trim();
    if (!t || t.startsWith('#')) continue;
    const cells = t.split('\t').map(c => c.trim());
    const [date, company, reportNum = '', platform = '', subject = '', threshold = '', score = '', staleNote = '',
      kindRaw = '', deadline = '', deliverable = '', requirementsUrl = '', submittedAt = '', proof = ''] = cells;
    const kind = kindRaw === '' || kindRaw === '-' ? 'skills-test' : kindRaw;
    if (cells.length < 5 || !date || !company || !platform || !subject || !KINDS.includes(kind)) {
      malformed.push({ line: t.slice(0, 80) });
      continue;
    }
    const norm = (v) => (v === '' || v === '-' ? null : v);
    rows.push({
      date, company,
      reportNum: norm(reportNum),
      platform, subject,
      threshold: parsePct(threshold),
      score: parsePct(score),
      staleNote: norm(staleNote),
      kind,
      deadline: norm(deadline),
      deliverable: norm(deliverable),
      requirementsUrl: norm(requirementsUrl),
      submittedAt: norm(submittedAt),
      proof: norm(proof),
    });
  }
  return { rows, malformed };
}

// --- Aggregation ---
export function summarize(rows, malformed = []) {
  const byPlatform = {};
  let staleFlagged = 0;
  for (const r of rows) {
    // Take-home assignments have no threshold/score; counting them would pad
    // every platform's "unknown outcome" tally. They are read via `open`.
    if (r.kind === 'take-home') continue;
    byPlatform[r.platform] ??= { count: 0, staleFlagged: 0, passed: 0, failed: 0, unknownOutcome: 0 };
    const agg = byPlatform[r.platform];
    agg.count += 1;
    if (r.staleNote) { agg.staleFlagged += 1; staleFlagged += 1; }
    // Pass/fail only when BOTH threshold and score are known — a lone score
    // with a hidden threshold proves nothing either way.
    if (r.threshold !== null && r.score !== null) {
      if (r.score >= r.threshold) agg.passed += 1; else agg.failed += 1;
    } else {
      agg.unknownOutcome += 1;
    }
  }
  return {
    assessments: rows,
    aggregates: { byPlatform },
    quality: {
      total: rows.length,
      staleFlagged,
      withoutScore: rows.filter(r => r.kind !== 'take-home' && r.score === null).length,
      withoutThreshold: rows.filter(r => r.kind !== 'take-home' && r.threshold === null).length,
      malformedLines: malformed,
    },
  };
}

// --- Append (`add` subcommand) ---
export function buildRow(fields, today) {
  const req = (name) => {
    const v = String(fields[name] ?? '').trim();
    if (!v) throw new Error(`--${name} is required`);
    if (v.includes('\t') || v.includes('\n')) throw new Error(`--${name} must not contain tabs or newlines`);
    return v;
  };
  const opt = (name) => {
    const v = String(fields[name] ?? '').trim();
    if (v.includes('\t') || v.includes('\n')) throw new Error(`--${name} must not contain tabs or newlines`);
    return v || '-';
  };
  const optPct = (name) => {
    const v = String(fields[name] ?? '').trim();
    if (!v) return '-';
    if (parsePct(v) === null) throw new Error(`--${name} must be a percentage (e.g. 70 or 70%), got "${v}"`);
    return v;
  };
  const kind = String(fields.kind ?? '').trim() || 'skills-test';
  if (!KINDS.includes(kind)) throw new Error(`--kind must be one of ${KINDS.join(', ')}, got "${kind}"`);
  const base = [
    today, req('company'), opt('report'), req('platform'), req('subject'),
    optPct('threshold'), optPct('score'), opt('stale') === '-' ? '' : opt('stale'),
  ];
  const tail = ['deadline', 'deliverable', 'requirements-url', 'submitted-at', 'proof'].map(k => opt(k));
  if (kind === 'skills-test') {
    if (tail.some(v => v !== '-')) {
      throw new Error('--deadline/--deliverable/--requirements-url/--submitted-at/--proof need --kind take-home');
    }
    return base.join('\t'); // byte-identical to the pre-#5733 format
  }
  if (tail[0] !== '-' && !isOffsetDateTime(tail[0])) {
    throw new Error(`--deadline must be an ISO date-time with the sender's UTC offset or Z (e.g. 2026-11-02T17:00:00-08:00), got "${tail[0]}"`);
  }
  if (tail[1] !== '-' && !DELIVERABLES.includes(tail[1])) {
    throw new Error(`--deliverable must be one of ${DELIVERABLES.join(', ')}, got "${tail[1]}"`);
  }
  if (tail[3] !== '-' && !isIsoDate(tail[3]) && !isLocalDateTime(tail[3]) && !isOffsetDateTime(tail[3])) {
    throw new Error(`--submitted-at must be an ISO date or date-time, got "${tail[3]}"`);
  }
  return [...base, kind, ...tail].join('\t');
}

// --- Take-home deadlines ---
// Strict calendar and clock validation: Date.parse accepts or silently rolls over
// values such as 2026-02-30 and offsets like +99:99, so check the fields explicitly.
const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
const OFFSET_DATETIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.\d+)?(Z|([+-])(\d{2}):?(\d{2}))$/;
const LOCAL_DATETIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.\d+)?$/;

function validCalendarDate(y, m, d) {
  const dt = new Date(Date.UTC(y, m - 1, d));
  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
}
function validClock(h, min, s) {
  return h >= 0 && h <= 23 && min >= 0 && min <= 59 && (s === undefined || (s >= 0 && s <= 59));
}

/** YYYY-MM-DD that is a real calendar date. */
export function isIsoDate(v) {
  const m = typeof v === 'string' ? DATE_RE.exec(v) : null;
  return !!m && validCalendarDate(+m[1], +m[2], +m[3]);
}

/** YYYY-MM-DDTHH:MM[:SS] with a real date and clock, no offset. */
export function isLocalDateTime(v) {
  const m = typeof v === 'string' ? LOCAL_DATETIME_RE.exec(v) : null;
  return !!m && validCalendarDate(+m[1], +m[2], +m[3]) && validClock(+m[4], +m[5], m[6] === undefined ? undefined : +m[6]);
}

/** Date-time with Z or a +/-HH:MM offset (hours 0-14, minutes 0-59). */
export function isOffsetDateTime(v) {
  const m = typeof v === 'string' ? OFFSET_DATETIME_RE.exec(v) : null;
  if (!m) return false;
  if (!validCalendarDate(+m[1], +m[2], +m[3])) return false;
  if (!validClock(+m[4], +m[5], m[6] === undefined ? undefined : +m[6])) return false;
  if (m[7] === 'Z') return true;
  const oh = +m[9], om = +m[10];
  return oh <= 14 && om <= 59;
}

export function isValidTimeZone(tz) {
  if (!tz || typeof tz !== 'string') return false;
  try { new Intl.DateTimeFormat('en-CA', { timeZone: tz }); return true; } catch { return false; }
}

// Zone precedence: --tz, then config/profile.yml location.timezone (only if it is
// an Area/City IANA name — the example profile ships an abbreviation like "PST", which is
// ambiguous and is ignored), then the machine's zone.
export function resolveTimeZone(flagTz, profilePath = getProfilePath()) {
  if (flagTz) {
    if (!isValidTimeZone(flagTz)) throw new Error(`--tz "${flagTz}" is not a valid IANA timezone (e.g. America/Toronto)`);
    return { tz: flagTz, source: '--tz' };
  }
  try {
    if (profilePath && existsSync(profilePath)) {
      const cand = (loadYaml(readFileSync(profilePath, 'utf-8')) || {})?.location?.timezone;
      if (typeof cand === 'string' && cand.includes('/') && isValidTimeZone(cand)) return { tz: cand, source: 'config/profile.yml' };
    }
  } catch { /* unreadable profile -> fall through */ }
  return { tz: Intl.DateTimeFormat().resolvedOptions().timeZone, source: 'machine' };
}

export function formatInZone(iso, tz) {
  const parts = Object.fromEntries(
    new Intl.DateTimeFormat('en-CA', {
      timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit',
      hour: '2-digit', minute: '2-digit', hourCycle: 'h23', timeZoneName: 'short',
    }).formatToParts(new Date(iso)).map(p => [p.type, p.value]),
  );
  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute} ${parts.timeZoneName}`;
}

const takeHomeKey = (r) => [r.company, r.reportNum ?? '', r.subject].join('\u0000').toLowerCase();

// Fold append-only rows into one current record per assignment
// (company + report# + subject); a later non-empty value overrides an earlier one.
export function foldTakeHomes(rows) {
  const byKey = new Map();
  for (const r of rows) {
    if (r.kind !== 'take-home') continue;
    const key = takeHomeKey(r);
    const prev = byKey.get(key);
    if (!prev) { byKey.set(key, { ...r }); continue; }
    for (const f of ['deadline', 'deliverable', 'requirementsUrl', 'submittedAt', 'proof', 'platform']) {
      if (r[f]) prev[f] = r[f];
    }
  }
  return [...byKey.values()];
}

// Open (unsubmitted) take-homes, soonest deadline first (no deadline last).
// warn = due within WARN_HOURS and not submitted; overdue = deadline passed.
export function openTakeHomes(rows, { tz, now = new Date() }) {
  const open = foldTakeHomes(rows).filter(r => !r.submittedAt).map(r => {
    const t = r.deadline ? Date.parse(r.deadline) : NaN;
    const hoursLeft = Number.isNaN(t) ? null : (t - now.getTime()) / 3600000;
    return {
      company: r.company, reportNum: r.reportNum, subject: r.subject, platform: r.platform,
      deliverable: r.deliverable, requirementsUrl: r.requirementsUrl,
      deadline: r.deadline,
      deadlineLocal: Number.isNaN(t) ? null : formatInZone(r.deadline, tz),
      hoursLeft: hoursLeft === null ? null : Math.round(hoursLeft * 10) / 10,
      overdue: hoursLeft !== null && hoursLeft < 0,
      warn: hoursLeft !== null && hoursLeft >= 0 && hoursLeft <= WARN_HOURS,
    };
  });
  open.sort((a, b) => (a.deadline ? Date.parse(a.deadline) : Infinity) - (b.deadline ? Date.parse(b.deadline) : Infinity));
  return open;
}

function printOpen(open, tz, source) {
  console.log(`\nOPEN TAKE-HOME ASSIGNMENTS — deadlines shown in ${tz} (${source})\n`);
  if (!open.length) { console.log('  None open.\n'); return; }
  for (const a of open) {
    const mark = a.overdue ? 'OVERDUE' : a.warn ? `DUE IN ${Math.floor(a.hoursLeft)}h` : '       ';
    const ref = a.reportNum ? ` (#${a.reportNum})` : '';
    const how = a.deliverable ? ` [${a.deliverable}]` : '';
    console.log(`  ${a.overdue || a.warn ? '⚠' : ' '} ${a.deadlineLocal ?? 'no deadline'}  ${a.company}${ref} — ${a.subject}${how}  ${mark}`.trimEnd());
    if (a.requirementsUrl) console.log(`      requirements: ${a.requirementsUrl}`);
  }
  console.log('');
}

function addEntry(args, mode = 'add') {
  const fields = {};
  for (let i = 0; i < args.length; i++) {
    const m = args[i].match(/^--(company|report|platform|subject|threshold|score|stale|kind|deadline|deliverable|requirements-url|submitted-at|proof)$/);
    if (m) { fields[m[1]] = args[i + 1] ?? ''; i++; }
  }
  // LOCAL day: this is the date written into the appended assessments.tsv row,
  // and the UTC day stamped a user record with a day that had not happened yet
  // for anyone west of Greenwich (#3070).
  const today = localToday();
  let row;
  try {
    if (mode === 'submit') {
      // Append-only: record a submission as a NEW row for an existing take-home,
      // never by rewriting the original. Platform/deadline/etc. come from the
      // folded earlier rows; this command submits nothing anywhere.
      if (!String(fields['submitted-at'] ?? '').trim()) throw new Error('--submitted-at is required');
      const existing = existsSync(LOG_PATH) ? parseAssessments(readFileSync(LOG_PATH, 'utf-8')).rows : [];
      const want = takeHomeKey({ company: String(fields.company ?? '').trim(), reportNum: String(fields.report ?? '').trim() || null, subject: String(fields.subject ?? '').trim() });
      const prior = foldTakeHomes(existing).find(r => takeHomeKey(r) === want);
      if (!prior) throw new Error('no logged take-home matches --company/--report/--subject (add it first with --kind take-home)');
      fields.kind = 'take-home';
      fields.platform = prior.platform;
      fields.deadline = prior.deadline ?? '';
      fields.deliverable = prior.deliverable ?? '';
      fields['requirements-url'] = prior.requirementsUrl ?? '';
    }
    row = buildRow(fields, today);
  } catch (e) {
    console.error(`assessment-log: ${e.message}`);
    console.error(USAGE);
    process.exit(1);
  }
  // Append-only: existing rows are never rewritten. Create with header comment on first use.
  mkdirSync(dirname(LOG_PATH), { recursive: true });
  let prefix;
  if (existsSync(LOG_PATH)) {
    const existing = readFileSync(LOG_PATH, 'utf-8');
    prefix = existing.endsWith('\n') || existing === '' ? '' : '\n';
  } else {
    prefix = HEADER_COMMENT + '\n';
  }
  appendFileSync(LOG_PATH, prefix + row + '\n');
  console.log(JSON.stringify({ added: true, row: row.split('\t') }, null, 2));
}

// --- Self-test (in-memory fixtures, no file writes) ---
const LOG_FIXTURE = [
  '# comment line',
  '2026-07-01\tAcme\t042\teSkill\tMS Office\t70\t92\treferences Adobe Acrobat 9 (2008-era)',
  '2026-07-02\tGlobex\t-\tHackerRank\tJavaScript\t-\t85\t',
  '2026-07-03\tInitech\t013\tCriteria\tCognitive Aptitude\t65\t60\t',
  '2026-07-04\tHooli\t-\tPredictive Index\tBehavioral\t-\t-\t',
  '2026-07-05\tUmbrella\t017\teSkill\tOutlook\t70\t95\told Outlook web UI, nothing currently shipping',
  '2026-07-06\tAcme', // malformed on purpose — too few cells
].join('\n');

function selfTest() {
  const assert = (cond, msg) => {
    if (!cond) { console.error(`SELF-TEST FAIL: ${msg}`); process.exit(1); }
  };

  // parsePct
  assert(parsePct('70') === 70, '70 -> 70');
  assert(parsePct('70%') === 70, '70% -> 70');
  assert(parsePct('70.5 %') === 70.5, 'decimal with spaced % sign');
  assert(parsePct('-') === null, '- -> null');
  assert(parsePct('') === null, 'blank -> null');
  assert(parsePct('?') === null, '? -> null');
  assert(parsePct('n/a') === null, 'n/a -> null');
  assert(parsePct('high') === null, 'prose -> null');

  // parseAssessments
  const { rows, malformed } = parseAssessments(LOG_FIXTURE);
  assert(rows.length === 5, `5 rows parsed, got ${rows.length}`);
  assert(malformed.length === 1, `1 malformed line reported, got ${malformed.length}`);
  assert(rows[0].company === 'Acme' && rows[0].platform === 'eSkill' && rows[0].reportNum === '042', 'fields mapped');
  assert(rows[0].threshold === 70 && rows[0].score === 92, 'threshold/score parsed');
  assert(rows[0].staleNote.includes('Acrobat 9'), 'stale note preserved');
  assert(rows[1].reportNum === null && rows[1].threshold === null, 'optional cells -> null');
  assert(rows[3].score === null && rows[3].staleNote === null, 'no-score no-stale row tolerated');
  assert(parseAssessments('').rows.length === 0, 'empty log');
  // trailing cells absent entirely (hand-written short row) must still parse
  const short = parseAssessments('2026-07-01\tAcme\t-\teSkill\tExcel').rows;
  assert(short.length === 1 && short[0].score === null && short[0].staleNote === null, 'short row (5 cells) tolerated');

  // summarize
  const result = summarize(rows, malformed);
  assert(result.quality.total === 5, 'total 5');
  assert(result.quality.staleFlagged === 2, `2 stale-flagged, got ${result.quality.staleFlagged}`);
  assert(result.quality.withoutScore === 1 && result.quality.withoutThreshold === 2, 'missing-field counts');
  assert(result.quality.malformedLines.length === 1, 'malformed line surfaced in quality');
  const eskill = result.aggregates.byPlatform['eSkill'];
  assert(eskill.count === 2 && eskill.staleFlagged === 2 && eskill.passed === 2, 'eSkill: 2 events, both stale-flagged, both passed');
  const criteria = result.aggregates.byPlatform['Criteria'];
  assert(criteria.failed === 1 && criteria.passed === 0, 'Criteria: score below threshold -> failed');
  // lone score with hidden threshold must NOT count as passed
  const hr = result.aggregates.byPlatform['HackerRank'];
  assert(hr.passed === 0 && hr.unknownOutcome === 1, 'hidden threshold -> unknown outcome, not a pass');
  const pi = result.aggregates.byPlatform['Predictive Index'];
  assert(pi.unknownOutcome === 1, 'no threshold + no score -> unknown outcome');

  // buildRow
  const row = buildRow({ company: 'Acme', report: '042', platform: 'eSkill', subject: 'MS Office', threshold: '70', score: '92', stale: 'Acrobat 9' }, '2026-07-07');
  assert(row === '2026-07-07\tAcme\t042\teSkill\tMS Office\t70\t92\tAcrobat 9', 'full row built');
  const minimal = buildRow({ company: 'Acme', platform: 'eSkill', subject: 'Excel' }, '2026-07-07');
  assert(minimal === '2026-07-07\tAcme\t-\teSkill\tExcel\t-\t-\t', 'optional fields default to -/empty');
  // round-trip: built rows must parse back losslessly
  const rt = parseAssessments(row + '\n' + minimal).rows;
  assert(rt.length === 2 && rt[0].score === 92 && rt[1].threshold === null, 'built rows round-trip through parser');
  const throws = (fields, frag) => {
    try { buildRow(fields, '2026-07-07'); return false; } catch (e) { return e.message.includes(frag); }
  };
  assert(throws({ platform: 'eSkill', subject: 'Excel' }, '--company is required'), 'missing company rejected');
  assert(throws({ company: 'Acme', platform: 'eSkill', subject: 'Excel', threshold: 'high' }, '--threshold must be a percentage'), 'prose threshold rejected');
  assert(throws({ company: 'A\tcme', platform: 'eSkill', subject: 'Excel' }, 'tabs'), 'embedded tab rejected');

  console.log('assessment-log self-test OK (pct parser + TSV parser + aggregation + row builder)');
}

// --- Output ---
function printSummary(result) {
  const { aggregates, quality, assessments } = result;
  console.log('\nSKILLS ASSESSMENTS — per-application events\n');

  if (!assessments.length) {
    console.log('  No assessments logged yet.');
    console.log('  Log one: node assessment-log.mjs add --company <name> --platform <vendor> --subject <topic>');
  } else {
    console.log('  Events:');
    for (const a of assessments) {
      if (a.kind === 'take-home') {
        console.log(`  ${a.date} ${a.company}${a.reportNum ? ` (#${a.reportNum})` : ''} — take-home: ${a.subject}${a.submittedAt ? ` (submitted ${a.submittedAt})` : ''}`);
        continue;
      }
      const ref = a.reportNum ? ` (#${a.reportNum})` : '';
      const outcome = a.threshold !== null && a.score !== null
        ? `${a.score}% vs threshold ${a.threshold}% — ${a.score >= a.threshold ? 'passed' : 'failed'}`
        : [a.score !== null ? `score ${a.score}%` : null, a.threshold !== null ? `threshold ${a.threshold}%` : null].filter(Boolean).join(', ') || 'no score/threshold reported';
      console.log(`  ${a.date} ${a.company}${ref} — ${a.platform}: ${a.subject}`);
      console.log(`      ${outcome}`);
      if (a.staleNote) console.log(`      ⚠ stale: ${a.staleNote}`);
    }
    console.log('\n  By platform:');
    for (const [platform, agg] of Object.entries(aggregates.byPlatform)) {
      const stale = agg.staleFlagged ? `, ${agg.staleFlagged} stale-flagged` : '';
      console.log(`  ${platform}: ${agg.count} event${agg.count === 1 ? '' : 's'} (${agg.passed} passed, ${agg.failed} failed, ${agg.unknownOutcome} unknown${stale})`);
    }
  }

  console.log('\n  Data quality:');
  console.log(`  stale-flagged (candidate-observed): ${quality.staleFlagged} of ${quality.total}`);
  console.log(`  without score: ${quality.withoutScore}, without threshold: ${quality.withoutThreshold}`);
  if (quality.malformedLines.length) {
    console.log(`  ⚠ ${quality.malformedLines.length} malformed line${quality.malformedLines.length === 1 ? '' : 's'} skipped (need date, company, platform, subject):`);
    for (const m of quality.malformedLines) console.log(`      "${m.line}"`);
  } else {
    console.log('  malformed lines: none');
  }
  console.log('');
}

function openCommand(args) {
  const tzIdx = args.indexOf('--tz');
  let zone;
  try {
    if (tzIdx >= 0 && (args[tzIdx + 1] === undefined || args[tzIdx + 1].startsWith('--'))) {
      throw new Error('--tz requires an IANA timezone (e.g. America/Toronto)');
    }
    zone = resolveTimeZone(tzIdx >= 0 ? args[tzIdx + 1] : undefined);
  } catch (e) {
    console.error(`assessment-log: ${e.message}`);
    process.exit(1);
  }
  const content = existsSync(LOG_PATH) ? readFileSync(LOG_PATH, 'utf-8') : '';
  const open = openTakeHomes(parseAssessments(content).rows, { tz: zone.tz });
  if (args.includes('--json')) console.log(JSON.stringify({ timeZone: zone.tz, timeZoneSource: zone.source, open }, null, 2));
  else printOpen(open, zone.tz, zone.source);
}

function main() {
  const args = process.argv.slice(2);

  if (args.includes('--help') || args.includes('-h')) {
    console.log(USAGE);
    process.exit(0);
  }

  // Values passed to the add subcommand remain positional data even when they
  // start with a dash (for example an explicitly unknown "-" percentage).
  // Only a leading-dash argument outside those value slots is a CLI flag.
  const valueFlags = args[0] === 'add' || args[0] === 'submit' ? ADD_VALUE_FLAGS : args[0] === 'open' ? OPEN_VALUE_FLAGS : [];
  const consumedValueIndices = new Set();
  if (valueFlags.length) {
    args.forEach((arg, index) => {
      if (valueFlags.includes(arg) && args[index + 1] !== undefined && !args[index + 1].startsWith('--')) {
        consumedValueIndices.add(index + 1);
      }
    });
  }

  const validFlags = [...KNOWN_FLAGS, ...valueFlags, ...(args[0] === 'open' ? OPEN_FLAGS : [])];
  const unknownFlags = args.filter((arg, index) =>
    arg.startsWith('-') && !consumedValueIndices.has(index) && !validFlags.includes(arg));
  if (unknownFlags.length) {
    console.error(`assessment-log: unrecognized flag(s): ${unknownFlags.join(', ')}. Valid flags: ${validFlags.join(', ')}`);
    console.error(USAGE);
    process.exit(1);
  }

  if (args.includes('--self-test')) { selfTest(); return; }
  if (args[0] === 'add' || args[0] === 'submit') { addEntry(args.slice(1), args[0]); return; }
  if (args[0] === 'open') { openCommand(args.slice(1)); return; }

  const content = existsSync(LOG_PATH) ? readFileSync(LOG_PATH, 'utf-8') : '';
  const { rows, malformed } = parseAssessments(content);
  const result = summarize(rows, malformed);

  if (args.includes('--summary')) {
    printSummary(result);
  } else {
    console.log(JSON.stringify(result, null, 2));
  }
}

if (isMainModule(import.meta.url)) {
  main();
}