from __future__ import annotations

import json
import unittest
from http import HTTPStatus
from pathlib import Path
from unittest import mock

from backend.application import HUB_SERVICE_HANDLERS, RequestHandler


ROOT = Path(__file__).resolve().parents[1]
SERVICE_TOKEN = "hub-admin-token-for-tests"


class FakeHeaders(dict):
    def get(self, name, default=""):  # type: ignore[override]
        return super().get(name, default)


class HubAdminBridgeTests(unittest.TestCase):
    def handler(self, path: str, token: str, calls: list[str]) -> RequestHandler:
        handler = RequestHandler.__new__(RequestHandler)
        handler.path = path
        handler.headers = FakeHeaders({"X-Hub-Admin-Token": token} if token else {})
        handler.responses = []
        handler.send_json = lambda payload, status=HTTPStatus.OK, headers=None: (
            handler.responses.append((status, payload))
        )
        handler.require_auth = lambda: calls.append("auth") or True
        handler.require_csrf = lambda: calls.append("csrf") or True
        handler.require_access = lambda method, route: calls.append("access") or True
        return handler

    def test_every_bridge_path_has_a_real_handler(self) -> None:
        for path, handler_name in HUB_SERVICE_HANDLERS.items():
            with self.subTest(path=path):
                self.assertTrue(path.startswith("/api/hub-admin/"))
                self.assertTrue(callable(getattr(RequestHandler, handler_name)))

    def test_bridge_paths_stay_out_of_the_browser_route_registry(self) -> None:
        registry = json.loads(
            (ROOT / "config" / "api.config.json").read_text(encoding="utf-8")
        )
        registered = {route["path"] for route in registry["routes"]}
        for path in HUB_SERVICE_HANDLERS:
            with self.subTest(path=path):
                self.assertNotIn(path, registered)
                self.assertIsNone(RequestHandler.route_registry.resolve("POST", path))

    def test_missing_or_wrong_service_token_is_rejected(self) -> None:
        for token in ("", "wrong-token"):
            with self.subTest(token=token), mock.patch.dict(
                "os.environ", {"HUB_ADMIN_TOKEN": SERVICE_TOKEN}
            ):
                calls: list[str] = []
                handler = self.handler("/api/hub-admin/status", token, calls)
                handler.hub_system_status = lambda: calls.append("dispatched")

                RequestHandler.do_POST(handler)

                self.assertEqual(calls, [])
                status, payload = handler.responses[-1]
                self.assertEqual(status, HTTPStatus.UNAUTHORIZED)
                self.assertIn("服务令牌", payload["error"])

    def test_unset_server_token_refuses_every_bridge_call(self) -> None:
        with mock.patch.dict("os.environ", {"HUB_ADMIN_TOKEN": ""}):
            calls: list[str] = []
            handler = self.handler("/api/hub-admin/status", SERVICE_TOKEN, calls)
            handler.hub_system_status = lambda: calls.append("dispatched")

            RequestHandler.do_POST(handler)

            self.assertEqual(calls, [])
            self.assertEqual(handler.responses[-1][0], HTTPStatus.UNAUTHORIZED)

    def test_valid_service_token_dispatches_without_session_guards(self) -> None:
        for path, handler_name in HUB_SERVICE_HANDLERS.items():
            with self.subTest(path=path), mock.patch.dict(
                "os.environ", {"HUB_ADMIN_TOKEN": SERVICE_TOKEN}
            ):
                calls: list[str] = []
                handler = self.handler(path, SERVICE_TOKEN, calls)
                setattr(handler, handler_name, lambda: calls.append(handler_name))

                RequestHandler.do_POST(handler)

                self.assertEqual(calls, [handler_name])


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