import copy
import hashlib
import json
import tempfile
import unittest
from pathlib import Path

from klein_code_bench.build import build
from klein_code_bench.catalog import FAMILIES
from klein_code_bench.fuzz import generated_inputs
from klein_code_bench.reference.domains import solve
from klein_code_bench.reference.export import export_reference
from klein_code_bench.reference.service import Service
from klein_code_bench.runner import (
    DATA,
    copy_project,
    equal,
    evaluate,
    load_tasks,
    run_session,
)
from klein_code_bench.scoring import summarize


class DomainTests(unittest.TestCase):
    def test_all_65_independent_goldens(self):
        self.assertEqual(len(FAMILIES), 65)
        for family in FAMILIES.values():
            with self.subTest(family=family.slug):
                self.assertTrue(
                    equal(solve(family.slug, family.inputs[0]), family.golden)
                )

    def test_generators_cover_every_family_without_mutating_input(self):
        for family in FAMILIES:
            for data in generated_inputs(family):
                original = copy.deepcopy(data)
                json.dumps(solve(family, data), allow_nan=False)
                self.assertEqual(data, original, family)

    def test_money_conservation(self):
        for x in generated_inputs("money_split", count=100):
            shares = solve("money_split", x)
            self.assertEqual(sum(shares), x["amount"])
            self.assertTrue(all(v >= 0 for v in shares))

    def test_knapsack_against_exhaustive_subsets(self):
        for x in generated_inputs("knapsack", count=50):
            best = max(
                sum(item["value"] for i, item in enumerate(x["items"]) if mask >> i & 1)
                for mask in range(1 << len(x["items"]))
                if sum(
                    item["weight"] for i, item in enumerate(x["items"]) if mask >> i & 1
                )
                <= x["capacity"]
            )
            self.assertEqual(solve("knapsack", x), best)

    def test_shortest_path_against_bellman_ford(self):
        for x in generated_inputs("shortest_path", count=50):
            d = {n: float("inf") for n in x["nodes"]}
            d[x["start"]] = 0
            for _ in x["nodes"]:
                for a, b, w in x["edges"]:
                    d[b] = min(d[b], d[a] + w)
            expected = {k: v if v != float("inf") else None for k, v in d.items()}
            self.assertEqual(solve("shortest_path", x), expected)

    def test_factorization_reconstructs_input(self):
        for x in generated_inputs("prime_factors", count=100):
            product = 1
            for p, exponent in solve("prime_factors", x):
                self.assertTrue(all(p % d for d in range(2, int(p**0.5) + 1)))
                product *= p**exponent
            self.assertEqual(product, x["number"])

    def test_base_conversion_roundtrip(self):
        for x in generated_inputs("base_convert", count=100):
            self.assertEqual(
                int(solve("base_convert", x), x["to_base"]), int(x["digits"])
            )

    def test_sequence_script_reconstructs_both_inputs(self):
        for x in generated_inputs("sequence_diff", count=100):
            result = solve("sequence_diff", x)
            self.assertEqual([v for op, v in result if op != "insert"], x["a"])
            self.assertEqual([v for op, v in result if op != "delete"], x["b"])


class ServiceTests(unittest.TestCase):
    def setUp(self):
        self.s = Service("word_frequency", "max")

    def call(self, op, **kwargs):
        return self.s.request(dict(op=op, **kwargs))

    def test_revisions_and_failed_cas(self):
        self.assertEqual(
            self.call("put", key="a", value=None),
            {"ok": True, "result": {"key": "a", "revision": 1}},
        )
        self.assertEqual(
            self.call("delete", key="missing", if_revision=0),
            {"ok": False, "error": "conflict"},
        )
        self.assertEqual(
            self.call("get", key="a")["result"],
            {"key": "a", "value": None, "revision": 1},
        )
        self.assertEqual(self.call("status")["result"], {"revision": 1, "size": 1})

    def test_batch_rollback_and_revision_reuse(self):
        self.assertEqual(
            self.call(
                "batch",
                commands=[
                    {"op": "put", "key": "a", "value": 1},
                    {"op": "get", "key": "bad"},
                ],
            ),
            {"ok": False, "error": "not_found"},
        )
        self.assertEqual(self.call("status")["result"], {"revision": 0, "size": 0})
        self.assertEqual(self.call("history")["result"], [])
        self.assertEqual(self.call("put", key="b", value=2)["result"]["revision"], 1)

    def test_nested_commit_outer_rollback(self):
        self.call("begin")
        self.call("put", key="a", value=1)
        self.call("begin")
        self.call("put", key="b", value=2)
        self.assertEqual(self.call("commit")["result"], {"depth": 1})
        self.assertEqual(self.call("rollback")["result"], {"depth": 0})
        self.assertEqual(self.call("list")["result"], [])
        self.assertEqual(self.call("history")["result"], [])

    def test_idempotent_request_checks_cache_before_cas(self):
        first = self.call("put", key="a", value=1, token="t", if_revision=0)
        self.assertEqual(
            self.call("put", key="a", value=1, token="t", if_revision=0), first
        )
        self.assertEqual(self.call("status")["result"]["revision"], 1)
        self.assertEqual(
            self.call("put", key="a", value=2, token="t"),
            {"ok": False, "error": "idempotency_conflict"},
        )

    def test_failed_and_rolled_back_tokens_forgotten(self):
        self.call("delete", key="a", token="t")
        self.assertTrue(self.call("put", key="a", value=1, token="t")["ok"])
        self.call("begin")
        self.call("put", key="b", value=2, token="u")
        self.call("rollback")
        self.assertTrue(self.call("put", key="b", value=3, token="u")["ok"])

    def test_evaluate_is_read_only(self):
        self.call("put", key="a", value={"text": "x x"})
        self.assertEqual(
            self.call("evaluate", key="a")["result"], [{"word": "x", "count": 2}]
        )
        self.assertEqual(self.call("get", key="a")["result"]["value"], {"text": "x x"})
        self.assertEqual(self.call("status")["result"]["revision"], 1)

    def test_scan_pages(self):
        for key in ["c", "a", "b"]:
            self.call("put", key=key, value=key)
        self.assertEqual(
            self.call("scan", limit=1)["result"],
            {"items": [{"key": "a", "value": "a", "revision": 2}], "next": "a"},
        )
        self.assertEqual(self.call("scan", after="b", limit=1)["result"]["next"], None)
        self.assertEqual(
            self.call("scan", limit=0)["result"], {"items": [], "next": None}
        )

    def test_outer_commit_is_durable_and_open_transaction_is_not(self):
        with tempfile.TemporaryDirectory() as d:
            self.s = Service("word_frequency", "max", d)
            self.call("begin")
            self.call("put", key="a", value={"text": "saved"}, token="t")
            self.call("commit")
            self.call("begin")
            self.call("delete", key="a")
            reloaded = Service("word_frequency", "max", d)
            self.assertEqual(
                reloaded.request({"op": "get", "key": "a"})["result"]["revision"], 1
            )
            self.assertEqual(reloaded.state["tokens"].keys(), {"t"})
            self.assertEqual(len(reloaded.state["history"]), 1)


class DatasetTests(unittest.TestCase):
    def test_exact_counts_unique_ids_and_manifest(self):
        rows = list(load_tasks())
        self.assertEqual(len(rows), 260)
        self.assertEqual(len({r["task_id"] for r in rows}), 260)
        for tier in ["easy", "intermediate", "hard", "max"]:
            self.assertEqual(sum(r["subset"] == tier for r in rows), 65)
        manifest = json.loads((DATA / "manifest.json").read_text())
        for name, digest in manifest["sha256"].items():
            self.assertEqual(
                hashlib.sha256((DATA / name).read_bytes()).hexdigest(), digest
            )

    def test_build_reproducible(self):
        with tempfile.TemporaryDirectory() as d:
            build(d)
            for file in DATA.iterdir():
                if file.suffix in {".json", ".jsonl"}:
                    self.assertEqual(
                        file.read_bytes(), (Path(d) / file.name).read_bytes(), file.name
                    )

    def test_public_examples_in_prompt_and_nonempty_acceptance(self):
        for row in load_tasks():
            self.assertTrue(json.loads(row["public_tests"]))
            traces = json.loads(row["acceptance_tests"])
            self.assertTrue(traces)
            self.assertEqual(
                row["num_assertions"],
                sum(len(s["expected"]) for t in traces for s in t["sessions"]),
            )
            for trace in traces:
                for session in trace["sessions"]:
                    self.assertTrue(session["requests"])
                    self.assertEqual(len(session["requests"]), len(session["expected"]))

    def test_scoring_uses_full_denominator_and_rejects_smoke(self):
        row = next(load_tasks("easy"))
        report = {"task_id": row["task_id"], "subset": "easy", "resolved": True}
        self.assertEqual(
            summarize([report])["subsets"]["easy"]["resolution_rate"], 1 / 65
        )
        with self.assertRaises(ValueError):
            summarize([report, report])
        with self.assertRaises(ValueError):
            summarize([dict(report, evaluation_scope="public")])


class RunnerTests(unittest.TestCase):
    def setUp(self):
        self.temporary = tempfile.TemporaryDirectory()
        self.root = Path(self.temporary.name)
        self.project, self.state = self.root / "project", self.root / "state"
        self.project.mkdir()
        self.state.mkdir()
        self.session = {
            "requests": [{"op": "status"}],
            "expected": [{"ok": True, "result": 7}],
        }

    def tearDown(self):
        self.temporary.cleanup()

    def run_code(self, code, timeout=1):
        (self.project / "main.py").write_text(code)
        return run_session(self.project, self.state, self.session, timeout=timeout)

    def test_response_and_clean_exit(self):
        self.assertTrue(
            self.run_code(
                'import sys\nfor line in sys.stdin:\n print(\'{"ok":true,"result":7}\', flush=True)\n'
            )["passed"]
        )

    def test_rejects_wrong_boolean_numeric_type(self):
        self.assertFalse(equal(True, 1))
        self.assertFalse(equal(1, True))
        self.assertFalse(equal(float("nan"), 1))
        self.assertTrue(equal(1.0, 1))
        self.assertFalse(equal(10**30, 10**30 + 1))

    def test_timeout_without_output(self):
        self.assertFalse(
            self.run_code("import time\ntime.sleep(20)", timeout=0.2)["passed"]
        )

    def test_failure_on_nonzero_exit(self):
        self.assertFalse(
            self.run_code(
                'import sys\nsys.stdin.readline()\nprint(\'{"ok":true,"result":7}\',flush=True)\nsys.exit(1)'
            )["passed"]
        )

    def test_rejects_extra_stdout(self):
        self.assertFalse(
            self.run_code(
                'import sys\nsys.stdin.readline()\nprint(\'{"ok":true,"result":7}\')\nprint("extra",flush=True)'
            )["passed"]
        )

    def test_output_flood_is_bounded(self):
        self.assertFalse(
            self.run_code('import os\nwhile True: os.write(1,b"x"*65536)')["passed"]
        )

    def test_stderr_flood_does_not_deadlock(self):
        self.assertTrue(
            self.run_code(
                'import os,sys\nfor line in sys.stdin:\n os.write(2,b"x"*200000)\n print(\'{"ok":true,"result":7}\',flush=True)'
            )["passed"]
        )

    def test_symlinks_rejected(self):
        (self.project / "main.py").symlink_to("/etc/passwd")
        target = self.root / "copied"
        target.mkdir()
        with self.assertRaises(ValueError):
            copy_project(self.project, target)

    def test_invalid_submission_is_failed_rather_than_infrastructure_error(self):
        (self.project / "main.py").symlink_to("/etc/passwd")
        result = evaluate(next(load_tasks("easy")), self.project)
        self.assertFalse(result["resolved"])
        self.assertIn("symlink", result["reason"])

    def test_reference_max_restart_and_empty_submission(self):
        row = next(load_tasks("max"))
        export_reference(row["family"], "max", self.project)
        result = evaluate(row, self.project)
        self.assertTrue(result["passed"], result)
        empty = self.root / "empty"
        empty.mkdir()
        self.assertFalse(evaluate(row, empty)["passed"])


if __name__ == "__main__":
    unittest.main()