from __future__ import annotations

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


ROOT = Path(__file__).parents[1]
SCRIPTS = ROOT / "scripts"
sys.path.insert(0, str(SCRIPTS))


def load_module(name: str, relative_path: str):
    path = SCRIPTS / relative_path
    spec = importlib.util.spec_from_file_location(name, path)
    assert spec and spec.loader
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


COMMON = load_module("test_o11y_common", "o11y_common.py")
METRICS = load_module("test_query_o11y_metrics", "query_o11y_metrics.py")
LOKI = load_module("test_query_o11y_loki", "query_o11y_loki.py")


class O11yReauthTest(unittest.TestCase):
    def test_force_refresh_bypasses_valid_cached_token(self):
        with mock.patch.dict(
            os.environ,
            {
                "O11Y_AUTH0_TOKEN": "cached-token",
                "O11Y_AUTH0_TOKEN_EXPIRES": "4102444800",
                "GITHUB_PAT": "pat-for-test",
            },
            clear=False,
        ), mock.patch.object(
            COMMON, "request_json", return_value={"auth0_token": "fresh-token"}
        ) as request:
            with mock.patch.object(COMMON, "load_runtime_config", return_value=None):
                token, auth, provider = COMMON.get_auth0_token(
                    "aws", timeout=1, force_refresh=True
                )

        self.assertEqual((token, auth, provider), ("fresh-token", "fresh", "aws"))
        request.assert_called_once()

    def test_403_message_mentions_vpn_without_secret_details(self):
        message = COMMON.o11y_403_message("metrics")

        self.assertIn("403", message)
        self.assertIn("Office network/Feilian VPN", message)
        self.assertNotIn("Bearer", message)

    def test_metrics_request_preserves_initial_403_when_curl_fallback_fails(self):
        response = mock.Mock(status_code=403)
        response.json.return_value = {"status": "error"}
        with mock.patch.object(METRICS.requests, "get", return_value=response), mock.patch(
            "subprocess.run", side_effect=OSError("curl unavailable")
        ):
            status, _ = METRICS.request_metrics(
                "https://example.invalid/query_range",
                "old-token",
                "vector(1)",
                1,
                2,
                1,
                1,
            )

        self.assertEqual(status, 403)

    def test_loki_http_error_preserves_403_status(self):
        error = LOKI.LokiHTTPError(403, "forbidden")

        self.assertEqual(error.status_code, 403)
        self.assertIn("HTTP 403", str(error))

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