import json
import logging
import subprocess
import sys
import unittest
from datetime import datetime, timedelta, timezone
from pathlib import Path

from matrix_core import DeterministicMatrixCore, ENGINE_VERSION

FIXED = datetime(2026, 11, 3, 12, tzinfo=timezone.utc)
VECTOR = "36e7be60a50a6d846b8b162c199a5e534c612ba171163d9c3406e2f2b12c0651"
MODULE = Path(sys.modules[DeterministicMatrixCore.__module__].__file__).resolve()


class MatrixCoreTests(unittest.TestCase):
    def setUp(self):
        self.core = DeterministicMatrixCore()

    def test_known_checksum_vector(self):
        result = self.core.enforce_zero_tolerance_matrix("Evidence before confidence.", FIXED)
        self.assertEqual(result["matrix_verification_seal"], VECTOR)
        self.assertEqual(result["seal_date"], "2026-11-03")
        self.assertEqual(result["engine_version"], ENGINE_VERSION)

    def test_whitespace_normalization_including_unicode(self):
        result = self.core.enforce_zero_tolerance_matrix("\tEvidence\u00a0before\n confidence.  ", FIXED)
        self.assertEqual(result["input_payload"], "Evidence before confidence.")
        self.assertEqual(result["matrix_verification_seal"], VECTOR)

    def test_invalid_payloads_do_not_receive_checksums(self):
        for payload in (None, "", " \t\n\u00a0", 0, False, b"text", [], {}):
            with self.subTest(payload=repr(payload)):
                result = self.core.enforce_zero_tolerance_matrix(payload, FIXED)
                self.assertFalse(result["valid"])
                self.assertEqual(result["error"], "EMPTY_OR_INVALID_PAYLOAD")
                self.assertNotIn("matrix_verification_seal", result)

    def test_fixed_instant_repeats_entire_result(self):
        expected = self.core.enforce_zero_tolerance_matrix("test", FIXED)
        for _ in range(25):
            self.assertEqual(self.core.enforce_zero_tolerance_matrix("test", FIXED), expected)

    def test_same_utc_day_repeats_checksum_but_not_timestamp(self):
        first = self.core.enforce_zero_tolerance_matrix("test", FIXED)
        later = self.core.enforce_zero_tolerance_matrix("test", FIXED + timedelta(hours=1))
        self.assertEqual(first["matrix_verification_seal"], later["matrix_verification_seal"])
        self.assertNotEqual(first["timestamp"], later["timestamp"])

    def test_next_utc_day_changes_checksum(self):
        first = self.core.enforce_zero_tolerance_matrix("test", FIXED)
        next_day = self.core.enforce_zero_tolerance_matrix("test", FIXED + timedelta(days=1))
        self.assertNotEqual(first["matrix_verification_seal"], next_day["matrix_verification_seal"])

    def test_equivalent_timezone_instants_have_identical_results(self):
        local = datetime(2026, 11, 4, 0, 30, tzinfo=timezone(timedelta(hours=2)))
        utc = datetime(2026, 11, 3, 22, 30, tzinfo=timezone.utc)
        result = self.core.enforce_zero_tolerance_matrix("test", local)
        self.assertEqual(result, self.core.enforce_zero_tolerance_matrix("test", utc))
        self.assertEqual(result["seal_date"], "2026-11-03")
        self.assertTrue(result["timestamp"].endswith("+00:00"))

    def test_naive_datetime_is_rejected(self):
        with self.assertRaises(ValueError):
            self.core.enforce_zero_tolerance_matrix("test", datetime(2026, 11, 3))

    def test_wrong_time_types_are_rejected(self):
        for instant in (0, "2026-11-03", False):
            with self.subTest(instant=instant), self.assertRaises(TypeError):
                self.core.enforce_zero_tolerance_matrix("test", instant)

    def test_default_time_is_aware_utc(self):
        result = self.core.enforce_zero_tolerance_matrix("test")
        instant = datetime.fromisoformat(result["timestamp"])
        self.assertEqual(instant.utcoffset(), timedelta(0))
        self.assertEqual(instant.date().isoformat(), result["seal_date"])

    def test_engine_version_is_metadata_not_seal_input(self):
        first = self.core.enforce_zero_tolerance_matrix("test", FIXED)
        other = DeterministicMatrixCore("custom").enforce_zero_tolerance_matrix("test", FIXED)
        self.assertEqual(first["matrix_verification_seal"], other["matrix_verification_seal"])
        self.assertNotEqual(first["engine_version"], other["engine_version"])

    def test_import_does_not_configure_root_logging(self):
        code = "import logging; before=list(logging.root.handlers); import matrix_core; assert logging.root.handlers == before"
        result = subprocess.run([sys.executable, "-B", "-c", code], cwd=MODULE.parent, capture_output=True)
        self.assertEqual(result.returncode, 0, result.stderr)

    def cli(self, *arguments):
        return subprocess.run([sys.executable, "-X", "utf8", "-B", str(MODULE), *arguments], capture_output=True, text=True, encoding="utf-8")

    def test_cli_is_json_and_matches_vector(self):
        result = self.cli("Evidence before confidence.", "--at", FIXED.isoformat())
        self.assertEqual(result.returncode, 0)
        self.assertEqual(json.loads(result.stdout)["matrix_verification_seal"], VECTOR)
        self.assertEqual(result.stderr, "")

    def test_cli_missing_payload_is_invalid(self):
        result = self.cli()
        self.assertEqual(result.returncode, 2)
        self.assertFalse(json.loads(result.stdout)["valid"])

    def test_cli_rejects_timestamp_without_timezone(self):
        result = self.cli("test", "--at", "2026-11-03T12:00:00")
        self.assertEqual(result.returncode, 2)
        self.assertEqual(json.loads(result.stdout)["error"], "INVALID_TIMESTAMP")

    def test_cli_preserves_unicode(self):
        result = self.cli("Čćšđž", "--at", FIXED.isoformat())
        self.assertEqual(result.returncode, 0)
        self.assertEqual(json.loads(result.stdout)["input_payload"], "Čćšđž")


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