from fractions import Fraction
from itertools import product
from pathlib import Path
import json
import subprocess
import sys
import unittest
from model import evaluate, evidence


def rational(pair):
    return Fraction(pair["numerator"], pair["denominator"])


def oracle(trace, capacity):
    """Follow separate ordered-slot paths without merging equivalent states."""
    totals = [Fraction(0)] * len(trace)
    def visit(index, slots, mass):
        if index == len(trace):
            return
        key = trace[index]
        if key in slots:
            visit(index + 1, slots, mass)
        else:
            totals[index] += mass
            if len(slots) < capacity:
                visit(index + 1, slots + (key,), mass)
            else:
                for slot in range(capacity):
                    copy = list(slots)
                    copy[slot] = key
                    visit(index + 1, tuple(copy), mass / capacity)
    visit(0, (), Fraction(1))
    return totals


class ModelTests(unittest.TestCase):
    def test_cold_start_and_denominators(self):
        row = evaluate("ABCA", 2)
        self.assertEqual(row["coldRequests"], 3)
        self.assertEqual(row["reuseRequests"], 1)
        self.assertEqual(rational(row["expectedMisses"]), Fraction(7, 2))
        self.assertEqual(rational(row["allMissesPerRequest"]), Fraction(7, 8))
        self.assertEqual(rational(row["noncoldMissesPerRequest"]), Fraction(1, 8))
        self.assertEqual(rational(row["missesPerReuse"]), Fraction(1, 2))
        self.assertEqual(row["lruMisses"], 4)

    def test_free_slots_and_hits_do_not_evict(self):
        row = evaluate("ABBA", 2)
        self.assertEqual(rational(row["expectedMisses"]), 2)
        self.assertTrue(all(rational(e["evictionProbability"]) == 0 for e in row["events"]))
        self.assertEqual(rational(evaluate("ABCA", 2)["events"][1]["evictionProbability"]), 0)

    def test_two_evictions(self):
        row = evaluate("ABCDA", 2)
        self.assertEqual(rational(row["events"][-1]["missProbability"]), Fraction(3, 4))
        self.assertEqual(rational(row["expectedMisses"]), Fraction(19, 4))

    def test_independent_exhaustive_path_oracle(self):
        for length in range(1, 6):
            for letters in product("ABC", repeat=length):
                trace = "".join(letters)
                for capacity in (1, 2, 3):
                    row = evaluate(trace, capacity)
                    self.assertEqual([rational(e["missProbability"]) for e in row["events"]],
                                     oracle(trace, capacity), (trace, capacity))

    def test_accounting(self):
        for trace in ("A", "AAAAAAAAAAAA", "ABCDEFGHIJKL", "ABACABACABAC"):
            for capacity in (1, 2, 3, 4):
                row = evaluate(trace, capacity)
                self.assertEqual(rational(row["expectedMisses"]),
                                 row["coldRequests"] + rational(row["expectedNoncoldMisses"]))
                for event in row["events"]:
                    self.assertEqual(sum(rational(s["probability"]) for s in event["statesAfter"]), 1)
                    self.assertTrue(all(len(s["resident"]) <= capacity for s in event["statesAfter"]))

    def test_no_reuse_is_explicit(self):
        self.assertIsNone(evaluate("ABC", 2)["missesPerReuse"])

    def test_bad_inputs(self):
        for trace, capacity in (("", 2), ("A" * 13, 2), (["A"], 2), ("a", 2),
                                ("A ", 2), ("A", 0), ("A", 5), ("A", 1.5), ("A", True)):
            with self.assertRaises(ValueError):
                evaluate(trace, capacity)

    def test_export(self):
        self.assertEqual(json.loads(Path(__file__).with_name("evidence.json").read_text()), evidence())

    def test_invalid_cli_preserves_output(self):
        script = Path(__file__).with_name("model.py")
        path = script.with_name("evidence.json")
        before = path.read_bytes()
        for args in (["--unknown"], ["--check", "--unknown"]):
            run = subprocess.run([sys.executable, "-B", str(script), *args], capture_output=True)
            self.assertNotEqual(run.returncode, 0)
            self.assertEqual(run.stdout, b"")
            self.assertEqual(path.read_bytes(), before)


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