from typing import Any, Dict, List

import httpx
from fastapi import HTTPException


def get_provider_defaults(provider: str) -> tuple[str, str]:
    normalized = str(provider or "").lower().strip()
    if normalized in {"openai"}:
        return "openai", "https://api.openai.com/v1"
    if normalized in {"openrouter"}:
        return "openrouter", "https://openrouter.ai/api/v1"
    if normalized in {"dashscope", "aliyun", "qwen", "aliyun-qwen"}:
        return "dashscope", "https://dashscope.aliyuncs.com/compatible-mode/v1"
    if normalized in {"deepseek"}:
        return "deepseek", "https://api.deepseek.com/v1"
    if normalized in {"xunfei", "iflytek", "xfyun"}:
        return "openai", "https://spark-api-open.xf-yun.com/v1"
    if normalized in {"vllm"}:
        return "openai", ""
    if normalized in {"kimi", "moonshot"}:
        return "kimi", "https://api.moonshot.cn/v1"
    if normalized in {"minimax"}:
        return "minimax", "https://api.minimax.chat/v1"
    return normalized, ""


async def test_provider_connection(payload: Dict[str, Any]) -> Dict[str, Any]:
    provider = str(payload.get("provider") or "").strip()
    api_key = str(payload.get("api_key") or "").strip()
    model = str(payload.get("model") or "").strip()
    api_base = str(payload.get("api_base") or "").strip()

    if not provider or not api_key:
        raise HTTPException(status_code=400, detail="provider and api_key are required")

    normalized_provider, _ = get_provider_defaults(provider)
    base = api_base.rstrip("/")
    if normalized_provider not in {"openrouter", "dashscope", "kimi", "minimax", "openai", "deepseek"}:
        raise HTTPException(status_code=400, detail=f"provider not supported for test: {provider}")
    if not base:
        raise HTTPException(status_code=400, detail=f"api_base is required for provider: {provider}")

    headers = {"Authorization": f"Bearer {api_key}"}
    timeout = httpx.Timeout(20.0, connect=10.0)
    url = f"{base}/models"
    try:
        async with httpx.AsyncClient(timeout=timeout) as client:
            response = await client.get(url, headers=headers)
        if response.status_code >= 400:
            return {
                "ok": False,
                "provider": normalized_provider,
                "status_code": response.status_code,
                "detail": response.text[:500],
            }
        data = response.json()
        models_raw = data.get("data", []) if isinstance(data, dict) else []
        model_ids: List[str] = [
            str(item["id"]) for item in models_raw[:20] if isinstance(item, dict) and item.get("id")
        ]
        return {
            "ok": True,
            "provider": normalized_provider,
            "endpoint": url,
            "models_preview": model_ids[:8],
            "model_hint": (
                "model_found"
                if model and any(model in item for item in model_ids)
                else ("model_not_listed" if model else "")
            ),
        }
    except Exception as exc:
        return {
            "ok": False,
            "provider": normalized_provider,
            "endpoint": url,
            "detail": str(exc),
        }