"""Verify real QuantCore output, source provenance and the Python input boundary."""
from pathlib import Path
import hashlib
import json
import math
import subprocess
import sys
import unittest

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "public/lab"))
from experiment import compare

class QuantCoreLabTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.data = json.loads((ROOT / "public/lab/data.json").read_text())
        cls.reference = json.loads((ROOT / "lib/lab-reference.json").read_text())

    def test_all_supported_allocations_match_reference(self):
        for dataset in self.data:
            for n in range(101):
                result = compare({"dataset": dataset, "left": n, "right": 100-n}, self.data)
                for side, weight in [("left", n), ("right", 100-n)]:
                    expected = self.reference[dataset][weight]
                    for metric in ["totalReturn", "volatility", "maxDrawdown"]:
                        self.assertAlmostEqual(result[side][metric], expected[metric], places=12)
                    self.assertEqual(len(result[side]["path"]), 253)
                    self.assertEqual(result[side]["path"][0], 100)
                    self.assertAlmostEqual(result[side]["path"][-1]/100-1, expected["totalReturn"], places=12)

    def test_portfolio_math_against_independent_scalar_calculation(self):
        rows = self.data["diverse"]
        for n in [0, 25, 60, 80, 100]:
            values = [a*n/100 + b*(100-n)/100 for a, b in rows]
            mean = sum(values)/len(values)
            volatility = math.sqrt(sum((v-mean)**2 for v in values)/(len(values)-1)*252)
            wealth, peak, drawdown = 100, 100, 0
            for value in values:
                wealth *= 1+value
                peak = max(peak, wealth)
                drawdown = min(drawdown, wealth/peak-1)
            result = compare({"dataset":"diverse", "left":n, "right":n}, self.data)["left"]
            self.assertAlmostEqual(result["volatility"], volatility, places=12)
            self.assertAlmostEqual(result["totalReturn"], wealth/100-1, places=12)
            self.assertAlmostEqual(result["maxDrawdown"], drawdown, places=12)

    def test_source_and_data_integrity(self):
        manifest = json.loads((ROOT / "public/lab/source.json").read_text())
        for name, digest in manifest["modules"].items():
            self.assertEqual(hashlib.sha256((ROOT/"public/lab/quantcore"/name).read_bytes()).hexdigest(), digest)
        self.assertEqual(hashlib.sha256((ROOT/"public/lab/data.json").read_bytes()).hexdigest(), manifest["data_sha256"])

    def test_invalid_and_executable_inputs_are_rejected(self):
        initial = {"dataset":"diverse", "left":60, "right":80}
        for bad in [dict(initial, left=-1), dict(initial, right=101), dict(initial, left=True),
                    dict(initial, left="60"), dict(initial, left=60.1), dict(initial, left=float("nan")),
                    dict(initial, dataset="https://example.com"), dict(initial, code="import os")]:
            with self.assertRaises(ValueError): compare(bad, self.data)

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