from __future__ import annotations

import importlib.util
import sys
import unittest
from pathlib import Path
from unittest.mock import patch


SCRIPT_PATH = Path(__file__).with_name("smoke-deliberate-practice-api.py")
SPEC = importlib.util.spec_from_file_location(
    "smoke_deliberate_practice_api", SCRIPT_PATH
)
assert SPEC is not None and SPEC.loader is not None
MODULE = importlib.util.module_from_spec(SPEC)
sys.modules[SPEC.name] = MODULE
SPEC.loader.exec_module(MODULE)


class FakeClient:
    def __init__(self, bodies: list[dict[str, object]]) -> None:
        self.bodies = list(bodies)
        self.paths: list[str] = []

    def request(self, method: str, path: str, *args: object, **kwargs: object):
        self.paths.append(f"{method} {path}")
        if not self.bodies:
            raise AssertionError("unexpected request")
        return MODULE.ApiResponse(200, self.bodies.pop(0))


class DeliberatePracticeSmokeUnitTest(unittest.TestCase):
    def test_selects_two_distinct_database_personas_with_p1_as_source(self) -> None:
        client = FakeClient(
            [
                [
                    {"code": "P2", "source": "database", "degraded": False},
                    {"code": "P1", "source": "database", "degraded": False},
                    {"code": "P3", "source": "fallback", "degraded": False},
                ]
            ]
        )

        self.assertEqual(MODULE._choose_distinct_personas(client), ("P1", "P2"))

    def test_review_poll_is_bounded_and_fetches_review_only_when_ready(self) -> None:
        client = FakeClient(
            [
                {"review_ready": False},
                {"review_ready": True},
                {"reviewReady": True, "turns": [{"turn_id": "a"}, {"turn_id": "b"}]},
            ]
        )
        clock = iter([0.0, 0.0, 0.25])

        with (
            patch.object(MODULE.time, "monotonic", side_effect=lambda: next(clock)),
            patch.object(MODULE.time, "sleep") as sleep,
        ):
            result = MODULE._wait_for_session_review(
                client,
                "session-1",
                timeout=1.0,
                interval=0.25,
            )

        self.assertEqual(result["poll_count"], 2)
        self.assertEqual(result["review"]["reviewReady"], True)
        self.assertEqual(
            client.paths,
            [
                "GET /sessions/session-1",
                "GET /sessions/session-1",
                "GET /sessions/session-1/review",
            ],
        )
        sleep.assert_called_once_with(0.25)

    def test_runtime_read_model_requires_unseen_independent_model_evidence(self) -> None:
        proof = MODULE._runtime_attempt_read_proof(
            {
                "episodes": [
                    {
                        "episode_submission_id": "submission-1",
                        "session_id": "session-2",
                        "attempts": [
                            {
                                "attempt_record_id": "attempt-1",
                                "scenario_novelty": "unseen_transfer",
                                "learner_claimed_success": False,
                                "evidence_turn_ids": ["turn-1", "turn-2"],
                                "attempt_payload": {
                                    "observation": {
                                        "criterion": {
                                            "source_kind": "model_inferred",
                                            "perspective": "independent_observer",
                                            "model_run_id": "model-run-1",
                                        }
                                    }
                                },
                            }
                        ],
                    }
                ]
            },
            session_id="session-2",
            durable_turn_ids=["turn-1", "turn-2"],
        )

        self.assertEqual(proof["episode_submission_id"], "submission-1")
        self.assertEqual(proof["model_run_ids"], ["model-run-1"])
        self.assertEqual(proof["durable_evidence_turn_ids"], ["turn-1", "turn-2"])

    def test_smoke_never_calls_browser_media_or_voice_api(self) -> None:
        source = SCRIPT_PATH.read_text(encoding="utf-8").lower()
        for forbidden in (
            "/voice",
            "getusermedia",
            "enumeratedevices",
            "mediadevices",
        ):
            self.assertNotIn(forbidden, source)


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