"""Fail-closed URL identity normalization for model/provider routes."""

from __future__ import annotations

from typing import Any, Optional
from urllib.parse import urlsplit, urlunsplit


def normalize_route_base_url(base_url: Any) -> str:
    """Canonicalize only proven-equivalent endpoint URL components."""
    raw = str(base_url or "")
    if not raw:
        return ""
    if any(ord(char) <= 0x20 for char in raw):
        return raw
    had_query_delimiter = "?" in raw.split("#", 1)[0]
    try:
        parsed = urlsplit(raw)
        hostname = parsed.hostname
        if not parsed.scheme or not hostname:
            return raw
        scheme = parsed.scheme.lower()
        if "%" in hostname:
            address, zone = hostname.split("%", 1)
            host = f"{address.lower()}%{zone}"
        else:
            host = hostname.lower()
        port = parsed.port
    except (TypeError, ValueError):
        return raw
    route_host = parsed.netloc.rsplit("@", 1)[-1]
    if route_host.startswith("[") or ":" in host:
        host = f"[{host}]"
    if port is not None and (scheme, port) not in {("http", 80), ("https", 443)}:
        host = f"{host}:{port}"
    if "@" in parsed.netloc:
        host = f"{parsed.netloc.rsplit('@', 1)[0]}@{host}"
    path = parsed.path
    if path.endswith("/") and not had_query_delimiter:
        path = path[:-1]
    normalized = urlunsplit((scheme, host, path, parsed.query, ""))
    if had_query_delimiter and not parsed.query:
        normalized += "?"
    return normalized


def provider_owns_route(provider: Any, base_url: Any, config: Any = None) -> Optional[bool]:
    """Whether ``model.base_url`` is *provider*'s own endpoint.

    ``True``: the host is the provider's registry/plugin endpoint or the endpoint of a
    ``providers:``/``custom_providers:`` entry that resolves to *provider*, or *provider* is bare
    ``custom``/``local`` (the URL *is* the route). ``False``: the host is another known provider's
    stock endpoint, or *provider* names a user entry with a different endpoint. ``None``: unknown
    host (a proxy, a LAN server) — nothing here can say whose it is. Offline: the registry lookup
    never fetches the models.dev catalog.
    """
    from hermes_cli.providers import get_provider, normalize_provider, resolve_custom_provider, resolve_user_provider
    from utils import base_url_hostname

    host = base_url_hostname(str(base_url or ""))
    if not host:
        return None
    raw = str(provider or "").strip().lower()
    canonical = normalize_provider(raw)
    if canonical in ("custom", "local"):
        # Bare custom / local-server aliases are configured BY model.base_url (#14676, #27132);
        # resolve_custom_provider would also self-heal bare "custom" to the first entry (#17478).
        return True
    cfg = config if isinstance(config, dict) else {}
    user_pdef = resolve_user_provider(raw, cfg.get("providers") or {}) or resolve_custom_provider(
        raw, cfg.get("custom_providers"))
    if user_pdef is not None and user_pdef.base_url:
        return base_url_hostname(user_pdef.base_url) == host
    pdef = get_provider(canonical, allow_network=False)
    if pdef is not None and pdef.base_url and base_url_hostname(pdef.base_url) == host:
        return True
    if pdef is None and user_pdef is None:
        return True
    from agent.model_metadata import _infer_provider_from_url
    inferred = _infer_provider_from_url(str(base_url))
    if inferred is None:
        return None
    return normalize_provider(inferred) == canonical


def drop_stale_model_route(model_cfg: Any, provider: Any, config: Any = None) -> "tuple[dict[str, Any], bool]":
    """Pop the route keys (``base_url``, ``api_mode``) a previous provider left in ``model:``
    when the block is re-pointed at *provider* without a fresh route (``hermes config set
    model.provider``). Mirrors what a persisted ``/model`` switch writes: the route is synced to
    the target, never carried over. Returns ``(popped {key: old value}, unverified)`` where
    ``unverified`` is True when a base_url of unknown ownership was kept — the caller should say so.
    A base_url that belongs to *provider* is kept together with its api_mode; with no base_url the
    api_mode alone is wire state of the old route and goes."""
    if not isinstance(model_cfg, dict):
        return {}, False
    base_url = str(model_cfg.get("base_url") or "").strip()
    owned = provider_owns_route(provider, base_url, config) if base_url else False
    if owned:
        return {}, False
    if owned is None:
        return {}, True
    popped = {k: model_cfg.pop(k) for k in ("base_url", "api_mode") if model_cfg.get(k) not in (None, "")}
    return popped, False


def should_clear_context_pin(configured_model: Any, active_model: Any, configured_base_url: Any, active_base_url: Any,
                             configured_provider: Any, active_provider: Any) -> bool:
    """True when a configured ``model.context_length`` pin no longer matches its runtime route.
    Fail-closed: any error during route comparison returns ``True`` (drop the pin) so a stale window
    never silently inflates the compression threshold."""
    configured_model = str(configured_model or "").strip()
    if configured_model and configured_model != str(active_model or "").strip():
        return True
    try:
        from agent.agent_init import _context_route_mismatch
        return _context_route_mismatch(configured_base_url, active_base_url, configured_provider, active_provider)
    except Exception:
        return True


async def should_clear_context_pin_async(*args: Any) -> bool:
    """``should_clear_context_pin`` on a worker thread so async gateway handlers never run it on the
    event loop — the resolution chain is cache-only (``allow_network=False``) but can still do
    cold-start disk I/O."""
    import asyncio
    return await asyncio.to_thread(should_clear_context_pin, *args)