#!/usr/bin/env python3
from __future__ import annotations

import importlib.util
import json
import shlex
import shutil
import subprocess
import unittest
from pathlib import Path


SCRIPT_DIR = Path(__file__).resolve().parent
SKILL_ROOT = SCRIPT_DIR.parent
MODULE_PATH = SCRIPT_DIR / "clinic_api.py"
SHELL_ENTRYPOINT = SCRIPT_DIR / "clinic-shell.sh"

SPEC = importlib.util.spec_from_file_location("clinic_api", MODULE_PATH)
clinic_api = importlib.util.module_from_spec(SPEC)
assert SPEC.loader is not None
SPEC.loader.exec_module(clinic_api)


class RecordingClinicAPI(clinic_api.ClinicAPI):
    def __init__(self) -> None:
        self.calls: list[tuple[str, dict]] = []

    def _api_get(self, path: str, params: dict | None = None) -> dict:
        self.calls.append((path, params or {}))
        return {"items": [], "total": 0}

    def _get(self, path: str, params: dict | None = None) -> dict:
        self.calls.append((path, params or {}))
        return {"items": [], "has_more": False}


class ClinicAPIClusterSearchTest(unittest.TestCase):
    def test_exact_compatibility_lookup_skips_total_count(self):
        api = RecordingClinicAPI()

        api.search_cluster_by_id("123", show_deleted=True, limit=1)

        self.assertEqual(
            api.calls,
            [
                (
                    "/dashboard/clusters2",
                    {
                        "cluster_id": "123",
                        "show_deleted": "true",
                        "limit": 1,
                        "page": 1,
                        "include_total": "false",
                    },
                )
            ],
        )

    def test_advanced_filters_use_repeatable_dashboard_parameters(self):
        api = RecordingClinicAPI()

        api.search_clusters(
            query="tenant name",
            show_deleted=False,
            limit=50,
            page=2,
            cluster_statuses=["active", "offline"],
            deploy_types_v2=["essential v2"],
            providers=["aws", "gcp"],
            regions=["us-west-2"],
            sort="clusterCreatedAt",
            order="ascend",
        )

        self.assertEqual(len(api.calls), 1)
        path, params = api.calls[0]
        self.assertEqual(path, "/dashboard/clusters2")
        self.assertEqual(params["query"], "tenant name")
        self.assertEqual(params["show_deleted"], "false")
        self.assertEqual(params["limit"], 50)
        self.assertEqual(params["page"], 2)
        self.assertEqual(params["cluster_status"], ["active", "offline"])
        self.assertEqual(params["deploy_type_v2"], ["essential v2"])
        self.assertEqual(params["provider"], ["aws", "gcp"])
        self.assertEqual(params["region"], ["us-west-2"])
        self.assertEqual(params["sort"], "clusterCreatedAt")
        self.assertEqual(params["order"], "ascend")
        self.assertEqual(params["include_total"], "false")

    def test_advanced_search_can_request_exact_total(self):
        api = RecordingClinicAPI()

        api.search_clusters(include_total=True)

        path, params = api.calls[0]
        self.assertEqual(path, "/dashboard/clusters2")
        self.assertEqual(params["include_total"], "true")

    def test_invalid_pagination_is_rejected_before_request(self):
        api = RecordingClinicAPI()
        with self.assertRaisesRegex(ValueError, "positive integers"):
            api.search_clusters(limit=0)
        self.assertEqual(api.calls, [])

    def test_org_list_skips_total_count_by_default(self):
        api = RecordingClinicAPI()

        api.list_clusters("123", query="prod", page_size=25, page=2)

        self.assertEqual(
            api.calls,
            [
                (
                    "/data-proxy/api/v1/orgs/123/clusters",
                    {
                        "query": "prod",
                        "showDeleted": "false",
                        "pageSize": 25,
                        "page": 2,
                        "include_total": "false",
                    },
                )
            ],
        )

    def test_org_list_can_request_exact_total(self):
        api = RecordingClinicAPI()

        api.list_clusters("123", include_total=True)

        self.assertEqual(api.calls[0][1]["include_total"], "true")


class ClinicShellClusterSearchTest(unittest.TestCase):
    maxDiff = None

    def invoke(self, command: str, shell: str = "bash", check: bool = True):
        script = f"""
source {shlex.quote(str(SHELL_ENTRYPOINT))}
CLINIC_ENDPOINT=https://clinic.test
CLINIC_API_BASE=https://clinic.test/clinic/api/v1
CLINIC_API_KEY=test-key
_ensure_clinic_auth() {{ return 0; }}
curl() {{
  python3 -c 'import json, sys; print(json.dumps(sys.argv[1:]))' "$@"
}}
{command}
"""
        return subprocess.run(
            [shell, "-c", script],
            cwd=SKILL_ROOT,
            check=check,
            capture_output=True,
            text=True,
        )

    @staticmethod
    def request_args(completed: subprocess.CompletedProcess) -> list[str]:
        lines = [line for line in completed.stdout.splitlines() if line.strip()]
        if not lines:
            raise AssertionError(completed.stderr)
        return json.loads(lines[-1])

    @staticmethod
    def encoded_params(args: list[str]) -> dict[str, list[str]]:
        result: dict[str, list[str]] = {}
        for index, arg in enumerate(args[:-1]):
            if arg != "--data-urlencode":
                continue
            key, separator, value = args[index + 1].partition("=")
            if not separator:
                raise AssertionError(f"malformed parameter: {args[index + 1]!r}")
            result.setdefault(key, []).append(value)
        return result

    def test_advanced_flags_are_passed_to_route_neutral_helper(self):
        completed = self.invoke(
            "clinic_search_clusters "
            "--provider aws --provider gcp "
            "--deploy-type-v2 'essential v2' "
            "--cluster-status active --show-deleted false --limit 50 --page 2"
        )
        args = self.request_args(completed)
        self.assertIn("https://clinic.test/clinic/api/v1/dashboard/clusters2", args)
        self.assertEqual(
            self.encoded_params(args),
            {
                "query": [""],
                "show_deleted": ["false"],
                "limit": ["50"],
                "page": ["2"],
                "include_total": ["false"],
                "provider": ["aws", "gcp"],
                "deploy_type_v2": ["essential v2"],
                "cluster_status": ["active"],
            },
        )

    def test_exact_lookup_skips_total_count(self):
        args = self.request_args(
            self.invoke("clinic_search_cluster_by_id 123 true 1")
        )
        self.assertIn("https://clinic.test/clinic/api/v1/dashboard/clusters2", args)
        self.assertEqual(
            self.encoded_params(args),
            {
                "cluster_id": ["123"],
                "show_deleted": ["true"],
                "limit": ["1"],
                "page": ["1"],
                "include_total": ["false"],
            },
        )

    def test_historical_positional_form_still_works(self):
        args = self.request_args(
            self.invoke("clinic_search_clusters 'tenant name' true 25 3")
        )
        self.assertEqual(
            self.encoded_params(args),
            {
                "query": ["tenant name"],
                "show_deleted": ["true"],
                "limit": ["25"],
                "page": ["3"],
                "include_total": ["false"],
            },
        )

    def test_org_list_skips_total_count_by_default(self):
        args = self.request_args(
            self.invoke("clinic_list_clusters 123 prod false 25 2")
        )
        self.assertIn(
            "https://clinic.test/data-proxy/api/v1/orgs/123/clusters", args
        )
        self.assertEqual(
            self.encoded_params(args),
            {
                "query": ["prod"],
                "showDeleted": ["false"],
                "pageSize": ["25"],
                "page": ["2"],
                "include_total": ["false"],
            },
        )

    def test_org_list_can_request_exact_total(self):
        args = self.request_args(
            self.invoke("clinic_list_clusters 123 '' false 50 1 true")
        )
        self.assertEqual(self.encoded_params(args)["include_total"], ["true"])

    def test_search_can_request_exact_total(self):
        args = self.request_args(
            self.invoke("clinic_search_clusters --include-total true")
        )
        self.assertEqual(
            self.encoded_params(args)["include_total"],
            ["true"],
        )

    def test_empty_advanced_filter_array_is_bash_nounset_safe(self):
        args = self.request_args(
            self.invoke("set -u\nclinic_search_clusters 'tenant name' false 25 3")
        )
        self.assertIn("https://clinic.test/clinic/api/v1/dashboard/clusters2", args)
        self.assertEqual(
            self.encoded_params(args),
            {
                "query": ["tenant name"],
                "show_deleted": ["false"],
                "limit": ["25"],
                "page": ["3"],
                "include_total": ["false"],
            },
        )

    def test_unknown_option_fails_before_request(self):
        completed = self.invoke(
            "clinic_search_clusters --unknown value", check=False
        )
        self.assertEqual(completed.returncode, 2)
        self.assertNotIn("[\"-s\"", completed.stdout)
        self.assertIn("unsupported option", completed.stderr)

    def test_invalid_include_total_fails_before_request(self):
        completed = self.invoke(
            "clinic_search_clusters --include-total sometimes", check=False
        )
        self.assertEqual(completed.returncode, 2)
        self.assertNotIn("[\"-s\"", completed.stdout)
        self.assertIn("--include-total must be true or false", completed.stderr)

    @unittest.skipUnless(shutil.which("zsh"), "zsh is not installed")
    def test_zsh_preserves_repeatable_filters(self):
        args = self.request_args(
            self.invoke(
                "clinic_search_clusters --provider aws --provider gcp "
                "--deploy-type-v2 'essential v2'",
                shell="zsh",
            )
        )
        params = self.encoded_params(args)
        self.assertEqual(params["provider"], ["aws", "gcp"])
        self.assertEqual(params["deploy_type_v2"], ["essential v2"])


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