from __future__ import annotations

import json
import unittest

from ai_triage.oncall import (
    OncallClient,
    OncallError,
    OncallOwnerRouter,
    load_oncall_teams,
)


class SequencedReadTransport:
    def __init__(self, responses: list[tuple[int, bytes]]) -> None:
        self.responses = list(responses)
        self.calls: list[tuple[str, dict[str, str], float]] = []

    def __call__(
        self,
        url: str,
        headers: dict[str, str],
        timeout: float,
    ) -> tuple[int, bytes]:
        self.calls.append((url, headers, timeout))
        return self.responses.pop(0)


class OncallClientTests(unittest.TestCase):
    def test_loads_current_oncall_team_catalog_with_bearer_auth(self) -> None:
        transport = SequencedReadTransport(
            [
                (
                    200,
                    json.dumps(
                        {
                            "teams": [
                                {
                                    "team_id": 8,
                                    "team_key": "global_control",
                                    "display_name": "SOE - Global & Dedicated",
                                    "group_names": ["ONCALL"],
                                },
                                {
                                    "team_id": 16,
                                    "team_key": "dedicated_service",
                                    "display_name": "Dedicated (Deprecated)",
                                    "group_names": ["HIDE"],
                                },
                            ]
                        }
                    ).encode(),
                )
            ]
        )
        client = OncallClient(
            "https://oncall.pingcap.net",
            "oc_v2_secret",
            transport=transport,
        )

        teams = load_oncall_teams(client, "ONCALL")

        self.assertEqual(
            {"global_control": "SOE - Global & Dedicated"},
            teams,
        )
        url, headers, timeout = transport.calls[0]
        self.assertEqual(
            "https://oncall.pingcap.net/api/v1/teams?group_name=ONCALL",
            url,
        )
        self.assertEqual("Bearer oc_v2_secret", headers["Authorization"])
        self.assertEqual(10.0, timeout)
        self.assertNotIn("oc_v2_secret", url)

    def test_product_owner_router_uses_live_primary_oncall_and_caches_result(self) -> None:
        transport = SequencedReadTransport(
            [
                (
                    200,
                    json.dumps(
                        {
                            "team_id": 8,
                            "current_engineer_emails": [
                                "first@example.com",
                                "first@example.com",
                            ],
                            "backup_engineer_emails": ["backup@example.com"],
                            "current_no_oncall": False,
                            "next_switch_at": 1784862000,
                        }
                    ).encode(),
                )
            ]
        )
        client = OncallClient(
            "https://oncall.pingcap.net",
            "oc_v2_secret",
            transport=transport,
        )
        router = OncallOwnerRouter(
            client,
            {"global_control": "SOE - Global & Dedicated"},
            mention_resolver=lambda emails: {
                "first@example.com": "ou_first",
            },
            cache_ttl_seconds=60,
        )
        product = {
            "category": "product_error",
            "component": "dedicated-control-plane",
            "oncall_team": "global_control",
            "owner": "fallback@example.com",
            "owner_type": "component",
        }

        first = router.route(product)
        second = router.route(product)

        self.assertEqual("product_oncall", first["owner_type"])
        self.assertEqual(["first@example.com"], first["owner_emails"])
        self.assertEqual(["ou_first"], first["owner_open_ids"])
        self.assertEqual("first@example.com", first["owner"])
        self.assertEqual(
            "SOE - Global & Dedicated",
            first["oncall_team_display"],
        )
        self.assertEqual(first, second)
        self.assertEqual(1, len(transport.calls))

    def test_known_component_case_fallback_still_resolves_live_oncall(self) -> None:
        transport = SequencedReadTransport(
            [
                (
                    200,
                    json.dumps(
                        {
                            "team_id": 8,
                            "current_engineer_emails": ["first@example.com"],
                            "backup_engineer_emails": [],
                            "current_no_oncall": False,
                            "next_switch_at": 1784862000,
                        }
                    ).encode(),
                )
            ]
        )
        router = OncallOwnerRouter(
            OncallClient(
                "https://oncall.pingcap.net",
                "oc_v2_secret",
                transport=transport,
            ),
            {"global_control": "SOE - Global & Dedicated"},
        )

        result = router.route(
            {
                "category": "product_error",
                "component": "dedicated-control-plane",
                "oncall_team": "global_control",
                "owner": "case@example.com",
                "owner_type": "case",
            }
        )

        self.assertEqual("product_oncall", result["owner_type"])
        self.assertEqual("first@example.com", result["owner"])
        self.assertEqual(1, len(transport.calls))

    def test_non_product_and_unknown_team_keep_configured_owner(self) -> None:
        client = OncallClient(
            "https://oncall.pingcap.net",
            "oc_v2_secret",
            transport=SequencedReadTransport([]),
        )
        router = OncallOwnerRouter(
            client,
            {"global_control": "SOE - Global & Dedicated"},
        )

        case = router.route(
            {
                "category": "case_error",
                "oncall_team": "unknown",
                "owner": "case@example.com",
                "owner_type": "case",
            }
        )
        unknown = router.route(
            {
                "category": "product_error",
                "oncall_team": "unknown",
                "owner": "fallback@example.com",
                "owner_type": "component",
            }
        )

        self.assertEqual("case@example.com", case["owner"])
        self.assertEqual("case", case["owner_type"])
        self.assertEqual("fallback@example.com", unknown["owner"])
        self.assertEqual("component", unknown["owner_type"])

    def test_unknown_component_keeps_case_owner_even_with_known_team(self) -> None:
        transport = SequencedReadTransport([])
        client = OncallClient(
            "https://oncall.pingcap.net",
            "oc_v2_secret",
            transport=transport,
        )
        router = OncallOwnerRouter(
            client,
            {"global_control": "SOE - Global & Dedicated"},
        )

        result = router.route(
            {
                "category": "product_error",
                "component": "unknown",
                "oncall_team": "global_control",
                "owner": "case@example.com",
                "owner_type": "case",
            }
        )

        self.assertEqual("case@example.com", result["owner"])
        self.assertEqual("case", result["owner_type"])
        self.assertEqual([], transport.calls)

    def test_api_errors_do_not_leak_api_key(self) -> None:
        client = OncallClient(
            "https://oncall.pingcap.net",
            "oc_v2_secret",
            transport=SequencedReadTransport([(500, b'{"error":"failed"}')]),
        )

        with self.assertRaises(OncallError) as caught:
            load_oncall_teams(client, "ONCALL")

        self.assertNotIn("oc_v2_secret", str(caught.exception))


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