"""
Rilevamento automatico credenziali / env per server MCP arbitrari (senza catalogo curato).

Fonti: README, .env.example, sorgenti, env già presenti nel registry.
"""

from __future__ import annotations

import os
import re
import time
import json
import logging
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set

from .mcp_server_files import resolve_mcp_server_dir

logger = logging.getLogger("aion.mcp_credential_discovery")

# ---------------------------------------------------------------------------
# TTL cache for probe_remote_url_sync – avoids re-probing the same URL
# during a single request (the function is called 2-3× per integration).
# ---------------------------------------------------------------------------
_PROBE_CACHE: dict[str, tuple[float, Dict[str, Any]]] = {}
_PROBE_CACHE_TTL: int = int(os.environ.get("AION_INTEGRATIONS_PROBE_TTL", "60"))

# ---------------------------------------------------------------------------
# Per-slug cache for discover_mcp_credentials – eliminates the 2-3 redundant
# calls per integration during the integrations-list endpoint.
# ---------------------------------------------------------------------------
_DISCOVERY_CACHE: dict[str, CredentialDiscoveryResult] = {}

# Timeout for HTTP probes – reduced from 15 s to a configurable value
# (default 5 s).  Page-load probing does not need a full 15 s wait.
_PROBE_TIMEOUT: float = float(os.environ.get("AION_INTEGRATIONS_PROBE_TIMEOUT", "5"))

# Env di runtime / framework — non chiedere in chat-ui
_SKIP_ENV = frozenset(
    {
        "NODE_ENV",
        "PATH",
        "HOME",
        "USER",
        "SHELL",
        "LANG",
        "LC_ALL",
        "PWD",
        "TMPDIR",
        "PYTHONPATH",
        "PYTHONUNBUFFERED",
        "CI",
        "DEBUG",
        "LOG_LEVEL",
        "NO_COLOR",
        "FORCE_COLOR",
        "TERM",
        "PORT",
        "HOST",
        "HOSTNAME",
        "DOTENV_CONFIG_PATH",
        "FASTMCP_LOG_LEVEL",
        "FASTMCP_SHOW_SERVER_BANNER",
        "FASTMCP_CHECK_FOR_UPDATES",
        "MCP_TRANSPORT",
        "UV_THREADPOOL_SIZE",
    }
)

_SKIP_PREFIXES = ("AION_", "FASTMCP_", "MCP_LOG", "VITE_", "NEXT_PUBLIC_")

_CREDENTIAL_KEY_RE = re.compile(
    r"(TOKEN|SECRET|PASSWORD|API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|CLIENT_SECRET|"
    r"REFRESH|CREDENTIAL|AUTH|EMAIL|IMAP|SMTP|BEARER|OAUTH)",
    re.I,
)

_ENV_PATTERNS = [
    re.compile(r"process\.env\.([A-Z][A-Z0-9_]*)", re.M),
    re.compile(r"""process\.env\[['"]([A-Z][A-Z0-9_]*)['"]\]""", re.M),
    re.compile(r"""os\.environ\[['"]([A-Z][A-Z0-9_]*)['"]\]""", re.M),
    re.compile(r"""os\.getenv\(\s*['"]([A-Z][A-Z0-9_]*)['"]""", re.M),
    re.compile(r"""['"]([A-Z][A-Z0-9_]{2,})['"]\s*:\s*process\.env""", re.M),
    re.compile(r"^\s*([A-Z][A-Z0-9_]+)\s*:\s*z\.", re.M),
    re.compile(r"\b([A-Z][A-Z0-9_]{3,})\s*:\s*z\.string", re.M),
    re.compile(r'"([A-Z][A-Z0-9_]{3,})"\s*:\s*"', re.M),
    re.compile(r"^\s*([A-Z][A-Z0-9_]+)\s*=", re.M),
]

_AION_USER_KEY_RE = re.compile(r"^\$\{AION_USER_[A-Z0-9_]+__([A-Z0-9_]+)\}$")
_ENV_PLACEHOLDER_RE = re.compile(r"^\$\{([A-Z][A-Z0-9_]+)\}$")
# Wildcard ``${AION_USER_<SLUG>__*}``: the process receives *all* of the user's
# credentials for the slug as one JSON object (see ``credential_store``).  The
# env var carrying it is plumbing, not something the user fills in, so it must
# never become a credential form field.
_AION_USER_WILDCARD_RE = re.compile(r"^\$\{AION_USER_[A-Z0-9_]+__\*\}$")


def _wildcard_env_keys(env: Dict[str, Any]) -> Set[str]:
    """Registry env names whose value is the ``${AION_USER_<SLUG>__*}`` wildcard."""
    return {
        str(k).strip()
        for k, v in (env or {}).items()
        if isinstance(v, str) and _AION_USER_WILDCARD_RE.match(v.strip())
    }


_CONFIG_FILE_HINTS = re.compile(
    r"config\.toml|\.config/|xdg|XDG_CONFIG|credentials?\s+file|file\s+di\s+configurazione",
    re.I,
)


@dataclass
class CredentialDiscoveryResult:
    env_keys: List[str] = field(default_factory=list)
    schema: List[Dict[str, Any]] = field(default_factory=list)
    credential_mode_hint: str = "none"
    sources: List[str] = field(default_factory=list)
    config_file_auth: bool = False
    has_env_auth: bool = False
    remote_auth_type: Optional[str] = None
    remote_connect_url: Optional[str] = None
    remote_docs_url: Optional[str] = None
    remote_hint: Optional[str] = None
    remote_error: Optional[str] = None
    remote_oauth_provider: Optional[str] = None
    remote_oauth_server: Optional[str] = None
    remote_oauth_token_url: Optional[str] = None


_BOOLEAN_KEY_RE = re.compile(
    r"(^ENABLE_|^USE_|^DISABLE_|^ALLOW_|^REQUIRE_|^IS_|^AUTO_|^DEBUG$|_SSL$|_TLS$|_SECURE$|_ENABLED$|_DISABLED$|_DEBUG$)",
    re.I,
)

_SECRET_KEY_RE = re.compile(
    r"(TOKEN|SECRET|PASSWORD|PASS|API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|CLIENT_SECRET|AUTH|BEARER|OAUTH)",
    re.I,
)

_BASIC_KEY_RE = re.compile(
    r"(^(EMAIL|USER|USERNAME|LOGIN|ACCOUNT|ID|CLIENT_ID|TOKEN|API_KEY|SECRET|PASSWORD|PASS|PAT|ACCESS_TOKEN)$|_EMAIL$|_USERNAME$|_PASSWORD$|_TOKEN$|_API_KEY$|_SECRET$|_PAT$)",
    re.I,
)

_ACRONYMS = frozenset(
    {
        "IMAP",
        "SMTP",
        "SSL",
        "TLS",
        "API",
        "URL",
        "URI",
        "ID",
        "SSH",
        "HTTP",
        "HTTPS",
        "JSON",
        "SQL",
        "DB",
        "PAT",
        "OAUTH",
    }
)

_FRIENDLY_METADATA_MAP: Dict[str, Dict[str, Any]] = {
    "IMAP_HOST": {
        "label": "Server Posta in Arrivo (IMAP)",
        "description": "Indirizzo del server IMAP (es. imap.gmail.com, outlook.office365.com)",
        "category": "advanced",
        "type": "text",
    },
    "IMAP_PORT": {
        "label": "Porta IMAP",
        "description": "Porta per la connessione IMAP (predefinita: 993 per SSL)",
        "category": "advanced",
        "type": "text",
        "default_value": "993",
    },
    "SMTP_HOST": {
        "label": "Server Posta in Uscita (SMTP)",
        "description": "Indirizzo del server SMTP (es. smtp.gmail.com, smtp.office365.com)",
        "category": "advanced",
        "type": "text",
    },
    "SMTP_PORT": {
        "label": "Porta SMTP",
        "description": "Porta per la connessione SMTP (predefinita: 587 o 465)",
        "category": "advanced",
        "type": "text",
        "default_value": "587",
    },
    "EMAIL": {
        "label": "Indirizzo Email",
        "description": "Il tuo indirizzo email completo",
        "category": "basic",
        "type": "text",
    },
    "EMAIL_ADDRESS": {
        "label": "Indirizzo Email",
        "description": "Il tuo indirizzo email completo",
        "category": "basic",
        "type": "text",
    },
    "EMAIL_USER": {
        "label": "Nome Utente / Email",
        "description": "Nome utente o email per l'accesso",
        "category": "basic",
        "type": "text",
    },
    "PASSWORD": {
        "label": "Password / App Password",
        "description": "Password dell'account o Password per le App (consigliata se hai il 2FA)",
        "category": "basic",
        "type": "password",
    },
    "EMAIL_PASSWORD": {
        "label": "Password / App Password",
        "description": "Password dell'account o Password per le App (consigliata se hai il 2FA)",
        "category": "basic",
        "type": "password",
    },
    "APP_PASSWORD": {
        "label": "Password per le App",
        "description": "Password applicativa generata nelle impostazioni di sicurezza dell'account",
        "category": "basic",
        "type": "password",
    },
    "USE_SSL": {
        "label": "Connessione Sicura (SSL/TLS)",
        "description": "Abilita crittografia SSL/TLS per la trasmissione sicura dei dati",
        "category": "advanced",
        "type": "boolean",
        "default_value": "true",
    },
    "ENABLE_SSL": {
        "label": "Connessione Sicura (SSL)",
        "description": "Abilita crittografia SSL per la connessione",
        "category": "advanced",
        "type": "boolean",
        "default_value": "true",
    },
    "ENABLE_TLS": {
        "label": "Connessione Sicura (TLS)",
        "description": "Abilita crittografia TLS per la connessione",
        "category": "advanced",
        "type": "boolean",
        "default_value": "true",
    },
    "ENABLE_ATTACHMENT_DOWNLOAD": {
        "label": "Scarica Allegati",
        "description": "Consente all'agente di scaricare e analizzare i file allegati",
        "category": "advanced",
        "type": "boolean",
        "default_value": "true",
    },
    "FOLDER": {
        "label": "Cartella di Posta",
        "description": "Cartella email di default (es. INBOX)",
        "category": "advanced",
        "type": "text",
        "default_value": "INBOX",
    },
    "MAILBOX": {
        "label": "Casella di Posta",
        "description": "Nome della casella di posta (es. INBOX)",
        "category": "advanced",
        "type": "text",
        "default_value": "INBOX",
    },
    "API_KEY": {
        "label": "Chiave API",
        "description": "Chiave API segreta generata dalla piattaforma",
        "category": "basic",
        "type": "password",
    },
    "API_TOKEN": {
        "label": "Token API",
        "description": "Token di autorizzazione per accedere al servizio",
        "category": "basic",
        "type": "password",
    },
    "ACCESS_TOKEN": {
        "label": "Token di Accesso",
        "description": "Token personale per autenticare le richieste",
        "category": "basic",
        "type": "password",
    },
    "PERSONAL_ACCESS_TOKEN": {
        "label": "Personal Access Token",
        "description": "Token personale generato nelle impostazioni sviluppatore",
        "category": "basic",
        "type": "password",
    },
    "PAT": {
        "label": "Personal Access Token",
        "description": "Token personale generato nelle impostazioni sviluppatore",
        "category": "basic",
        "type": "password",
    },
    "CLIENT_ID": {
        "label": "Client ID",
        "description": "Identificativo client dell'applicazione",
        "category": "basic",
        "type": "text",
    },
    "CLIENT_SECRET": {
        "label": "Client Secret",
        "description": "Secret dell'applicazione",
        "category": "basic",
        "type": "password",
    },
    "USERNAME": {
        "label": "Nome Utente",
        "description": "Nome utente del tuo account",
        "category": "basic",
        "type": "text",
    },
    "USER": {
        "label": "Nome Utente",
        "description": "Nome utente del tuo account",
        "category": "basic",
        "type": "text",
    },
}


def _clean_prefix(key: str) -> str:
    cleaned = key
    for prefix in ("MCP_EMAIL_SERVER_", "MCP_SERVER_", "MCP_"):
        if cleaned.startswith(prefix) and len(cleaned) > len(prefix):
            return cleaned[len(prefix) :]
    return cleaned


def _should_skip_env(key: str) -> bool:
    if not key or len(key) < 2:
        return True
    if key in _SKIP_ENV:
        return True
    if key.startswith("AION_"):
        return not _is_credential_key(key)
    return any(key.startswith(p) for p in _SKIP_PREFIXES)


def _is_credential_key(key: str) -> bool:
    return bool(_CREDENTIAL_KEY_RE.search(key))


_NUMBER_KEY_RE = re.compile(
    r"(PORT$|TIMEOUT$|_LIMIT$|_RETRIES$|_MAX_|_MIN_|^PORT$|^TIMEOUT$)",
    re.I,
)


def _field_type(key: str, default_val: Any = None) -> str:
    cleaned = _clean_prefix(key)
    if cleaned in _FRIENDLY_METADATA_MAP and "type" in _FRIENDLY_METADATA_MAP[cleaned]:
        return str(_FRIENDLY_METADATA_MAP[cleaned]["type"])
    if key in _FRIENDLY_METADATA_MAP and "type" in _FRIENDLY_METADATA_MAP[key]:
        return str(_FRIENDLY_METADATA_MAP[key]["type"])
    if default_val is not None and str(default_val).strip().lower() in (
        "true",
        "false",
    ):
        return "boolean"
    if _BOOLEAN_KEY_RE.search(cleaned):
        return "boolean"
    if _SECRET_KEY_RE.search(cleaned):
        return "password"
    if _NUMBER_KEY_RE.search(cleaned):
        return "number"
    if default_val is not None and str(default_val).strip().isdigit():
        return "number"
    return "text"


def _field_category(key: str) -> str:
    cleaned = _clean_prefix(key)
    if (
        cleaned in _FRIENDLY_METADATA_MAP
        and "category" in _FRIENDLY_METADATA_MAP[cleaned]
    ):
        return str(_FRIENDLY_METADATA_MAP[cleaned]["category"])
    if key in _FRIENDLY_METADATA_MAP and "category" in _FRIENDLY_METADATA_MAP[key]:
        return str(_FRIENDLY_METADATA_MAP[key]["category"])
    if _BASIC_KEY_RE.search(cleaned):
        return "basic"
    return "advanced"


def _keys_from_text(text: str) -> Set[str]:
    found: Set[str] = set()
    if not text:
        return found
    for pat in _ENV_PATTERNS:
        for m in pat.finditer(text):
            k = m.group(1)
            if k and not _should_skip_env(k):
                found.add(k)
    return found


def _keys_from_registry_env(env: Dict[str, Any]) -> Set[str]:
    """Chiavi env del registry (nome variabile MCP), non il testo interno ai placeholder."""
    found: Set[str] = set()
    for key, val in (env or {}).items():
        if isinstance(val, str) and _AION_USER_WILDCARD_RE.match(val.strip()):
            continue  # wildcard carrier, not a user-facing key
        if isinstance(key, str) and key.strip() and not _should_skip_env(key.strip()):
            found.add(key.strip())
        if isinstance(val, str):
            s = val.strip()
            m = _AION_USER_KEY_RE.match(s)
            if m:
                found.add(m.group(1))
                continue
            m2 = _ENV_PLACEHOLDER_RE.match(s)
            if m2:
                inner = m2.group(1)
                if inner.startswith("AION_USER_"):
                    continue
                if _is_credential_key(inner):
                    found.add(inner)
    return found


def _label_for_env_key(key: str) -> str:
    cleaned = _clean_prefix(key)
    if cleaned in _FRIENDLY_METADATA_MAP and "label" in _FRIENDLY_METADATA_MAP[cleaned]:
        return str(_FRIENDLY_METADATA_MAP[cleaned]["label"])
    if key in _FRIENDLY_METADATA_MAP and "label" in _FRIENDLY_METADATA_MAP[key]:
        return str(_FRIENDLY_METADATA_MAP[key]["label"])

    words = cleaned.split("_")
    formatted_words: List[str] = []
    for w in words:
        if not w:
            continue
        u = w.upper()
        if u in _ACRONYMS:
            formatted_words.append(u)
        else:
            formatted_words.append(w.capitalize())
    return " ".join(formatted_words) if formatted_words else key


def _schema_from_keys(
    keys: List[str],
    defaults: Optional[Dict[str, Any]] = None,
    static_org_keys: Optional[Set[str]] = None,
) -> List[Dict[str, Any]]:
    schema: List[Dict[str, Any]] = []
    defaults = defaults or {}
    static_org_keys = static_org_keys or set()
    for k in keys:
        if k.startswith("AION_USER_") or k in static_org_keys:
            continue
        cleaned = _clean_prefix(k)
        meta = (
            _FRIENDLY_METADATA_MAP.get(cleaned) or _FRIENDLY_METADATA_MAP.get(k) or {}
        )
        ftype = meta.get("type") or _field_type(k, defaults.get(k))
        fcat = meta.get("category") or _field_category(k)
        desc = meta.get("description")
        # ``is None`` instead of ``or``: a falsy default (``False``, "0") is a
        # real default (toggle off) and must not fall back to the catalog one.
        default_v = defaults.get(k)
        if default_v is None:
            default_v = meta.get("default_value")

        is_required = True
        if ftype == "boolean":
            is_required = False
        elif fcat == "advanced" and default_v is not None:
            is_required = False

        field_dict: Dict[str, Any] = {
            "key": k,
            "label": meta.get("label") or _label_for_env_key(k),
            "type": ftype,
            "category": fcat,
            "required": is_required,
            "description": desc,
        }
        if default_v is not None:
            field_dict["default_value"] = default_v
        schema.append(field_dict)
    return schema


def classify_from_headers(
    headers: List[Dict[str, Any]], remote: Dict[str, Any], meta: Dict[str, Any]
) -> Dict[str, Any]:
    has_bearer = False
    has_basic = False
    has_oauth = False

    for h in headers:
        if not isinstance(h, dict):
            continue
        name = str(h.get("name") or "").lower()
        value = str(h.get("value") or "").lower()
        if "bearer" in value or "bearer" in name:
            has_bearer = True
        elif "basic" in value or "basic" in name:
            has_basic = True
        elif "oauth" in value or "oauth" in name or "authorization_uri" in value:
            has_oauth = True

    connect_url = meta.get("connect") or None
    url = remote.get("url")

    if has_oauth:
        return {
            "type": "oauth2",
            "url": url,
            "connectUrl": connect_url,
            "credential_mode": "per_user",
            "credential_schema": [
                {
                    "key": "OAUTH_TOKEN",
                    "label": "OAuth Token",
                    "type": "oauth",
                    "required": True,
                }
            ],
        }
    if has_bearer:
        return {
            "type": "api-key",
            "url": url,
            "connectUrl": connect_url,
            "credential_mode": "per_user",
            "credential_schema": [
                {
                    "key": "API_KEY",
                    "label": "API Key",
                    "type": "password",
                    "required": True,
                }
            ],
        }
    if has_basic:
        return {
            "type": "basic",
            "url": url,
            "connectUrl": connect_url,
            "credential_mode": "per_user",
            "credential_schema": [
                {
                    "key": "BASIC_AUTH",
                    "label": "Basic Auth Credentials",
                    "type": "password",
                    "required": True,
                }
            ],
        }
    return {
        "type": "api-key",
        "url": url,
        "connectUrl": connect_url,
        "credential_mode": "per_user",
        "credential_schema": [
            {"key": "API_KEY", "label": "API Key", "type": "password", "required": True}
        ],
    }


def extract_url_from_www_authenticate(www_auth: str, param_name: str) -> Optional[str]:
    import re

    pattern = rf'{param_name}\s*=\s*(?:"([^"]+)"|([^,\s]+))'
    match = re.search(pattern, www_auth, re.IGNORECASE)
    if match:
        return match.group(1) or match.group(2)
    return None


def detect_oauth_provider(url: str = "") -> str:
    """Fallback tecnico per discovery senza catalogo; non usare per etichette UI."""
    return "generic"


def get_url_origin(url: str) -> str:
    from urllib.parse import urlparse

    parsed = urlparse(url)
    return f"{parsed.scheme}://{parsed.netloc}"


def authorization_server_metadata_urls(issuer: str) -> List[str]:
    """URL RFC 8414 / OIDC da provare per un authorization server (issuer può avere path).

    Ordine come da spec MCP (authorization server metadata discovery): per issuer con
    path prima la forma RFC 8414 con il well-known inserito tra host e path, poi OIDC
    con path inserito, poi OIDC appeso al path. Un MCP server può pubblicare in
    ``/.well-known/oauth-authorization-server/<path>`` un proxy (es. davanti a
    Keycloak) con registration_endpoint diverso da quello nativo dell'issuer.
    """
    from urllib.parse import urlparse, urlunparse

    issuer = (issuer or "").strip().rstrip("/")
    if not issuer:
        return []
    parsed = urlparse(issuer)
    path = (parsed.path or "").rstrip("/")
    if not path:
        return [
            f"{issuer}/.well-known/oauth-authorization-server",
            f"{issuer}/.well-known/openid-configuration",
        ]

    def _inserted(well_known: str) -> str:
        return urlunparse(
            (
                parsed.scheme,
                parsed.netloc,
                f"/.well-known/{well_known}{path}",
                "",
                "",
                "",
            )
        )

    return [
        _inserted("oauth-authorization-server"),
        _inserted("openid-configuration"),
        f"{issuer}/.well-known/openid-configuration",
        # Non standard ma diffuso (es. Keycloak): RFC 8414 appeso al path.
        f"{issuer}/.well-known/oauth-authorization-server",
    ]


def fetch_authorization_server_metadata(
    issuer: str, *, timeout: float = 5.0
) -> Dict[str, Any]:
    import requests

    for meta_url in authorization_server_metadata_urls(issuer):
        try:
            res = requests.get(meta_url, timeout=timeout)
            if res.status_code == 200:
                doc = res.json()
                if isinstance(doc, dict) and doc:
                    return doc
        except Exception:
            continue
    return {}


_MCP_INITIALIZE_PROBE = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
        "protocolVersion": "2024-11-05",
        "capabilities": {},
        "clientInfo": {"name": "aion-oauth-probe", "version": "1"},
    },
}


def _resource_metadata_from_www_authenticate(www_auth: str) -> Optional[str]:
    return extract_url_from_www_authenticate(www_auth, "resource_metadata")


def _fetch_protected_resource_metadata(
    remote_url: str, *, timeout: float = 5.0
) -> Dict[str, Any]:
    """RFC 9728: well-known + probe 401 (GET/POST) per estrarre authorization_servers."""
    import requests
    from urllib.parse import urlparse, urlunparse

    parsed_url = urlparse(remote_url)
    urls_to_try: List[str] = []
    if parsed_url.netloc:
        urls_to_try.append(
            urlunparse(
                (
                    parsed_url.scheme,
                    parsed_url.netloc,
                    "/.well-known/oauth-protected-resource",
                    "",
                    "",
                    "",
                )
            )
        )
    urls_to_try.append(f"{remote_url.rstrip('/')}/.well-known/oauth-protected-resource")
    for well_known_url in urls_to_try:
        try:
            res = requests.get(well_known_url, timeout=timeout)
            if res.status_code == 200:
                doc = res.json()
                if isinstance(doc, dict) and doc.get("authorization_servers"):
                    return doc
        except Exception:
            continue

    headers = {
        "Accept": "application/json, text/event-stream",
        "Content-Type": "application/json",
    }
    for method, kwargs in (
        ("GET", {}),
        ("POST", {"json": _MCP_INITIALIZE_PROBE}),
    ):
        try:
            res = requests.request(
                method, remote_url, headers=headers, timeout=timeout, **kwargs
            )
            if res.status_code != 401:
                continue
            rm_url = _resource_metadata_from_www_authenticate(
                res.headers.get("WWW-Authenticate") or ""
            )
            if not rm_url:
                continue
            meta_res = requests.get(rm_url, timeout=timeout)
            if meta_res.status_code == 200:
                doc = meta_res.json()
                if isinstance(doc, dict) and doc.get("authorization_servers"):
                    return doc
        except Exception:
            continue
    return {}


def probe_remote_url_sync(url: str, meta: Dict[str, Any]) -> Dict[str, Any]:
    # --- TTL cache ----------------------------------------------------------
    now = time.monotonic()
    cached = _PROBE_CACHE.get(url)
    if cached is not None:
        ts, result = cached
        if now - ts < _PROBE_CACHE_TTL:
            return result
        else:
            del _PROBE_CACHE[url]
    # -------------------------------------------------------------------------
    import requests

    try:
        response = requests.get(url, timeout=_PROBE_TIMEOUT)

        if response.status_code == 200:
            return {
                "type": "none",
                "url": url,
                "credential_mode": "none",
                "credential_schema": [],
            }
        elif response.status_code == 401:
            www_auth = response.headers.get("WWW-Authenticate") or ""
            connect_url = meta.get("connect") or None

            # 3a. Ha resource_metadata -> segui il link (RFC 9728)
            resource_meta = extract_url_from_www_authenticate(
                www_auth, "resource_metadata"
            )
            if resource_meta:
                try:
                    meta_res = requests.get(resource_meta, timeout=_PROBE_TIMEOUT)
                    if meta_res.status_code == 200:
                        doc = meta_res.json()
                        auth_servers = doc.get("authorization_servers") or []
                        issuer = auth_servers[0] if auth_servers else ""
                        if issuer:
                            as_meta = fetch_authorization_server_metadata(issuer)
                            token_url = as_meta.get("token_endpoint")
                            provider = detect_oauth_provider(issuer)
                            return {
                                "type": "oauth2",
                                "url": url,
                                "hint": www_auth,
                                "connectUrl": connect_url,
                                "credential_mode": "per_user",
                                "oauth_provider": provider,
                                "oauth_server": issuer,
                                "oauth_token_url": token_url
                                or f"{issuer.rstrip('/')}/access_token",
                                "credential_schema": [
                                    {
                                        "key": "OAUTH_TOKEN",
                                        "label": "OAuth Token",
                                        "type": "oauth",
                                        "required": True,
                                    }
                                ],
                            }
                except Exception:
                    pass

            # 3b. Ha authorization_uri diretto
            auth_uri = extract_url_from_www_authenticate(www_auth, "authorization_uri")
            if auth_uri:
                provider = detect_oauth_provider(auth_uri)
                token_url = auth_uri.replace("/auth", "/token").replace(
                    "/authorize", "/token"
                )
                return {
                    "type": "oauth2",
                    "url": url,
                    "hint": www_auth,
                    "connectUrl": connect_url,
                    "credential_mode": "per_user",
                    "oauth_provider": provider,
                    "oauth_server": auth_uri,
                    "oauth_token_url": token_url,
                    "credential_schema": [
                        {
                            "key": "OAUTH_TOKEN",
                            "label": "OAuth Token",
                            "type": "oauth",
                            "required": True,
                        }
                    ],
                }

            # 3c. Prova /.well-known/oauth-authorization-server
            try:
                origin_url = get_url_origin(url)
                wk_url = f"{origin_url}/.well-known/oauth-authorization-server"
                wk_res = requests.get(wk_url, timeout=_PROBE_TIMEOUT)
                if wk_res.status_code == 200:
                    doc = wk_res.json()
                    issuer = doc.get("issuer")
                    token_url = doc.get("token_endpoint")
                    if issuer:
                        provider = detect_oauth_provider(issuer)
                        return {
                            "type": "oauth2",
                            "url": url,
                            "hint": www_auth,
                            "connectUrl": connect_url,
                            "credential_mode": "per_user",
                            "oauth_provider": provider,
                            "oauth_server": issuer,
                            "oauth_token_url": token_url
                            or f"{issuer.rstrip('/')}/token",
                            "credential_schema": [
                                {
                                    "key": "OAUTH_TOKEN",
                                    "label": "OAuth Token",
                                    "type": "oauth",
                                    "required": True,
                                }
                            ],
                        }
            except Exception:
                pass

            # Fallback 401
            if "bearer" in www_auth.lower():
                return {
                    "type": "api-key",
                    "url": url,
                    "hint": www_auth,
                    "connectUrl": connect_url,
                    "credential_mode": "per_user",
                    "credential_schema": [
                        {
                            "key": "API_KEY",
                            "label": "API Key",
                            "type": "password",
                            "required": True,
                        }
                    ],
                }
            elif "basic" in www_auth.lower():
                return {
                    "type": "basic",
                    "url": url,
                    "hint": www_auth,
                    "connectUrl": connect_url,
                    "credential_mode": "per_user",
                    "credential_schema": [
                        {
                            "key": "BASIC_AUTH",
                            "label": "Basic Auth Credentials",
                            "type": "password",
                            "required": True,
                        }
                    ],
                }
            else:
                return {
                    "type": "unknown",
                    "url": url,
                    "hint": www_auth,
                    "connectUrl": connect_url,
                    "credential_mode": "per_user",
                    "credential_schema": [
                        {
                            "key": "API_KEY",
                            "label": "API Key / Token",
                            "type": "password",
                            "required": True,
                        }
                    ],
                }
        elif response.status_code == 403:
            return {
                "type": "unknown",
                "url": url,
                "credential_mode": "per_user",
                "credential_schema": [
                    {
                        "key": "API_KEY",
                        "label": "Token / API Key",
                        "type": "password",
                        "required": True,
                    }
                ],
            }
        else:
            return {
                "type": "unreachable",
                "url": url,
                "error": f"HTTP {response.status_code}",
            }
    except Exception as e:
        return {"type": "unreachable", "url": url, "error": str(e)}


def _extract_remote_bridge_token_key(cfg: dict) -> Optional[str]:
    """Estrae il nome della env var dal --header Bearer ${VAR} negli args di mcp-remote."""
    args = cfg.get("args") or []
    import re

    for i, arg in enumerate(args):
        if arg == "--header" and i + 1 < len(args):
            header_val = args[i + 1]
            m = re.search(r"\$\{([A-Z0-9_]+)\}", header_val)
            if m:
                return m.group(1)
    return None


def resolve_remote_bridge_auth_env_var(cfg: dict) -> Optional[str]:
    """Preferisce auth_env_var esplicito nel registry; fallback su parsing args CLI."""
    explicit = (cfg.get("auth_env_var") or "").strip()
    if explicit:
        # Voci org_shared installate prima della correzione: auth_env_var per-utente ma
        # header con il token dell'organizzazione (${API_KEY}). Vale l'header.
        if explicit.startswith("AION_USER_"):
            header_key = _extract_remote_bridge_token_key(cfg)
            if header_key and not header_key.startswith("AION_USER_"):
                return header_key
        return explicit
    token_key = _extract_remote_bridge_token_key(cfg)
    if token_key:
        logger.warning(
            "remote-bridge: auth_env_var dedotto dal parsing CLI args; "
            "configurare auth_env_var esplicito nel registry"
        )
    return token_key


def clear_discovery_cache() -> None:
    """Svuota la cache in-memory del discovery delle credenziali."""
    _DISCOVERY_CACHE.clear()


def discover_mcp_credentials(
    server_slug: str,
    server_config: Optional[Dict[str, Any]] = None,
) -> CredentialDiscoveryResult:
    """
    Analizza file installati e registry per proporre schema credenziali e modalità.
    """
    # Fast path: reuse discovery result for the same slug + config within this request.
    cache_key = f"{server_slug}::{json.dumps(server_config, sort_keys=True, default=str) if server_config else ''}"
    cached = _DISCOVERY_CACHE.get(cache_key)
    if cached is not None:
        return cached

    cfg = server_config or {}

    # Rilevamento server remoti (SSE o remote-bridge)
    is_remote = cfg.get("aion_market_install") == "remote" or cfg.get("type") in (
        "sse",
        "remote-bridge",
    )
    if is_remote:
        remotes = cfg.get("remotes") or []
        url = cfg.get("remote_url") or cfg.get("url")
        remote = None
        if remotes:
            for r in remotes:
                if isinstance(r, dict) and r.get("type") in (
                    "sse",
                    "streamable-http",
                    "streamable_http",
                ):
                    remote = r
                    break
            if not remote and remotes:
                remote = remotes[0]
        if not remote and url:
            remote = {"url": url, "type": "sse", "headers": []}

        if not remote:
            _res = CredentialDiscoveryResult(
                env_keys=[],
                schema=[],
                credential_mode_hint="none",
                sources=["remote_discovery"],
                remote_auth_type="no-remote",
            )
            _DISCOVERY_CACHE[cache_key] = _res
            return _res

        headers = remote.get("headers") or []
        meta = cfg.get("_meta", {}).get(
            "io.modelcontextprotocol.registry/publisher-provided", {}
        )

        classified = None
        if headers:
            classified = classify_from_headers(headers, remote, meta)

        probe_url = cfg.get("remote_url") or remote.get("url") or url
        if probe_url:
            probe_res = probe_remote_url_sync(probe_url, meta)
            # Store in TTL cache so repeated calls with the same URL
            # during this request skip the HTTP round-trip.
            _PROBE_CACHE[probe_url] = (time.monotonic(), probe_res)
        else:
            probe_res = {"type": "unreachable", "error": "Missing remote URL"}

        if classified:
            if probe_res.get("type") == "unreachable":
                final_res = probe_res
            else:
                final_res = classified
                if "hint" not in final_res and "hint" in probe_res:
                    final_res["hint"] = probe_res["hint"]
        else:
            final_res = probe_res

        auth_type = final_res.get("type", "unknown")
        mode_hint = final_res.get("credential_mode", "per_user")
        schema = final_res.get("credential_schema") or []

        if cfg.get("type") == "remote-bridge":
            token_key = resolve_remote_bridge_auth_env_var(cfg)
            if token_key:
                db_key = token_key
                if "__" in token_key:
                    db_key = token_key.split("__", 1)[1]
                elif token_key.startswith("AION_USER_"):
                    db_key = token_key[len("AION_USER_") :]

                if schema:
                    schema = [dict(s) for s in schema]
                    for s in schema:
                        s["key"] = db_key
                else:
                    schema = [
                        {
                            "key": db_key,
                            "label": "Token / API Key",
                            "type": "password",
                            "required": True,
                        }
                    ]
                    mode_hint = "per_user"
                    if auth_type == "unknown" or auth_type == "unreachable":
                        auth_type = "api-key"

        env_keys = [s.get("key") for s in schema]

        _res = CredentialDiscoveryResult(
            env_keys=env_keys,
            schema=schema,
            credential_mode_hint=mode_hint,
            sources=["remote_probe" + ("+headers" if headers else "")],
            remote_auth_type=auth_type,
            remote_connect_url=final_res.get("connectUrl"),
            remote_docs_url=final_res.get("docsUrl") or meta.get("docs"),
            remote_hint=final_res.get("hint"),
            remote_error=final_res.get("error"),
            remote_oauth_provider=final_res.get("oauth_provider"),
            remote_oauth_server=final_res.get("oauth_server"),
            remote_oauth_token_url=final_res.get("oauth_token_url"),
            has_env_auth=(mode_hint != "none" and auth_type != "unreachable"),
        )
        _DISCOVERY_CACHE[cache_key] = _res
        return _res

    env = cfg.get("env") if isinstance(cfg.get("env"), dict) else {}
    keys: Set[str] = set()
    sources: List[str] = []
    defaults: Dict[str, Any] = {}
    static_org_keys: Set[str] = set()

    for k, v in env.items():
        if isinstance(k, str) and k.strip():
            k_clean = k.strip()
            if (
                isinstance(v, str)
                and v.strip()
                and not (
                    v.strip().startswith("${AION_USER_")
                    or _AION_USER_KEY_RE.match(v.strip())
                )
            ):
                static_org_keys.add(k_clean)

    registry_keys = _keys_from_registry_env(env)
    if registry_keys:
        keys |= registry_keys
        sources.append("registry")

    mcp_dir = resolve_mcp_server_dir(server_slug)
    if mcp_dir:
        for env_name in (".env.example", ".env.sample", ".env.template"):
            ef = mcp_dir / env_name
            if ef.is_file():
                content = ef.read_text(encoding="utf-8", errors="replace")
                keys |= _keys_from_text(content)
                for line in content.splitlines():
                    line = line.strip()
                    if line and not line.startswith("#") and "=" in line:
                        ek, _, ev = line.partition("=")
                        ek = ek.strip()
                        ev = ev.strip().strip("'\"")
                        if ek and ev:
                            defaults[ek] = ev
                sources.append(env_name)
                break

        for src in ("index.ts", "index.js", "server.ts", "server.py", "main.ts"):
            sf = mcp_dir / src
            if sf.is_file():
                keys |= _keys_from_text(
                    sf.read_text(encoding="utf-8", errors="replace")
                )
                sources.append(src)
                break

    readme_text = ""
    if mcp_dir and (mcp_dir / "README.md").is_file():
        readme_text = (mcp_dir / "README.md").read_text(
            encoding="utf-8", errors="replace"
        )
        keys |= _keys_from_text(readme_text)
        sources.append("README.md")

    # Source/README scans may also mention the wildcard carrier: drop it.
    keys -= _wildcard_env_keys(env)

    # Solo chiavi che sembrano credenziali o config server (host/port)
    cred_keys = sorted(
        k
        for k in keys
        if not k.startswith("AION_USER_")
        and (
            _is_credential_key(k)
            or k.endswith(("_HOST", "_PORT", "_URL", "_URI", "_SSL"))
        )
    )

    config_file_auth = bool(readme_text and _CONFIG_FILE_HINTS.search(readme_text))
    has_env_auth = len(cred_keys) > 0

    mode_hint = "none"
    if has_env_auth:
        mode_hint = "per_user"
    elif config_file_auth and not has_env_auth:
        mode_hint = "none"

    _res = CredentialDiscoveryResult(
        env_keys=cred_keys,
        schema=_schema_from_keys(
            cred_keys, defaults=defaults, static_org_keys=static_org_keys
        ),
        credential_mode_hint=mode_hint,
        sources=sources,
        config_file_auth=config_file_auth,
        has_env_auth=has_env_auth,
    )
    _DISCOVERY_CACHE[cache_key] = _res
    return _res


def merge_schema_sources(
    *,
    catalog_schema: List[Dict[str, Any]],
    discovered_schema: List[Dict[str, Any]],
) -> List[Dict[str, Any]]:
    """Catalogo opzionale (config/) + discovery; discovery riempie i buchi unendo i campi semantici."""
    if catalog_schema and not discovered_schema:
        return catalog_schema
    if discovered_schema and not catalog_schema:
        return discovered_schema
    if not catalog_schema and not discovered_schema:
        return []
    by_key: Dict[str, Dict[str, Any]] = {}
    for row in discovered_schema:
        k = str(row.get("key") or "").strip()
        if k:
            by_key[k] = dict(row)
    for row in catalog_schema:
        k = str(row.get("key") or "").strip()
        if k:
            if k in by_key:
                # Merge: catalog overrides specific fields, but keeps inferred type/category if missing
                merged = dict(by_key[k])
                for field_k, field_v in row.items():
                    if field_v is not None:
                        merged[field_k] = field_v
                by_key[k] = merged
            else:
                by_key[k] = dict(row)
    return [by_key[k] for k in sorted(by_key.keys())]
