from __future__ import annotations

import importlib.util
import io
import json
import sys
import unittest
from contextlib import redirect_stderr, redirect_stdout
from pathlib import Path


SCRIPT = Path(__file__).parents[1] / "scripts" / "resolve_serverless_pool.py"
SPEC = importlib.util.spec_from_file_location("resolve_serverless_pool", SCRIPT)
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 ResolveServerlessPoolTest(unittest.TestCase):
    def test_bare_aws_pool(self):
        routing = MODULE.resolve("us-west-2-f01")
        self.assertEqual(routing.pool, "us-west-2-f01")
        self.assertEqual(routing.vendor, "aws")
        self.assertEqual(routing.vendor_region, "aws-us-west-2")
        self.assertEqual(routing.application, "devtier-infra")
        self.assertEqual(
            routing.control_plane_info, "us-west-2-f01/aws-us-west-2/devtier-infra"
        )
        self.assertEqual(routing.promql_control_plane_info, "us-west-2-f01/aws-us-west-2")
        self.assertEqual(routing.loki_datasource, "Loki-aws-us-west-2")
        self.assertEqual(routing.prod_loki_cluster, "prod-us-west-2-f01")

    def test_bare_alicloud_pool(self):
        routing = MODULE.resolve("na-south-1-a01")
        self.assertEqual(routing.vendor, "alicloud")
        self.assertEqual(routing.vendor_region, "alicloud-na-south-1")
        self.assertEqual(
            routing.control_plane_info, "na-south-1-a01/alicloud-na-south-1/devtier-infra"
        )

    def test_full_control_plane_info_round_trip(self):
        routing = MODULE.resolve("eu-central-1-f02/aws-eu-central-1/devtier-infra")
        self.assertEqual(routing.pool, "eu-central-1-f02")
        self.assertEqual(routing.vendor_region, "aws-eu-central-1")
        self.assertEqual(
            routing.control_plane_info, "eu-central-1-f02/aws-eu-central-1/devtier-infra"
        )

    def test_full_value_with_mismatched_vendor_region_rejected(self):
        with self.assertRaisesRegex(ValueError, "does not match pool"):
            MODULE.resolve("us-west-2-f01/aws-us-east-1/devtier-infra")

    def test_application_override_on_bare_pool(self):
        routing = MODULE.resolve("us-west-2-f01", application="staging-infra")
        self.assertEqual(
            routing.control_plane_info, "us-west-2-f01/aws-us-west-2/staging-infra"
        )

    def test_application_override_on_full_value(self):
        routing = MODULE.resolve(
            "us-west-2-f01/aws-us-west-2/devtier-infra", application="staging-infra"
        )
        self.assertEqual(routing.application, "staging-infra")

    def test_wrong_segment_count_rejected(self):
        for bad in ("us-west-2", "us-west-2-f01-x", "us--2-f01", "us-west-2-f01/extra"):
            with self.assertRaises(ValueError, msg=bad):
                MODULE.resolve(bad)

    def test_unknown_vendor_code_rejected(self):
        with self.assertRaisesRegex(ValueError, "unknown vendor code"):
            MODULE.resolve("us-west-2-g01")

    def test_shell_metacharacters_in_routing_values_are_rejected(self):
        for application in ("$(touch /tmp/injected)", "bad;command", "bad value", "bad\nvalue", ""):
            with self.assertRaisesRegex(ValueError, "application must contain only"):
                MODULE.resolve("us-west-2-f01", application=application)
        with self.assertRaisesRegex(ValueError, "four dash-separated segments"):
            MODULE.resolve("us-west-2-f01$(command)")

    def test_cli_key_value_output(self):
        stdout = io.StringIO()
        with redirect_stdout(stdout):
            exit_code = MODULE.main(["us-west-2-f01"])
        self.assertEqual(exit_code, 0)
        self.assertIn(
            "control_plane_info=us-west-2-f01/aws-us-west-2/devtier-infra\n",
            stdout.getvalue(),
        )

    def test_cli_json_output(self):
        stdout = io.StringIO()
        with redirect_stdout(stdout):
            exit_code = MODULE.main(["--json", "na-south-1-a01"])
        self.assertEqual(exit_code, 0)
        payload = json.loads(stdout.getvalue())
        self.assertEqual(payload["vendor_region"], "alicloud-na-south-1")
        self.assertEqual(payload["loki_datasource"], "Loki-alicloud-na-south-1")

    def test_cli_invalid_input_exit_code(self):
        stderr = io.StringIO()
        with redirect_stderr(stderr):
            exit_code = MODULE.main(["us-west-2-g01"])
        self.assertEqual(exit_code, 2)
        self.assertIn("unknown vendor code", stderr.getvalue())

    def test_cli_rejects_unsafe_application(self):
        stdout = io.StringIO()
        stderr = io.StringIO()
        with redirect_stdout(stdout), redirect_stderr(stderr):
            exit_code = MODULE.main([
                "us-west-2-f01",
                "--application",
                "$(printf injected)",
            ])
        self.assertEqual(exit_code, 2)
        self.assertEqual(stdout.getvalue(), "")
        self.assertIn("application must contain only", stderr.getvalue())


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