/**
 * Batch B — Final Tasks Tests
 *
 * Tests for: evalRunner, a11yAudit, responsiveSpecs, compliance (noLog)
 */

import { describe, it, before, after } from "node:test";
import assert from "node:assert/strict";

// ──────────────── T-42: Eval Runner ────────────────

import {
  registerSuite,
  getSuite,
  listSuites,
  evaluateCase,
  runSuite,
  createScorecard,
  resetSuites,
} from "../../src/lib/evals/evalRunner.ts";

describe("evalRunner", () => {
  after(() => {
    // Remove test-registered suites while preserving built-ins.
    resetSuites();
  });

  it("should have golden-set suite pre-registered", () => {
    const suite = getSuite("golden-set");
    assert.ok(suite);
    assert.equal(suite.name, "OmniRoute Golden Set");
    assert.ok(suite.cases.length >= 10);
  });

  it("should list registered suites", () => {
    const suites = listSuites();
    assert.ok(suites.length >= 1);
    assert.ok(suites.some((s) => s.id === "golden-set"));
  });

  it("should evaluate exact match", () => {
    const result = evaluateCase(
      {
        id: "t1",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "exact", value: "hello" },
      },
      "hello"
    );
    assert.equal(result.passed, true);
  });

  it("should fail exact match on mismatch", () => {
    const result = evaluateCase(
      {
        id: "t2",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "exact", value: "hello" },
      },
      "world"
    );
    assert.equal(result.passed, false);
  });

  it("should evaluate contains (case-insensitive)", () => {
    const result = evaluateCase(
      {
        id: "t3",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "contains", value: "paris" },
      },
      "The capital is Paris."
    );
    assert.equal(result.passed, true);
  });

  it("should evaluate regex", () => {
    const result = evaluateCase(
      {
        id: "t4",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "regex", value: "\\d+" },
      },
      "The answer is 42."
    );
    assert.equal(result.passed, true);
  });

  it("should fail regex when expected value is missing", () => {
    const result = evaluateCase(
      {
        id: "t4-missing",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "regex" },
      },
      "The answer is 42."
    );
    assert.equal(result.passed, false);
    assert.equal(result.details.error, "No regex value provided for evaluation.");
  });

  it("should reject oversized regex patterns", () => {
    const result = evaluateCase(
      {
        id: "t4-large",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "regex", value: "a".repeat(513) },
      },
      "test"
    );
    assert.equal(result.passed, false);
    assert.equal(result.details.error, "Regex pattern too large for safe evaluation.");
  });

  it("should evaluate stateful RegExp values consistently", () => {
    const regex = /answer/g;
    const evalCase = {
      id: "t4-stateful",
      name: "test",
      model: "test",
      input: {},
      expected: { strategy: "regex", value: regex },
    };

    assert.equal(evaluateCase(evalCase, "answer").passed, true);
    assert.equal(evaluateCase(evalCase, "answer").passed, true);
  });

  it("should evaluate custom function", () => {
    const result = evaluateCase(
      {
        id: "t5",
        name: "test",
        model: "test",
        input: {},
        expected: { strategy: "custom", fn: (output) => output.length > 5 },
      },
      "this is long enough"
    );
    assert.equal(result.passed, true);
  });

  it("should handle unknown strategy gracefully", () => {
    const result = evaluateCase(
      { id: "t6", name: "test", model: "test", input: {}, expected: { strategy: "unknown" } },
      "test"
    );
    assert.equal(result.passed, false);
    assert.ok(result.error.includes("Unknown strategy"));
  });

  it("should normalize non-Error thrown values", () => {
    const result = evaluateCase(
      {
        id: "t7",
        name: "test",
        model: "test",
        input: {},
        expected: {
          strategy: "custom",
          fn: () => {
            throw "custom failure";
          },
        },
      },
      "test"
    );
    assert.equal(result.passed, false);
    assert.equal(result.error, "custom failure");
  });

  it("should run suite and produce summary", () => {
    registerSuite({
      id: "test-suite",
      name: "Test Suite",
      cases: [
        {
          id: "c1",
          name: "pass",
          model: "m",
          input: {},
          expected: { strategy: "contains", value: "yes" },
        },
        {
          id: "c2",
          name: "fail",
          model: "m",
          input: {},
          expected: { strategy: "contains", value: "no" },
        },
      ],
    });

    const result = runSuite("test-suite", { c1: "yes it works", c2: "yes it works" });
    assert.equal(result.summary.total, 2);
    assert.equal(result.summary.passed, 1);
    assert.equal(result.summary.failed, 1);
    assert.equal(result.summary.passRate, 50);
  });

  it("should create scorecard from runs", () => {
    const run1 = runSuite("test-suite", { c1: "yes", c2: "no" });
    const scorecard = createScorecard([run1]);
    assert.equal(scorecard.suites, 1);
    assert.equal(scorecard.totalCases, 2);
  });

  it("should throw on unknown suite", () => {
    assert.throws(() => runSuite("nonexistent", {}), { message: /not found/ });
  });

  it("should restore built-in suites when resetting test suites", () => {
    registerSuite({ id: "temporary-suite", name: "Temporary", cases: [] });
    resetSuites();

    assert.equal(getSuite("temporary-suite"), null);
    assert.ok(getSuite("golden-set"));
  });
});

// ──────────────── T-35: a11y Audit ────────────────

import { auditHTML, generateReport, WCAG_RULES } from "../../src/shared/utils/a11yAudit.ts";

describe("a11yAudit", () => {
  it("should pass for compliant HTML", () => {
    const html = '<button aria-label="Close">X</button><img alt="Logo" src="logo.png" />';
    const violations = auditHTML(html);
    assert.equal(violations.length, 0);
  });

  it("should detect images without alt text", () => {
    const html = '<img src="photo.jpg" />';
    const violations = auditHTML(html);
    assert.ok(violations.some((v) => v.id === WCAG_RULES.IMAGE_ALT));
  });

  it("should detect dialogs without role", () => {
    const html = '<div class="modal"><p>Content</p></div>';
    const violations = auditHTML(html);
    assert.ok(violations.some((v) => v.id === WCAG_RULES.DIALOG_ROLE));
  });

  it("should generate report summary", () => {
    const violations = [
      { id: "test", description: "test", impact: "critical", help: "fix", nodes: [] },
      { id: "test2", description: "test", impact: "serious", help: "fix", nodes: [] },
    ];
    const report = generateReport(violations);
    assert.equal(report.total, 2);
    assert.equal(report.critical, 1);
    assert.equal(report.serious, 1);
    assert.equal(report.passed, false);
  });

  it("should report passed for no violations", () => {
    const report = generateReport([]);
    assert.equal(report.passed, true);
    assert.equal(report.total, 0);
  });

  it("should not export the removed contrast compliance wrapper", async () => {
    const audit = await import("../../src/shared/utils/a11yAudit.ts");
    assert.equal("checkContrast" in audit, false);
    assert.equal(typeof audit.getContrastRatio, "function");
    assert.equal(typeof audit.auditHTML, "function");
    assert.equal(typeof audit.generateReport, "function");
  });

  it("should export WCAG rules", () => {
    assert.ok(WCAG_RULES.ARIA_LABEL);
    assert.ok(WCAG_RULES.COLOR_CONTRAST);
    assert.ok(WCAG_RULES.FOCUS_TRAP);
  });
});

// ──────────────── T-39: Responsive Specs ────────────────

import {
  A11Y_CHECKS,
  VIEWPORTS,
  PAGES,
  generateTestMatrix,
  getViewportNames,
} from "../../tests/e2e/responsiveSpecs.ts";

describe("responsiveSpecs", () => {
  it("should define mobile, tablet, desktop viewports", () => {
    assert.ok(VIEWPORTS.mobile);
    assert.ok(VIEWPORTS.tablet);
    assert.ok(VIEWPORTS.desktop);
    assert.equal(VIEWPORTS.mobile.width, 375);
    assert.equal(VIEWPORTS.tablet.width, 768);
  });

  it("should define pages to test", () => {
    assert.ok(PAGES.length >= 4);
    assert.ok(PAGES.some((p) => p.path === "/login"));
    assert.ok(PAGES.some((p) => p.path === "/dashboard"));
  });

  it("should generate test matrix", () => {
    const matrix = generateTestMatrix();
    assert.equal(matrix.length, 3 * PAGES.length); // 3 viewports × n pages
    assert.ok(matrix[0].testName);
    assert.ok(matrix[0].viewport);
    assert.ok(matrix[0].page);
  });

  it("should get viewport names", () => {
    const names = getViewportNames();
    assert.deepEqual(names, ["mobile", "tablet", "desktop"]);
  });

  it("should separate executable and manual accessibility checks", () => {
    assert.ok(A11Y_CHECKS.some((check) => check.kind === "evaluate"));
    assert.ok(A11Y_CHECKS.some((check) => check.kind === "manual"));
    assert.ok(A11Y_CHECKS.every((check) => typeof check.criteria === "string"));
  });
});

// ──────────────── T-43: Compliance (noLog) ────────────────

import { setNoLog, isNoLog, getRetentionDays } from "../../src/lib/compliance/index.ts";

describe("compliance", () => {
  it("should default to logging enabled", () => {
    assert.equal(isNoLog("key-1"), false);
  });

  it("should set noLog opt-out", () => {
    setNoLog("key-1", true);
    assert.equal(isNoLog("key-1"), true);
  });

  it("should clear noLog opt-out", () => {
    setNoLog("key-1", false);
    assert.equal(isNoLog("key-1"), false);
  });

  it("should expose split default retention windows", () => {
    assert.deepEqual(getRetentionDays(), { app: 7, call: 7 });
  });
});