main.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"net/http"
	"os"
	"runtime/debug"
	"strings"
	"time"
)

var version = func() string {
	if info, ok := debug.ReadBuildInfo(); ok && info.Main.Version != "" && info.Main.Version != "(devel)" {
		return strings.TrimPrefix(info.Main.Version, "v")
	}
	return "dev"
}()

// ANSI colors
const (
	colorReset  = "\033[0m"
	colorRed    = "\033[31m"
	colorGreen  = "\033[32m"
	colorYellow = "\033[33m"
	colorBlue   = "\033[34m"
	colorCyan   = "\033[36m"
	colorBold   = "\033[1m"
	colorDim    = "\033[2m"
)

func green(s string) string  { return colorGreen + s + colorReset }
func red(s string) string    { return colorRed + s + colorReset }
func yellow(s string) string { return colorYellow + s + colorReset }
func cyan(s string) string   { return colorCyan + s + colorReset }
func bold(s string) string   { return colorBold + s + colorReset }
func dim(s string) string    { return colorDim + s + colorReset }

// ─── Provider detection ───────────────────────────────────────────────────────

type Provider string

const (
	ProviderAnthropic   Provider = "anthropic"
	ProviderOpenAI      Provider = "openai"
	ProviderGemini      Provider = "gemini"
	ProviderCohere      Provider = "cohere"
	ProviderMistral     Provider = "mistral"
	ProviderGroq        Provider = "groq"
	ProviderTogether    Provider = "together"
	ProviderPerplexity  Provider = "perplexity"
	ProviderDeepSeek    Provider = "deepseek"
	ProviderXAI         Provider = "xai"
	ProviderHuggingFace Provider = "huggingface"
	ProviderReplicate   Provider = "replicate"
	ProviderUnknown     Provider = "unknown"
)

func detectProvider(key string) Provider {
	switch {
	case strings.HasPrefix(key, "sk-ant-"):
		return ProviderAnthropic
	case strings.HasPrefix(key, "sk-") && len(key) == 51:
		return ProviderOpenAI
	case strings.HasPrefix(key, "sk-proj-"):
		return ProviderOpenAI
	case strings.HasPrefix(key, "sk-or-"):
		return ProviderOpenAI // OpenRouter uses same prefix pattern
	case strings.HasPrefix(key, "AIzaSy"):
		return ProviderGemini
	case strings.HasPrefix(key, "sk-cohere-") || (len(key) == 40 && !strings.Contains(key, "-")):
		return ProviderCohere
	case strings.HasPrefix(key, "gsk_"):
		return ProviderGroq
	case strings.HasPrefix(key, "r8_"):
		return ProviderReplicate
	case strings.HasPrefix(key, "hf_"):
		return ProviderHuggingFace
	case strings.HasPrefix(key, "xai-"):
		return ProviderXAI
	case strings.HasPrefix(key, "pplx-"):
		return ProviderPerplexity
	case strings.HasPrefix(key, "together-") || strings.HasPrefix(key, "tgr_"):
		return ProviderTogether
	case strings.HasPrefix(key, "sk-") && len(key) > 51:
		// OpenAI newer keys are longer
		return ProviderOpenAI
	default:
		// Try length/entropy heuristics for Mistral, Cohere, DeepSeek
		if len(key) == 32 {
			return ProviderMistral
		}
		if len(key) == 64 {
			return ProviderDeepSeek
		}
		return ProviderUnknown
	}
}

// ─── Result types ─────────────────────────────────────────────────────────────

type Capability struct {
	Name        string
	Available   bool
	Description string
}

type ValidationResult struct {
	Provider     Provider
	Valid        bool
	Error        string
	Model        string
	OrgID        string
	Capabilities []Capability
	RawDetails   map[string]string
}

type jsonCapability struct {
	Name        string `json:"name"`
	Available   bool   `json:"available"`
	Description string `json:"description"`
}

type jsonResult struct {
	Provider     string            `json:"provider"`
	Valid        bool              `json:"valid"`
	Error        string            `json:"error,omitempty"`
	Model        string            `json:"model,omitempty"`
	Capabilities []jsonCapability  `json:"capabilities,omitempty"`
	Details      map[string]string `json:"details,omitempty"`
}

// ─── HTTP helpers ─────────────────────────────────────────────────────────────

var httpClient = &http.Client{Timeout: 15 * time.Second}

func doRequest(method, url string, headers map[string]string, body []byte) (int, []byte, error) {
	var req *http.Request
	var err error
	if body != nil {
		req, err = http.NewRequest(method, url, bytes.NewReader(body))
	} else {
		req, err = http.NewRequest(method, url, nil)
	}
	if err != nil {
		return 0, nil, err
	}
	for k, v := range headers {
		req.Header.Set(k, v)
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return 0, nil, err
	}
	defer resp.Body.Close()
	b, err := io.ReadAll(resp.Body)
	return resp.StatusCode, b, err
}

// ─── Validators ───────────────────────────────────────────────────────────────

func validateAnthropic(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderAnthropic}

	// 1. Test basic API access with a minimal message
	payload := map[string]interface{}{
		"model":      "claude-haiku-4-5-20251001",
		"max_tokens": 1,
		"messages":   []map[string]string{{"role": "user", "content": "hi"}},
	}
	body, _ := json.Marshal(payload)
	status, respBody, err := doRequest("POST", "https://api.anthropic.com/v1/messages", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
		"content-type":      "application/json",
	}, body)

	if err != nil {
		result.Error = err.Error()
		return result
	}

	if status == 401 || status == 403 {
		result.Valid = false
		var e map[string]interface{}
		if json.Unmarshal(respBody, &e) == nil {
			if errObj, ok := e["error"].(map[string]interface{}); ok {
				result.Error = fmt.Sprintf("%v", errObj["message"])
			}
		}
		return result
	}

	result.Valid = true
	result.Model = "claude-haiku-4-5-20251001 (used for validation)"

	// 2. Probe capabilities

	// Chat / Messages API
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Messages API (chat)",
		Available:   true,
		Description: "Send and receive chat messages",
	})

	// Streaming
	streamPayload := map[string]interface{}{
		"model":      "claude-haiku-4-5-20251001",
		"max_tokens": 1,
		"stream":     true,
		"messages":   []map[string]string{{"role": "user", "content": "hi"}},
	}
	streamBody, _ := json.Marshal(streamPayload)
	sStatus, _, _ := doRequest("POST", "https://api.anthropic.com/v1/messages", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
		"content-type":      "application/json",
	}, streamBody)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Streaming",
		Available:   sStatus == 200,
		Description: "Stream tokens in real-time",
	})

	// Files / Documents beta (claude-3.5 models)
	docPayload := map[string]interface{}{
		"model":      "claude-sonnet-4-20250514",
		"max_tokens": 1,
		"messages":   []map[string]string{{"role": "user", "content": "hi"}},
	}
	docBody, _ := json.Marshal(docPayload)
	dStatus, _, _ := doRequest("POST", "https://api.anthropic.com/v1/messages", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
		"content-type":      "application/json",
	}, docBody)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Claude Sonnet 4 access",
		Available:   dStatus == 200,
		Description: "Access to claude-sonnet-4-20250514",
	})

	// Opus
	opusPayload := map[string]interface{}{
		"model":      "claude-opus-4-20250514",
		"max_tokens": 1,
		"messages":   []map[string]string{{"role": "user", "content": "hi"}},
	}
	opusBody, _ := json.Marshal(opusPayload)
	oStatus, _, _ := doRequest("POST", "https://api.anthropic.com/v1/messages", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
		"content-type":      "application/json",
	}, opusBody)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Claude Opus 4 access",
		Available:   oStatus == 200,
		Description: "Access to claude-opus-4-20250514",
	})

	// Claude Code — uses the same API key but requires claude-sonnet-4 or opus-4
	// Claude Code is a CLI tool authenticated via the same API key; if you can
	// hit the models it uses, Claude Code will work with this key.
	claudeCodeAvailable := dStatus == 200 || oStatus == 200
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Claude Code (CLI)",
		Available:   claudeCodeAvailable,
		Description: "Run `claude` CLI — requires Sonnet 4 or Opus 4 access",
	})

	// Batch API
	bStatus, _, _ := doRequest("GET", "https://api.anthropic.com/v1/messages/batches", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
	}, nil)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Batch API",
		Available:   bStatus == 200,
		Description: "Asynchronous large-scale message processing",
	})

	// Files API (beta)
	fStatus, _, _ := doRequest("GET", "https://api.anthropic.com/v1/files", map[string]string{
		"x-api-key":         key,
		"anthropic-version": "2023-06-01",
		"anthropic-beta":    "files-api-2025-04-14",
	}, nil)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Files API (beta)",
		Available:   fStatus == 200,
		Description: "Upload and manage files for use in messages",
	})

	return result
}

func validateOpenAI(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderOpenAI}

	status, respBody, err := doRequest("GET", "https://api.openai.com/v1/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status == 401 {
		result.Valid = false
		var e map[string]interface{}
		if json.Unmarshal(respBody, &e) == nil {
			if errObj, ok := e["error"].(map[string]interface{}); ok {
				result.Error = fmt.Sprintf("%v", errObj["message"])
			}
		}
		return result
	}

	result.Valid = true

	var modelsResp struct {
		Data []struct {
			ID string `json:"id"`
		} `json:"data"`
	}
	json.Unmarshal(respBody, &modelsResp)

	modelSet := map[string]bool{}
	for _, m := range modelsResp.Data {
		modelSet[m.ID] = true
	}

	check := func(name, model, desc string) {
		result.Capabilities = append(result.Capabilities, Capability{
			Name:        name,
			Available:   modelSet[model],
			Description: desc,
		})
	}

	check("GPT-4o", "gpt-4o", "Latest multimodal GPT-4 model")
	check("GPT-4o mini", "gpt-4o-mini", "Lightweight GPT-4o variant")
	check("o1", "o1", "Reasoning model (o1)")
	check("o3", "o3", "Advanced reasoning model (o3)")
	check("GPT-4.1", "gpt-4.1", "GPT-4.1 model access")

	// Embeddings
	ePayload := map[string]interface{}{
		"model": "text-embedding-3-small",
		"input": "test",
	}
	eBody, _ := json.Marshal(ePayload)
	eStatus, _, _ := doRequest("POST", "https://api.openai.com/v1/embeddings", map[string]string{
		"Authorization": "Bearer " + key,
		"Content-Type":  "application/json",
	}, eBody)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Embeddings",
		Available:   eStatus == 200,
		Description: "text-embedding-3-small/large",
	})

	// DALL-E
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "DALL-E 3 (image gen)",
		Available:   modelSet["dall-e-3"],
		Description: "Image generation via DALL-E 3",
	})

	// Whisper
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Whisper (speech-to-text)",
		Available:   modelSet["whisper-1"],
		Description: "Audio transcription",
	})

	// TTS
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "TTS (text-to-speech)",
		Available:   modelSet["tts-1"],
		Description: "Text-to-speech synthesis",
	})

	// Assistants API
	aStatus, _, _ := doRequest("GET", "https://api.openai.com/v1/assistants", map[string]string{
		"Authorization": "Bearer " + key,
		"OpenAI-Beta":   "assistants=v2",
	}, nil)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Assistants API",
		Available:   aStatus == 200,
		Description: "Stateful assistant threads with tools",
	})

	// Fine-tuning
	ftStatus, _, _ := doRequest("GET", "https://api.openai.com/v1/fine_tuning/jobs", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	result.Capabilities = append(result.Capabilities, Capability{
		Name:        "Fine-tuning",
		Available:   ftStatus == 200,
		Description: "Custom model training",
	})

	// Org info
	uStatus, uBody, _ := doRequest("GET", "https://api.openai.com/v1/organization/users", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if uStatus == 200 {
		var orgResp map[string]interface{}
		if json.Unmarshal(uBody, &orgResp) == nil {
			result.RawDetails = map[string]string{"org_info": "accessible"}
		}
	}

	return result
}

func validateGemini(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderGemini}

	url := "https://generativelanguage.googleapis.com/v1beta/models?key=" + key
	status, respBody, err := doRequest("GET", url, nil, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status != 200 {
		result.Valid = false
		var e map[string]interface{}
		if json.Unmarshal(respBody, &e) == nil {
			if errObj, ok := e["error"].(map[string]interface{}); ok {
				result.Error = fmt.Sprintf("%v", errObj["message"])
			}
		}
		return result
	}

	result.Valid = true

	var modelsResp struct {
		Models []struct {
			Name string `json:"name"`
		} `json:"models"`
	}
	json.Unmarshal(respBody, &modelsResp)

	modelSet := map[string]bool{}
	for _, m := range modelsResp.Models {
		modelSet[m.Name] = true
	}

	hasModel := func(substr string) bool {
		for k := range modelSet {
			if strings.Contains(k, substr) {
				return true
			}
		}
		return false
	}

	caps := []struct{ name, key, desc string }{
		{"Gemini 2.5 Pro", "gemini-2.5-pro", "Latest flagship Gemini model"},
		{"Gemini 2.0 Flash", "gemini-2.0-flash", "Fast multimodal model"},
		{"Gemini 1.5 Pro", "gemini-1.5-pro", "Long context (2M tokens)"},
		{"Gemini 1.5 Flash", "gemini-1.5-flash", "Lightweight 1.5 variant"},
		{"Text Embeddings", "text-embedding", "Embedding generation"},
		{"Image generation (Imagen)", "imagen", "Image generation via Imagen"},
	}
	for _, c := range caps {
		result.Capabilities = append(result.Capabilities, Capability{
			Name:        c.name,
			Available:   hasModel(c.key),
			Description: c.desc,
		})
	}

	return result
}

func validateMistral(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderMistral}

	status, respBody, err := doRequest("GET", "https://api.mistral.ai/v1/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status != 200 {
		result.Valid = false
		var e map[string]interface{}
		json.Unmarshal(respBody, &e)
		if msg, ok := e["message"].(string); ok {
			result.Error = msg
		}
		return result
	}

	result.Valid = true

	var modelsResp struct {
		Data []struct {
			ID string `json:"id"`
		} `json:"data"`
	}
	json.Unmarshal(respBody, &modelsResp)
	modelSet := map[string]bool{}
	for _, m := range modelsResp.Data {
		modelSet[m.ID] = true
	}

	caps := []struct{ name, model, desc string }{
		{"Mistral Large", "mistral-large-latest", "Flagship model"},
		{"Mistral Small", "mistral-small-latest", "Efficient model"},
		{"Codestral", "codestral-latest", "Code generation specialist"},
		{"Pixtral Large", "pixtral-large-latest", "Vision + text model"},
		{"Mistral Embed", "mistral-embed", "Text embeddings"},
	}
	for _, c := range caps {
		result.Capabilities = append(result.Capabilities, Capability{
			Name:        c.name,
			Available:   modelSet[c.model],
			Description: c.desc,
		})
	}
	return result
}

func validateGroq(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderGroq}

	status, respBody, err := doRequest("GET", "https://api.groq.com/openai/v1/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status != 200 {
		result.Valid = false
		return result
	}
	result.Valid = true

	var modelsResp struct {
		Data []struct {
			ID string `json:"id"`
		} `json:"data"`
	}
	json.Unmarshal(respBody, &modelsResp)
	modelSet := map[string]bool{}
	for _, m := range modelsResp.Data {
		modelSet[m.ID] = true
	}

	caps := []struct{ name, model, desc string }{
		{"Llama 3.3 70B", "llama-3.3-70b-versatile", "Meta's Llama 3.3 70B"},
		{"Llama 3.1 8B", "llama-3.1-8b-instant", "Fast 8B model"},
		{"DeepSeek R1 Distill (Llama 70B)", "deepseek-r1-distill-llama-70b", "Reasoning distill"},
		{"Mixtral 8x7B", "mixtral-8x7b-32768", "Mixtral MoE"},
		{"Gemma 2 9B", "gemma2-9b-it", "Google Gemma 2"},
		{"Whisper large-v3", "whisper-large-v3", "Speech-to-text"},
	}
	for _, c := range caps {
		result.Capabilities = append(result.Capabilities, Capability{
			Name:        c.name,
			Available:   modelSet[c.model],
			Description: c.desc,
		})
	}
	return result
}

func validateCohere(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderCohere}

	payload := map[string]interface{}{
		"model":      "command-r",
		"max_tokens": 1,
		"message":    "hi",
	}
	body, _ := json.Marshal(payload)
	status, respBody, err := doRequest("POST", "https://api.cohere.com/v1/chat", map[string]string{
		"Authorization": "Bearer " + key,
		"Content-Type":  "application/json",
	}, body)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status == 401 || status == 403 {
		result.Valid = false
		var e map[string]interface{}
		json.Unmarshal(respBody, &e)
		if msg, ok := e["message"].(string); ok {
			result.Error = msg
		}
		return result
	}
	result.Valid = true

	result.Capabilities = []Capability{
		{Name: "Command R+", Available: true, Description: "Flagship RAG-optimized model"},
		{Name: "Command R", Available: true, Description: "Efficient instruction-following"},
		{Name: "Embed v3", Available: true, Description: "Multilingual embeddings"},
		{Name: "Rerank v3", Available: true, Description: "Document reranking"},
	}
	return result
}

func validateTogether(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderTogether}

	status, _, err := doRequest("GET", "https://api.together.xyz/v1/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	result.Valid = status == 200
	if !result.Valid {
		result.Error = fmt.Sprintf("HTTP %d", status)
		return result
	}

	result.Capabilities = []Capability{
		{Name: "Llama 3.1 405B", Available: true, Description: "Meta's largest open model"},
		{Name: "Mixtral 8x22B", Available: true, Description: "Large MoE model"},
		{Name: "FLUX image gen", Available: true, Description: "Image generation"},
		{Name: "Embeddings", Available: true, Description: "Open embedding models"},
		{Name: "Fine-tuning", Available: true, Description: "Custom model training"},
	}
	return result
}

func validatePerplexity(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderPerplexity}

	payload := map[string]interface{}{
		"model":      "sonar",
		"max_tokens": 1,
		"messages":   []map[string]string{{"role": "user", "content": "hi"}},
	}
	body, _ := json.Marshal(payload)
	status, _, err := doRequest("POST", "https://api.perplexity.ai/chat/completions", map[string]string{
		"Authorization": "Bearer " + key,
		"Content-Type":  "application/json",
	}, body)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	result.Valid = status == 200 || status == 400 // 400 = auth ok but bad request params
	if status == 401 {
		result.Valid = false
		result.Error = "Invalid API key"
		return result
	}
	result.Valid = true
	result.Capabilities = []Capability{
		{Name: "Sonar (web search)", Available: true, Description: "Real-time web search + LLM"},
		{Name: "Sonar Pro", Available: true, Description: "Advanced search reasoning"},
		{Name: "Sonar Deep Research", Available: true, Description: "Multi-step research"},
	}
	return result
}

func validateDeepSeek(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderDeepSeek}

	status, respBody, err := doRequest("GET", "https://api.deepseek.com/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status == 401 {
		result.Valid = false
		var e map[string]interface{}
		json.Unmarshal(respBody, &e)
		if errObj, ok := e["error"].(map[string]interface{}); ok {
			result.Error = fmt.Sprintf("%v", errObj["message"])
		}
		return result
	}
	result.Valid = true
	result.Capabilities = []Capability{
		{Name: "DeepSeek Chat (V3)", Available: true, Description: "Flagship chat model"},
		{Name: "DeepSeek Reasoner (R1)", Available: true, Description: "Chain-of-thought reasoning"},
	}
	return result
}

func validateXAI(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderXAI}

	status, _, err := doRequest("GET", "https://api.x.ai/v1/models", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	result.Valid = status == 200
	if !result.Valid {
		result.Error = fmt.Sprintf("HTTP %d", status)
		return result
	}
	result.Capabilities = []Capability{
		{Name: "Grok 3", Available: true, Description: "xAI flagship model with real-time X data"},
		{Name: "Grok 3 mini", Available: true, Description: "Efficient reasoning variant"},
		{Name: "Grok Vision", Available: true, Description: "Multimodal image understanding"},
	}
	return result
}

func validateHuggingFace(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderHuggingFace}

	status, respBody, err := doRequest("GET", "https://huggingface.co/api/whoami", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	if status != 200 {
		result.Valid = false
		result.Error = fmt.Sprintf("HTTP %d", status)
		return result
	}
	result.Valid = true

	var who map[string]interface{}
	json.Unmarshal(respBody, &who)
	if name, ok := who["name"].(string); ok {
		result.RawDetails = map[string]string{"username": name}
	}

	result.Capabilities = []Capability{
		{Name: "Inference API", Available: true, Description: "Hosted model inference"},
		{Name: "Model Hub access", Available: true, Description: "Download gated models"},
		{Name: "Spaces", Available: true, Description: "Deploy Gradio/Streamlit apps"},
		{Name: "Datasets Hub", Available: true, Description: "Access private datasets"},
	}
	return result
}

func validateReplicate(key string) ValidationResult {
	result := ValidationResult{Provider: ProviderReplicate}

	status, _, err := doRequest("GET", "https://api.replicate.com/v1/account", map[string]string{
		"Authorization": "Bearer " + key,
	}, nil)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	result.Valid = status == 200
	if !result.Valid {
		result.Error = fmt.Sprintf("HTTP %d", status)
		return result
	}
	result.Capabilities = []Capability{
		{Name: "Open source models", Available: true, Description: "Run any model on Replicate"},
		{Name: "Custom deployments", Available: true, Description: "Deploy your own models"},
		{Name: "Image gen (FLUX, SDXL)", Available: true, Description: "State-of-art image models"},
		{Name: "Video generation", Available: true, Description: "Video gen models"},
	}
	return result
}

func validateUnknown(key string) ValidationResult {
	return ValidationResult{
		Provider: ProviderUnknown,
		Valid:    false,
		Error:    "Could not detect provider from key format. Use --provider flag to specify.",
	}
}

// ─── Dispatch ─────────────────────────────────────────────────────────────────

func validate(key string, provider Provider) ValidationResult {
	switch provider {
	case ProviderAnthropic:
		return validateAnthropic(key)
	case ProviderOpenAI:
		return validateOpenAI(key)
	case ProviderGemini:
		return validateGemini(key)
	case ProviderMistral:
		return validateMistral(key)
	case ProviderGroq:
		return validateGroq(key)
	case ProviderCohere:
		return validateCohere(key)
	case ProviderTogether:
		return validateTogether(key)
	case ProviderPerplexity:
		return validatePerplexity(key)
	case ProviderDeepSeek:
		return validateDeepSeek(key)
	case ProviderXAI:
		return validateXAI(key)
	case ProviderHuggingFace:
		return validateHuggingFace(key)
	case ProviderReplicate:
		return validateReplicate(key)
	default:
		return validateUnknown(key)
	}
}

// ─── Display ─────────────────────────────────────────────────────────────────

var providerLabels = map[Provider]string{
	ProviderAnthropic:   "Anthropic",
	ProviderOpenAI:      "OpenAI",
	ProviderGemini:      "Google Gemini",
	ProviderCohere:      "Cohere",
	ProviderMistral:     "Mistral AI",
	ProviderGroq:        "Groq",
	ProviderTogether:    "Together AI",
	ProviderPerplexity:  "Perplexity AI",
	ProviderDeepSeek:    "DeepSeek",
	ProviderXAI:         "xAI (Grok)",
	ProviderHuggingFace: "Hugging Face",
	ProviderReplicate:   "Replicate",
	ProviderUnknown:     "Unknown",
}

func printResult(r ValidationResult) {
	label := providerLabels[r.Provider]

	fmt.Printf("%s  %s\n", bold("Provider:"), cyan(label))

	if r.Valid {
		fmt.Printf("%s  %s\n", bold("Status:  "), green("✓ VALID"))
	} else {
		fmt.Printf("%s  %s\n", bold("Status:  "), red("✗ INVALID"))
		if r.Error != "" {
			fmt.Printf("%s  %s\n", bold("Error:   "), dim(r.Error))
		}
		return
	}

	if r.Model != "" {
		fmt.Printf("%s  %s\n", bold("Tested:  "), dim(r.Model))
	}

	if len(r.RawDetails) > 0 {
		for k, v := range r.RawDetails {
			fmt.Printf("%s  %s\n", bold(fmt.Sprintf("%-9s", k+":")), dim(v))
		}
	}

	if len(r.Capabilities) > 0 {
		fmt.Printf("\n%s\n", bold("Capabilities:"))
		for _, c := range r.Capabilities {
			icon := green("✓")
			if !c.Available {
				icon = red("✗")
			}
			fmt.Printf("  %s  %-34s %s\n", icon, c.Name, dim(c.Description))
		}
	}
}

func printResultJSON(r ValidationResult) {
	label := providerLabels[r.Provider]
	out := jsonResult{
		Provider: label,
		Valid:    r.Valid,
		Error:    r.Error,
		Model:    r.Model,
		Details:  r.RawDetails,
	}
	for _, c := range r.Capabilities {
		out.Capabilities = append(out.Capabilities, jsonCapability{
			Name:        c.Name,
			Available:   c.Available,
			Description: c.Description,
		})
	}
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", "  ")
	enc.Encode(out)
}

// ─── Usage ────────────────────────────────────────────────────────────────────

func usage() {
	fmt.Printf(`%s — LLM API key validator %s

%s
  keyprobe <api-key> [flags]

%s
  keyprobe sk-ant-api03-...              # auto-detect (Anthropic)
  keyprobe sk-proj-...                   # auto-detect (OpenAI)
  keyprobe AIzaSy...                     # auto-detect (Gemini)
  keyprobe --anthropic <key>             # force Anthropic
  keyprobe --openai <key>                # force OpenAI
  keyprobe --gemini <key>                # force Gemini
  keyprobe --mistral <key>
  keyprobe --groq <key>
  keyprobe --cohere <key>
  keyprobe --together <key>
  keyprobe --perplexity <key>
  keyprobe --deepseek <key>
  keyprobe --xai <key>
  keyprobe --huggingface <key>
  keyprobe --replicate <key>
  keyprobe --output json <key>           # output as JSON

%s
  Validates the key against the provider's live API and reports
  which capabilities (models, APIs, features) are accessible.
  Detection is automatic when no --provider flag is given.
  Use --output json for machine-readable output.

`,
		bold("keyprobe"),
		dim("v"+version),
		bold("Usage:"),
		bold("Examples:"),
		bold("Notes:"),
	)
}

// ─── Main ─────────────────────────────────────────────────────────────────────

func main() {
	fs := flag.NewFlagSet("keyprobe", flag.ExitOnError)
	fs.Usage = usage

	fAnthropic := fs.Bool("anthropic", false, "")
	fOpenAI := fs.Bool("openai", false, "")
	fGemini := fs.Bool("gemini", false, "")
	fMistral := fs.Bool("mistral", false, "")
	fGroq := fs.Bool("groq", false, "")
	fCohere := fs.Bool("cohere", false, "")
	fTogether := fs.Bool("together", false, "")
	fPerplexity := fs.Bool("perplexity", false, "")
	fDeepSeek := fs.Bool("deepseek", false, "")
	fXAI := fs.Bool("xai", false, "")
	fHuggingFace := fs.Bool("huggingface", false, "")
	fReplicate := fs.Bool("replicate", false, "")
	fOutput := fs.String("output", "cli", "")
	fVersion := fs.Bool("version", false, "")

	// Extract the API key (first non-flag argument) so flags can appear anywhere.
	// String flags like --output consume the next token as their value, so we
	// must skip those values when hunting for the key.
	stringFlags := map[string]bool{"output": true}
	var key string
	var flagArgs []string
	rawArgs := os.Args[1:]
	for i := 0; i < len(rawArgs); i++ {
		arg := rawArgs[i]
		if strings.HasPrefix(arg, "--") {
			name := strings.TrimPrefix(arg, "--")
			if idx := strings.IndexByte(name, '='); idx >= 0 {
				// --flag=value form: entirely self-contained
				flagArgs = append(flagArgs, arg)
			} else if stringFlags[name] && i+1 < len(rawArgs) {
				// --flag value form: consume next token as value
				flagArgs = append(flagArgs, arg, rawArgs[i+1])
				i++
			} else {
				flagArgs = append(flagArgs, arg)
			}
		} else if strings.HasPrefix(arg, "-") && len(arg) == 2 {
			flagArgs = append(flagArgs, arg)
		} else {
			if key == "" {
				key = arg
			} else {
				fmt.Fprintln(os.Stderr, red("error: unexpected argument: "+arg))
				os.Exit(1)
			}
		}
	}
	fs.Parse(flagArgs)

	if *fVersion {
		fmt.Println("keyprobe v" + version)
		os.Exit(0)
	}

	if key == "" {
		fmt.Fprintln(os.Stderr, red("error: API key is required"))
		usage()
		os.Exit(1)
	}

	outputFormat := *fOutput
	if outputFormat != "json" && outputFormat != "cli" {
		fmt.Fprintf(os.Stderr, red("error: unknown output format %q (use 'json' or 'cli')\n"), outputFormat)
		os.Exit(1)
	}

	// Resolve provider from flags
	provider := Provider("")
	switch {
	case *fAnthropic:
		provider = ProviderAnthropic
	case *fOpenAI:
		provider = ProviderOpenAI
	case *fGemini:
		provider = ProviderGemini
	case *fMistral:
		provider = ProviderMistral
	case *fGroq:
		provider = ProviderGroq
	case *fCohere:
		provider = ProviderCohere
	case *fTogether:
		provider = ProviderTogether
	case *fPerplexity:
		provider = ProviderPerplexity
	case *fDeepSeek:
		provider = ProviderDeepSeek
	case *fXAI:
		provider = ProviderXAI
	case *fHuggingFace:
		provider = ProviderHuggingFace
	case *fReplicate:
		provider = ProviderReplicate
	}

	// Auto-detect if no provider flag given
	if provider == "" {
		provider = detectProvider(key)
		if provider == ProviderUnknown {
			fmt.Fprintln(os.Stderr, yellow("⚠ Could not auto-detect provider. Specify one with --anthropic, --openai, etc."))
			usage()
			os.Exit(1)
		}
		if outputFormat != "json" {
			fmt.Printf("%s %s\n", dim("Auto-detected:"), cyan(string(provider)))
		}
	}

	if outputFormat != "json" {
		fmt.Printf("%s", dim("Validating..."))
	}
	result := validate(key, provider)
	if outputFormat != "json" {
		fmt.Print("\r             \r") // clear "Validating..."
	}

	if outputFormat == "json" {
		printResultJSON(result)
	} else {
		printResult(result)
	}

	if !result.Valid {
		os.Exit(1)
	}
}