"""ASV benchmarks for Config Service resolution chain performance.

Measures the performance of:
- Single key resolution (default, global, env var, CLI flag)
- Full registry resolution (resolve_all)
- Key validation and type coercion
"""

from __future__ import annotations

import importlib
import os
import shutil
import sys
import tempfile
from pathlib import Path

# Ensure the local *source* tree is importable even when ASV has an
# older build of the package installed.
_SRC = str(Path(__file__).resolve().parents[1] / "src")
if _SRC not in sys.path:
    sys.path.insert(0, _SRC)

import cleveragents  # noqa: E402

importlib.reload(cleveragents)

from cleveragents.application.services.config_service import (  # noqa: E402
    ConfigService,
)


class ConfigResolutionDefaultSuite:
    """Benchmark default resolution (no overrides)."""

    def setup(self) -> None:
        self._tmpdir = Path(tempfile.mkdtemp())
        self._service = ConfigService(
            config_dir=self._tmpdir,
            config_path=self._tmpdir / "config.toml",
        )

    def teardown(self) -> None:
        shutil.rmtree(str(self._tmpdir), ignore_errors=True)

    def time_resolve_default(self) -> None:
        """Benchmark resolving a single key from defaults."""
        self._service.resolve("core.log_level")

    def time_resolve_default_verbose(self) -> None:
        """Benchmark resolving a single key with verbose chain."""
        self._service.resolve("core.log_level", verbose=True)


class ConfigResolutionGlobalSuite:
    """Benchmark resolution from global config file."""

    def setup(self) -> None:
        self._tmpdir = Path(tempfile.mkdtemp())
        self._service = ConfigService(
            config_dir=self._tmpdir,
            config_path=self._tmpdir / "config.toml",
        )
        self._service.set_value("core.log_level", "DEBUG")

    def teardown(self) -> None:
        shutil.rmtree(str(self._tmpdir), ignore_errors=True)

    def time_resolve_global(self) -> None:
        """Benchmark resolving from global config file."""
        self._service.resolve("core.log_level")


class ConfigResolutionEnvSuite:
    """Benchmark resolution from env var."""

    def setup(self) -> None:
        self._tmpdir = Path(tempfile.mkdtemp())
        self._service = ConfigService(
            config_dir=self._tmpdir,
            config_path=self._tmpdir / "config.toml",
        )
        os.environ["CLEVERAGENTS_CORE_LOG_LEVEL"] = "WARNING"

    def teardown(self) -> None:
        os.environ.pop("CLEVERAGENTS_CORE_LOG_LEVEL", None)
        shutil.rmtree(str(self._tmpdir), ignore_errors=True)

    def time_resolve_env(self) -> None:
        """Benchmark resolving from environment variable."""
        self._service.resolve("core.log_level")


class ConfigResolutionCLISuite:
    """Benchmark resolution with CLI flag."""

    def setup(self) -> None:
        self._tmpdir = Path(tempfile.mkdtemp())
        self._service = ConfigService(
            config_dir=self._tmpdir,
            config_path=self._tmpdir / "config.toml",
        )

    def teardown(self) -> None:
        shutil.rmtree(str(self._tmpdir), ignore_errors=True)

    def time_resolve_cli(self) -> None:
        """Benchmark resolving with CLI flag (highest priority)."""
        self._service.resolve("core.log_level", cli_value="ERROR")


class ConfigResolutionBulkSuite:
    """Benchmark bulk operations."""

    def setup(self) -> None:
        self._tmpdir = Path(tempfile.mkdtemp())
        self._service = ConfigService(
            config_dir=self._tmpdir,
            config_path=self._tmpdir / "config.toml",
        )

    def teardown(self) -> None:
        shutil.rmtree(str(self._tmpdir), ignore_errors=True)

    def time_resolve_all(self) -> None:
        """Benchmark resolving all registered keys."""
        self._service.resolve_all()

    def time_registry_keys(self) -> None:
        """Benchmark listing all registered keys."""
        ConfigService.registered_keys()


class ConfigValidationSuite:
    """Benchmark key validation and type coercion."""

    def time_validate_known_key(self) -> None:
        """Benchmark validating a known key."""
        ConfigService.validate_key("core.log_level")

    def time_validate_type_str(self) -> None:
        """Benchmark type coercion for string."""
        ConfigService.validate_type("core.log_level", "DEBUG")

    def time_validate_type_int(self) -> None:
        """Benchmark type coercion for integer."""
        ConfigService.validate_type("core.server_port", "8080")

    def time_validate_type_bool(self) -> None:
        """Benchmark type coercion for boolean."""
        ConfigService.validate_type("core.debug_enabled", "true")