import assert from "node:assert/strict";
import {
    resolveJurisdiction,
    isValidResolution,
    getResolutionPriority,
    getSourceConfidence,
    hasJurisdiction,
    hasPolicy,
    JURISDICTION_CATALOG,
    POLICIES
} from "../jurisdiction/index.js";

const tests = [];
function test(name, fn) {
    tests.push({ name, fn });
}

test("fixed us-ma resolves from site configuration", () => {
    const result = resolveJurisdiction({ mode: "fixed", jurisdiction: "us-ma" });
    assert.equal(result.status, "resolved");
    assert.equal(result.jurisdiction.id, "us-ma");
    assert.equal(result.policy.id, "us-state-privacy");
    assert.equal(result.source, "site-config");
    assert.equal(result.confidence, "explicit");
});

test("fixed eu resolves correctly", () => {
    const result = resolveJurisdiction({ mode: "fixed", jurisdiction: "eu" });
    assert.equal(result.jurisdiction.id, "eu");
    assert.equal(result.policy.id, "eu-privacy");
});

test("fixed global resolves global baseline", () => {
    const result = resolveJurisdiction({ mode: "fixed", jurisdiction: "global" });
    assert.equal(result.jurisdiction.id, "global");
    assert.equal(result.policy.id, "global-baseline");
});

test("global mode deliberately selects global policy", () => {
    const result = resolveJurisdiction({ mode: "global" });
    assert.equal(result.jurisdiction.id, "global");
    assert.equal(result.source, "site-config");
});

test("auto resolves server signal", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        request: { jurisdiction: "us-ca", source: "server" }
    });
    assert.equal(result.jurisdiction.id, "us-ca");
    assert.equal(result.source, "server");
    assert.equal(result.confidence, "high");
});

test("auto resolves application signal", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        visitor: { jurisdiction: "us-ma", source: "application" }
    });
    assert.equal(result.jurisdiction.id, "us-ma");
    assert.equal(result.source, "application");
});

test("auto resolves browser signal", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        visitor: { jurisdiction: "eu", source: "browser" }
    });
    assert.equal(result.jurisdiction.id, "eu");
    assert.equal(result.source, "browser");
    assert.equal(result.confidence, "low");
});

test("auto falls back conservatively when no signal exists", () => {
    const result = resolveJurisdiction({ mode: "auto" });
    assert.equal(result.status, "fallback");
    assert.equal(result.jurisdiction.id, "global");
    assert.equal(result.policy.id, "global-baseline");
    assert.equal(result.source, "fallback");
    assert.equal(result.confidence, "default");
});

test("auto ignores unknown jurisdiction signals", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        request: { jurisdiction: "xx-unknown", source: "server" }
    });
    assert.equal(result.status, "fallback");
    assert.equal(result.jurisdiction.id, "global");
});

test("higher-trust server signal wins over browser signal", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        request: { jurisdiction: "us-ma", source: "server" },
        visitor: { jurisdiction: "eu", source: "browser" }
    });
    assert.equal(result.jurisdiction.id, "us-ma");
    assert.equal(result.source, "server");
});

test("explicit site configuration wins over lower-trust signals", () => {
    const result = resolveJurisdiction({
        mode: "auto",
        site: { jurisdiction: "us-ca", source: "site-config" },
        request: { jurisdiction: "eu", source: "server" }
    });
    assert.equal(result.jurisdiction.id, "us-ca");
    assert.equal(result.source, "site-config");
});

test("fixed mode requires jurisdiction", () => {
    assert.throws(
        () => resolveJurisdiction({ mode: "fixed" }),
        /jurisdiction is required/i
    );
});

test("fixed mode rejects unknown jurisdiction", () => {
    assert.throws(
        () => resolveJurisdiction({ mode: "fixed", jurisdiction: "xx" }),
        /unknown jurisdiction/i
    );
});

test("invalid mode is rejected", () => {
    assert.throws(
        () => resolveJurisdiction({ mode: "random" }),
        /invalid jurisdiction mode/i
    );
});

test("invalid input type is rejected", () => {
    assert.throws(
        () => resolveJurisdiction(null),
        /input must be an object/i
    );
});

test("catalog entries reference existing policies", () => {
    for (const entry of Object.values(JURISDICTION_CATALOG)) {
        assert.equal(hasPolicy(entry.policy), true);
    }
});

test("resolution result satisfies its contract", () => {
    const results = [
        resolveJurisdiction({ mode: "fixed", jurisdiction: "us-ma" }),
        resolveJurisdiction({ mode: "global" }),
        resolveJurisdiction({ mode: "auto" })
    ];

    for (const result of results) {
        assert.equal(isValidResolution(result), true);
    }
});

test("source priority is deterministic", () => {
    assert.ok(getResolutionPriority("site-config") > getResolutionPriority("server"));
    assert.ok(getResolutionPriority("server") > getResolutionPriority("application"));
    assert.ok(getResolutionPriority("application") > getResolutionPriority("browser"));
    assert.ok(getResolutionPriority("browser") > getResolutionPriority("fallback"));
});

test("source confidence mapping is deterministic", () => {
    assert.equal(getSourceConfidence("site-config"), "explicit");
    assert.equal(getSourceConfidence("server"), "high");
    assert.equal(getSourceConfidence("application"), "medium");
    assert.equal(getSourceConfidence("browser"), "low");
    assert.equal(getSourceConfidence("fallback"), "default");
});

test("catalog contains the initial architectural jurisdictions", () => {
    for (const id of ["global", "us", "us-ma", "us-ca", "eu"]) {
        assert.equal(hasJurisdiction(id), true);
    }
    assert.equal(POLICIES["global-baseline"] !== undefined, true);
});

let passed = 0;
for (const { name, fn } of tests) {
    try {
        fn();
        passed += 1;
        console.log(`PASS: ${name}`);
    } catch (error) {
        console.error(`FAIL: ${name}`);
        console.error(error);
        process.exitCode = 1;
    }
}

console.log(`\n${passed}/${tests.length} tests passed`);
if (passed !== tests.length) {
    process.exitCode = 1;
}