// src/providers/traits.rs
#[async_trait]
pub trait Provider: Send + Sync + std::fmt::Debug {
    /// Provider 名称
    fn name(&self) -> &str;
    
    /// 完成对话
    async fn complete(&self, request: CompletionRequest) 
        -> Result<CompletionResponse, ProviderError>;
    
    /// 流式完成
    async fn complete_stream(&self, request: CompletionRequest) 
        -> Result<BoxStream<'static, Result<StreamChunk, ProviderError>>, ProviderError>;
    
    /// 列出可用模型
    async fn list_models(&self) -> Result<Vec<ModelInfo>, ProviderError>;
    
    /// 健康检查
    async fn health_check(&self) -> HealthStatus;
    
    /// 预热（建立连接池等）
    async fn warmup(&self) -> Result<()> {
        Ok(())
    }
}

/// 完成请求
#[derive(Debug, Clone)]
pub struct CompletionRequest {
    pub messages: Vec<Message>,
    pub model: Option<String>,
    pub temperature: Option<f32>,
    pub max_tokens: Option<u32>,
    pub tools: Option<Vec<ToolSpec>>,
    pub stream: bool,
}

/// 完成响应
#[derive(Debug, Clone)]
pub struct CompletionResponse {
    pub content: String,
    pub tool_calls: Option<Vec<ToolCall>>,
    pub usage: TokenUsage,
    pub model: String,
}

pub struct TokenUsage {
    pub prompt_tokens: u32,
    pub completion_tokens: u32,
    pub total_tokens: u32,
}

// src/providers/openai.rs
pub struct OpenAiProvider {
    client: reqwest::Client,
    api_key: String,
    base_url: String,
    default_model: String,
}

#[async_trait]
impl Provider for OpenAiProvider {
    fn name(&self) -> &str {
        "openai"
    }
    
    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse, ProviderError> {
        let body = json!({
            "model": request.model.as_deref().unwrap_or(&self.default_model),
            "messages": request.messages,
            "temperature": request.temperature.unwrap_or(0.7),
            "max_tokens": request.max_tokens,
            "tools": request.tools,
        });
        
        let response = self.client
            .post(format!("{}/v1/chat/completions", self.base_url))
            .header("Authorization", format!("Bearer {}", self.api_key))
            .json(&body)
            .send()
            .await
            .map_err(|e| ProviderError::Network(e.to_string()))?;
            
        if !response.status().is_success() {
            let error = response.text().await.unwrap_or_default();
            return Err(ProviderError::ApiError(error));
        }
        
        let result: OpenAiResponse = response.json().await
            .map_err(|e| ProviderError::ParseError(e.to_string()))?;
            
        Ok(CompletionResponse {
            content: result.choices[0].message.content.unwrap_or_default(),
            tool_calls: result.choices[0].message.tool_calls.map(|tcs| {
                tcs.into_iter().map(|tc| ToolCall {
                    id: tc.id,
                    name: tc.function.name,
                    arguments: tc.function.arguments,
                }).collect()
            }),
            usage: TokenUsage {
                prompt_tokens: result.usage.prompt_tokens,
                completion_tokens: result.usage.completion_tokens,
                total_tokens: result.usage.total_tokens,
            },
            model: result.model,
        })
    }
    
    async fn complete_stream(&self, request: CompletionRequest) 
        -> Result<BoxStream<'static, Result<StreamChunk, ProviderError>>, ProviderError> {
        // 实现流式响应...
        todo!()
    }
}

// OpenAI API 响应结构
#[derive(Debug, Deserialize)]
struct OpenAiResponse {
    model: String,
    choices: Vec<Choice>,
    usage: Usage,
}

#[derive(Debug, Deserialize)]
struct Choice {
    message: Message,
}

#[derive(Debug, Deserialize)]
struct Message {
    content: Option<String>,
    tool_calls: Option<Vec<ToolCall>>,
}

#[derive(Debug, Deserialize)]
struct Usage {
    prompt_tokens: u32,
    completion_tokens: u32,
    total_tokens: u32,
}

// src/providers/ollama.rs
pub struct OllamaProvider {
    client: reqwest::Client,
    base_url: String,
    default_model: String,
}

#[async_trait]
impl Provider for OllamaProvider {
    fn name(&self) -> &str {
        "ollama"
    }
    
    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse, ProviderError> {
        let body = json!({
            "model": request.model.as_deref().unwrap_or(&self.default_model),
            "messages": request.messages,
            "stream": false,
        });
        
        let response = self.client
            .post(format!("{}/api/chat", self.base_url))
            .json(&body)
            .send()
            .await
            .map_err(|e| {
                if e.is_connect() {
                    ProviderError::Network(
                        "无法连接到 Ollama，请检查服务是否运行".into()
                    )
                } else {
                    ProviderError::Network(e.to_string())
                }
            })?;
            
        let result: OllamaResponse = response.json().await
            .map_err(|e| ProviderError::ParseError(e.to_string()))?;
            
        Ok(CompletionResponse {
            content: result.message.content,
            tool_calls: None,  // Ollama 部分模型支持工具调用
            usage: TokenUsage {
                // Ollama 不返回 token 计数，需要估算
                prompt_tokens: 0,
                completion_tokens: 0,
                total_tokens: 0,
            },
            model: result.model,
        })
    }
    
    async fn health_check(&self) -> HealthStatus {
        match self.client
            .get(format!("{}/api/tags", self.base_url))
            .send()
            .await {
            Ok(resp) if resp.status().is_success() => HealthStatus::Healthy,
            _ => HealthStatus::Unhealthy("无法连接到 Ollama 服务".into()),
        }
    }
}

// src/providers/mod.rs
pub struct ProviderFactory;

impl ProviderFactory {
    pub async fn create(config: &ProviderConfig) -> Result<Box<dyn Provider>> {
        match config.type_.as_str() {
            "openai" => Ok(Box::new(OpenAiProvider::new(config)?)),
            "anthropic" => Ok(Box::new(AnthropicProvider::new(config)?)),
            "ollama" => Ok(Box::new(OllamaProvider::new(config)?)),
            "openrouter" => Ok(Box::new(OpenRouterProvider::new(config)?)),
            "deepseek" => Ok(Box::new(DeepSeekProvider::new(config)?)),
            "custom" => Ok(Box::new(CustomProvider::new(config)?)),
            _ => Err(Error::UnknownProvider(config.type_.clone())),
        }
    }
    
    pub fn list_available() -> Vec<&'static str> {
        vec![
            "openai",
            "anthropic",
            "ollama",
            "openrouter",
            "deepseek",
            "groq",
            "together",
            "custom",
        ]
    }
}

# 快速开始（推荐）
default_provider = "openrouter"
default_model = "openrouter/auto"

# 最强代码能力
default_provider = "openrouter"
default_model = "anthropic/claude-sonnet-4"

# 本地免费
default_provider = "ollama"
default_model = "llama3.2"

# 中文优化
default_provider = "openrouter"
default_model = "deepseek/deepseek-chat"

# 成本优先
default_provider = "openrouter"
default_model = "openrouter/optimus"

// src/providers/cached.rs
pub struct CachedProvider {
    inner: Box<dyn Provider>,
    cache: Arc<RwLock<LruCache<String, CompletionResponse>>>,
}

#[async_trait]
impl Provider for CachedProvider {
    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse, ProviderError> {
        // 生成缓存键
        let cache_key = format!(
            "{}/{}/{}/{}",
            request.model.as_deref().unwrap_or("default"),
            hash_messages(&request.messages),
            request.temperature.unwrap_or(0.7),
            request.max_tokens.unwrap_or(0)
        );
        
        // 检查缓存
        {
            let cache = self.cache.read().await;
            if let Some(cached) = cache.get(&cache_key) {
                trace!("Provider 缓存命中");
                return Ok(cached.clone());
            }
        }
        
        // 调用实际 Provider
        let result = self.inner.complete(request).await?;
        
        // 写入缓存
        {
            let mut cache = self.cache.write().await;
            cache.put(cache_key, result.clone());
        }
        
        Ok(result)
    }
    
    fn name(&self) -> &str {
        self.inner.name()
    }
}

商业模型:
- openai          : GPT-4o, GPT-4o-mini, o1, o3
- anthropic       : Claude 3.5/3.7 Sonnet, Opus, Haiku
- google          : Gemini 1.5/2.0 Pro/Flash
- cohere          : Command R, Command R+

聚合平台:
- openrouter      : 100+ 模型统一接口 (推荐)
- together        : Together AI 推理
- groq            : 极速推理平台

开源/本地:
- ollama          : 本地运行 Llama, Qwen, Phi 等
- lmstudio        : LM Studio 本地服务
- vllm            : vLLM 推理引擎

国内服务:
- deepseek        : DeepSeek Coder/Chat
- zai             : Z AI GLM-5
- openrouter-cn   : 通过 OpenRouter 访问国内模型

自定义:
- custom:https:// : 自定义 OpenAI 兼容端点

// 实现自定义 Provider
pub struct MyCustomProvider {
    client: reqwest::Client,
    api_key: String,
}

#[async_trait]
impl Provider for MyCustomProvider {
    fn name(&self) -> &str {
        "my-provider"
    }
    
    async fn complete(&self, request: CompletionRequest) 
        -> Result<CompletionResponse, ProviderError> {
        // 实现自己的 API 调用逻辑
        todo!()
    }
    
    async fn list_models(&self) -> Result<Vec<ModelInfo>, ProviderError> {
        Ok(vec![
            ModelInfo {
                id: "my-model".into(),
                name: "My Custom Model".into(),
                context_length: 4096,
            }
        ])
    }
}

// 注册到工厂
pub fn register_custom_providers(factory: &mut ProviderFactory) {
    factory.register("my-provider", |config| {
        Box::new(MyCustomProvider::new(config))
    });
}

# 使用自定义 Provider
default_provider = "custom:https://api.example.com/v1"
api_key = "your-api-key"