#!/usr/bin/env python3
"""Acceptance tests for CASAN's three-dimensional readiness contract."""

from __future__ import annotations

import importlib.util
import json
from pathlib import Path
import tempfile
import unittest


MODULE = Path(__file__).resolve().parents[1] / "scripts" / "python" / "readiness.py"
SPEC = importlib.util.spec_from_file_location("casan_readiness", MODULE)
READINESS = importlib.util.module_from_spec(SPEC)
assert SPEC.loader
SPEC.loader.exec_module(READINESS)


class ReadinessTests(unittest.TestCase):
    def setUp(self):
        self.temporary = tempfile.TemporaryDirectory()
        self.root = Path(self.temporary.name)
        self.runtime = self.root / "runtime"
        report = (
            self.runtime / "packages" / "casan-harness" / "scripts" /
            "python" / "local_report.py"
        )
        report.parent.mkdir(parents=True)
        report.write_text("# report engine\n", encoding="utf-8")
        (self.root / ".casan").mkdir()
        (self.root / ".casan" / "casan-hook.py").write_text(
            "# bootstrap\n", encoding="utf-8")
        (self.root / ".casan" / "config.json").write_text(json.dumps({
            "schema_version": "21.3",
            "project_id": "commercial-core",
            "edition": "core",
            "enforcement_mode": "enforce",
            "runtime_path": str(self.runtime),
            "clients": ["codex"],
        }), encoding="utf-8")
        (self.root / ".casan" / "version.lock").write_text(json.dumps({
            "harness_version": "1.0.5",
            "harness_hash": "abc123",
        }), encoding="utf-8")
        (self.root / ".codex").mkdir()
        (self.root / ".codex" / "hooks.json").write_text(
            '{"hooks":{"SessionStart":[{"hooks":[{"command":"python3 .casan/casan-hook.py --client codex"}]}]}}',
            encoding="utf-8",
        )
        (self.root / ".specify" / "logs").mkdir(parents=True)
        (self.root / ".specify" / "state").mkdir(parents=True)
        (self.root / "package.json").write_text(
            '{"name":"commercial-core"}', encoding="utf-8")

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

    def test_core_is_ready_without_a_domain_pack_or_provider_telemetry(self):
        result = READINESS.assess(self.root, client_state={
            "codex": {
                "verified": True,
                "operational": True,
                "status": "trusted",
            },
        })
        dimensions = result["dimensions"]
        self.assertEqual(result["overall_status"], "ready")
        self.assertEqual(dimensions["core"]["status"], "ready")
        self.assertEqual(
            dimensions["domain_pipeline"]["status"], "not_configured")
        self.assertEqual(
            dimensions["provider_telemetry"]["status"],
            "optional_unavailable",
        )
        self.assertEqual(
            dimensions["core"]["acceptance"][5]["status"],
            "optional_unavailable",
        )

    def test_unverified_codex_trust_is_an_action_not_a_fake_ready_state(self):
        result = READINESS.assess(self.root, client_state={
            "codex": {
                "verified": True,
                "operational": False,
                "status": "modified",
            },
        })
        self.assertEqual(result["overall_status"], "action_required")
        self.assertEqual(
            result["dimensions"]["core"]["acceptance"][1]["status"],
            "action_required",
        )
        self.assertTrue(any(
            action["code"] == "verify_codex_trust"
            for action in result["next_actions"]
        ))

    def test_one_healthy_route_keeps_core_operational_with_attention(self):
        config_path = self.root / ".casan" / "config.json"
        config = json.loads(config_path.read_text(encoding="utf-8"))
        config["clients"] = ["codex", "vscode-copilot"]
        config_path.write_text(json.dumps(config), encoding="utf-8")
        result = READINESS.assess(self.root, client_state={
            "codex": {
                "verified": True,
                "operational": True,
                "status": "trusted",
            },
            "vscode-copilot": {"operational": False},
        })
        self.assertEqual(result["overall_status"], "ready_with_attention")
        self.assertEqual(
            result["dimensions"]["core"]["acceptance"][1]["status"],
            "warning",
        )
        self.assertTrue(any(
            action["code"] == "activate_vscode_copilot"
            for action in result["next_actions"]
        ))

    def test_discovery_is_casan_owned_and_never_creates_domain_inputs(self):
        result = READINESS.assess(self.root, persist=True, client_state={
            "codex": {
                "verified": True,
                "operational": True,
                "status": "trusted",
            },
        })
        self.assertEqual(result["dimensions"]["domain_pipeline"]["domain_packs"], [])
        self.assertTrue((self.root / ".casan" / "discovery.json").is_file())
        self.assertTrue((self.root / ".casan" / "readiness.json").is_file())
        self.assertFalse((self.root / "apps").exists())

    def test_domain_configuration_references_existing_project_source_only(self):
        manifest = self.root / "docs" / "project.manifest.json"
        manifest.parent.mkdir()
        manifest.write_text(json.dumps({
            "schema_version": 1,
            "project_id": "commercial-core",
        }), encoding="utf-8")
        configured = READINESS.configure_domain(
            self.root, "docs/project.manifest.json")
        self.assertEqual(configured["manifest"], "docs/project.manifest.json")
        result = READINESS.assess(self.root, client_state={
            "codex": {
                "verified": True,
                "operational": True,
                "status": "trusted",
            },
        })
        self.assertEqual(
            result["dimensions"]["domain_pipeline"]["status"], "configured")
        self.assertEqual(
            result["dimensions"]["domain_pipeline"]["selected_manifest"],
            "docs/project.manifest.json",
        )


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