use async_trait::async_trait;
use anyhow::Result;

#[async_trait]
pub trait Provider: Send + Sync {
    /// Query provider capabilities
    fn capabilities(&self) -> ProviderCapabilities {
        ProviderCapabilities::default()
    }
    
    /// Convert tool specifications to provider-native format
    fn convert_tools(&self, tools: &[ToolSpec]) -> ToolsPayload {
        ToolsPayload::PromptGuided {
            instructions: build_tool_instructions_text(tools),
        }
    }
    
    /// Simple one-shot chat
    async fn simple_chat(
        &self,
        message: &str,
        model: &str,
        temperature: f64,
    ) -> Result<String>;
    
    /// Chat with optional system prompt
    async fn chat_with_system(
        &self,
        system_prompt: Option<&str>,
        message: &str,
        model: &str,
        temperature: f64,
    ) -> Result<String>;
    
    /// Multi-turn conversation
    async fn chat_with_history(
        &self,
        messages: &[ChatMessage],
        model: &str,
        temperature: f64,
    ) -> Result<String>;
    
    /// Structured chat API for agent loop
    async fn chat(
        &self,
        request: ChatRequest<'_>,
        model: &str,
        temperature: f64,
    ) -> Result<ChatResponse>;
    
    /// Whether provider supports native tool calls
    fn supports_native_tools(&self) -> bool {
        self.capabilities().native_tool_calling
    }
    
    /// Warm up HTTP connection pool
    async fn warmup(&self) -> Result<()> {
        Ok(())
    }
    
    /// Chat with native tool calling
    async fn chat_with_tools(
        &self,
        messages: &[ChatMessage],
        tools: &[serde_json::Value],
        model: &str,
        temperature: f64,
    ) -> Result<ChatResponse>;
    
    /// Whether provider supports streaming
    fn supports_streaming(&self) -> bool {
        false
    }
    
    /// Streaming chat
    fn stream_chat_with_system(
        &self,
        system_prompt: Option<&str>,
        message: &str,
        model: &str,
        temperature: f64,
        options: StreamOptions,
    ) -> stream::BoxStream<'static, StreamResult<StreamChunk>>;
    
    /// Streaming chat with history
    fn stream_chat_with_history(
        &self,
        messages: &[ChatMessage],
        model: &str,
        temperature: f64,
        options: StreamOptions,
    ) -> stream::BoxStream<'static, StreamResult<StreamChunk>>;
}

pub struct ChatMessage {
    pub role: String,     // "system", "user", "assistant", "tool"
    pub content: String,
}

impl ChatMessage {
    pub fn system(content: impl Into<String>) -> Self;
    pub fn user(content: impl Into<String>) -> Self;
    pub fn assistant(content: impl Into<String>) -> Self;
    pub fn tool(content: impl Into<String>) -> Self;
}

pub struct ChatResponse {
    pub text: Option<String>,
    pub tool_calls: Vec<ToolCall>,
}

impl ChatResponse {
    pub fn has_tool_calls(&self) -> bool;
    pub fn text_or_empty(&self) -> &str;
}

pub struct ToolCall {
    pub id: String,
    pub name: String,
    pub arguments: String,  // JSON string
}

pub struct ProviderCapabilities {
    pub native_tool_calling: bool,
}

impl Default for ProviderCapabilities {
    fn default() -> Self {
        Self { native_tool_calling: false }
    }
}

use async_trait::async_trait;
use anyhow::Result;

pub struct OllamaProvider {
    base_url: String,
    client: reqwest::Client,
}

impl OllamaProvider {
    pub fn new(base_url: Option<&str>) -> Self {
        Self {
            base_url: base_url.unwrap_or("http://localhost:11434").to_string(),
            client: reqwest::Client::new(),
        }
    }
}

#[async_trait]
impl Provider for OllamaProvider {
    async fn chat_with_system(
        &self,
        system_prompt: Option<&str>,
        message: &str,
        model: &str,
        temperature: f64,
    ) -> Result<String> {
        let url = format!("{}/api/generate", self.base_url);
        
        let prompt = match system_prompt {
            Some(sys) => format!("{sys}\n\n{message}"),
            None => message.to_string(),
        };
        
        let body = serde_json::json!({
            "model": model,
            "prompt": prompt,
            "temperature": temperature,
            "stream": false,
        });
        
        let resp = self.client
            .post(&url)
            .json(&body)
            .send()
            .await?
            .json::<serde_json::Value>()
            .await?;
        
        resp["response"]
            .as_str()
            .map(|s| s.to_string())
            .ok_or_else(|| anyhow::anyhow!("No response field"))
    }
}

impl Provider for AnthropicProvider {
    fn capabilities(&self) -> ProviderCapabilities {
        ProviderCapabilities {
            native_tool_calling: true,
        }
    }
    
    async fn chat_with_tools(
        &self,
        messages: &[ChatMessage],
        tools: &[serde_json::Value],
        model: &str,
        temperature: f64,
    ) -> Result<ChatResponse> {
        // Convert tools to Anthropic format
        // Make API call
        // Parse tool_use blocks
        // Return ChatResponse with tool_calls
    }
}

impl Provider for OllamaProvider {
    fn capabilities(&self) -> ProviderCapabilities {
        ProviderCapabilities {
            native_tool_calling: false,
        }
    }
    
    // Default implementation injects tool instructions into system prompt
}

<tool_call>
{"name": "shell", "arguments": {"command": "ls -la"}}
</tool_call>

impl Provider for OpenAIProvider {
    fn supports_streaming(&self) -> bool {
        true
    }
    
    fn stream_chat_with_system(
        &self,
        system_prompt: Option<&str>,
        message: &str,
        model: &str,
        temperature: f64,
        options: StreamOptions,
    ) -> stream::BoxStream<'static, StreamResult<StreamChunk>> {
        // Return async stream of chunks
        let stream = async_stream::stream! {
            // Yield StreamChunk::delta("text")
            // Yield StreamChunk::final_chunk()
        };
        
        Box::pin(stream)
    }
}

pub fn create_provider(name: &str, config: &Config) -> Result<Box<dyn Provider>> {
    match name {
        "openai" => Ok(Box::new(openai::OpenAIProvider::new(config))),
        "anthropic" => Ok(Box::new(anthropic::AnthropicProvider::new(config))),
        "ollama" => Ok(Box::new(ollama::OllamaProvider::new(None))),
        _ => Err(anyhow::anyhow!("Unknown provider: {}", name)),
    }
}