// tests/kb-update/test-backup-restore.test.mjs
// Unit tests for scripts/kb-update/lib/backup.mjs

import { test } from 'node:test';
import assert from 'node:assert/strict';
import {
  mkdtempSync,
  mkdirSync,
  rmSync,
  writeFileSync,
  readFileSync,
  readdirSync,
  existsSync,
  utimesSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import {
  backupDir,
  detectStaleRollback,
  cleanupOldBackups,
  backupTimestamp,
} from '../../scripts/kb-update/lib/backup.mjs';

function withTmp(fn) {
  const dir = mkdtempSync(join(tmpdir(), 'bk-test-'));
  try {
    return fn(dir);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}

function makeSrc(root, files) {
  mkdirSync(root, { recursive: true });
  for (const [rel, content] of Object.entries(files)) {
    const path = join(root, rel);
    mkdirSync(join(path, '..'), { recursive: true });
    writeFileSync(path, content, 'utf8');
  }
}

function readAll(root) {
  const out = {};
  function walk(dir, prefix) {
    for (const entry of readdirSync(dir, { withFileTypes: true })) {
      const full = join(dir, entry.name);
      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
      if (entry.isDirectory()) {
        walk(full, rel);
      } else if (entry.isFile()) {
        out[rel] = readFileSync(full, 'utf8');
      }
    }
  }
  walk(root, '');
  return out;
}

test('backupTimestamp — produces filesystem-safe ISO-ish format', () => {
  const ts = backupTimestamp(new Date('2026-05-05T10:32:13.456Z'));
  assert.equal(ts, '2026-05-05T10-32-13');
  assert.match(ts, /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
});

test('backupDir — creates timestamped subdir under backupRoot', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, { 'foo.md': 'A' });

    const { backupPath } = backupDir(src, root);
    assert.match(
      backupPath,
      /\.kb-backup\/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/
    );
    assert.equal(existsSync(backupPath), true);
  });
});

test('backupDir — copies content faithfully (deep equal)', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, {
      'a.md': 'alpha',
      'sub/b.md': 'beta',
      'sub/deep/c.md': 'gamma',
    });

    const { backupPath } = backupDir(src, root);
    const original = readAll(src);
    const copied = readAll(backupPath);
    // The backup also contains .backup-meta.json — strip it before comparing.
    delete copied['.backup-meta.json'];
    assert.deepEqual(copied, original);
  });
});

test('backupDir — writes .backup-meta.json sentinel inside backup', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, { 'foo.md': 'A' });
    const { backupPath } = backupDir(src, root);
    const metaPath = join(backupPath, '.backup-meta.json');
    assert.equal(existsSync(metaPath), true);
    const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
    assert.equal(meta.schema_version, 1);
    assert.equal(meta.src_dir, src);
    assert.match(meta.created_at, /^\d{4}-\d{2}-\d{2}T/);
  });
});

test('restore — round-trips content after src is mutated', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, { 'a.md': 'original', 'sub/b.md': 'original-b' });
    const original = readAll(src);

    const handle = backupDir(src, root);

    // Mutate src.
    writeFileSync(join(src, 'a.md'), 'mutated', 'utf8');
    writeFileSync(join(src, 'new.md'), 'extra', 'utf8');
    rmSync(join(src, 'sub'), { recursive: true, force: true });

    handle.restore();

    const restored = readAll(src);
    assert.deepEqual(restored, original);
  });
});

test('restore — sentinel is removed after successful restore', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, { 'foo.md': 'A' });
    const handle = backupDir(src, root);
    handle.restore();
    assert.equal(detectStaleRollback(root), false);
  });
});

test('detectStaleRollback — true when sentinel exists, false when absent', () => {
  withTmp((tmp) => {
    const root = join(tmp, '.kb-backup');
    mkdirSync(root, { recursive: true });
    assert.equal(detectStaleRollback(root), false);
    writeFileSync(join(root, '.rollback-in-progress'), '{}', 'utf8');
    assert.equal(detectStaleRollback(root), true);
  });
});

test('detectStaleRollback — sentinel persists when restore is interrupted', () => {
  withTmp((tmp) => {
    const root = join(tmp, '.kb-backup');
    mkdirSync(root, { recursive: true });
    // Simulate a crashed restore: sentinel was written but never removed.
    writeFileSync(
      join(root, '.rollback-in-progress'),
      JSON.stringify({ started_at: new Date().toISOString() }),
      'utf8'
    );
    // Sentinel must still be there until something explicitly clears it.
    assert.equal(detectStaleRollback(root), true);
  });
});

test('cleanupOldBackups — deletes backups older than retentionDays', () => {
  withTmp((tmp) => {
    const src = join(tmp, 'skills');
    const root = join(tmp, '.kb-backup');
    makeSrc(src, { 'foo.md': 'A' });

    // Two backups. Age the first by overwriting its meta.created_at.
    const oldHandle = backupDir(src, root);
    const oldMetaPath = join(oldHandle.backupPath, '.backup-meta.json');
    const oldMeta = JSON.parse(readFileSync(oldMetaPath, 'utf8'));
    const tenDaysAgo = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString();
    oldMeta.created_at = tenDaysAgo;
    writeFileSync(oldMetaPath, JSON.stringify(oldMeta, null, 2), 'utf8');

    // Sleep-equivalent: bump to ensure distinct backup-id.
    const newHandle = backupDir(src, root, { now: new Date(Date.now() + 1000) });

    const result = cleanupOldBackups(root, 7);
    assert.deepEqual(result.deleted, [oldHandle.backupPath]);
    assert.deepEqual(result.kept, [newHandle.backupPath]);
    assert.equal(existsSync(oldHandle.backupPath), false);
    assert.equal(existsSync(newHandle.backupPath), true);
  });
});

test('cleanupOldBackups — falls back to dir mtime when meta is missing', () => {
  withTmp((tmp) => {
    const root = join(tmp, '.kb-backup');
    const oldDir = join(root, '2026-04-01T00-00-00');
    mkdirSync(oldDir, { recursive: true });
    writeFileSync(join(oldDir, 'orphan.md'), 'no meta', 'utf8');
    // No .backup-meta.json. Set dir mtime to 30 days ago.
    const past = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
    utimesSync(oldDir, past, past);

    const result = cleanupOldBackups(root, 7);
    assert.deepEqual(result.deleted, [oldDir]);
    assert.equal(existsSync(oldDir), false);
  });
});

test('cleanupOldBackups — skips dirs with unresolvable age', () => {
  withTmp((tmp) => {
    const root = join(tmp, '.kb-backup');
    const odd = join(root, 'questionable');
    mkdirSync(odd, { recursive: true });
    // Stub statSync via making the file behave normally; fallback to mtime
    // works on real fs. To genuinely exercise the skip path we stub the warn
    // hook and make the meta unparseable + mtime fresh enough to not delete.
    writeFileSync(join(odd, '.backup-meta.json'), 'not json', 'utf8');
    // mtime fresh → kept (not deleted), so the skip path is not hit. The
    // skip-path guard only fires when statSync ALSO throws, which on real fs
    // requires deletion mid-iteration. Simulate with a dir that exists but
    // becomes inaccessible — out of scope for portable tests. Instead verify
    // the documented contract: unparseable meta with fresh mtime → kept.
    const result = cleanupOldBackups(root, 7);
    assert.deepEqual(result.kept, [odd]);
    assert.deepEqual(result.deleted, []);
  });
});

test('cleanupOldBackups — handles non-existent backupRoot gracefully', () => {
  withTmp((tmp) => {
    const root = join(tmp, 'never-created');
    const result = cleanupOldBackups(root, 7);
    assert.deepEqual(result, { kept: [], deleted: [], skipped: [] });
  });
});