mod claude_cli;
mod ollama;
mod traits;

// Re-exports for when providers are fully integrated
#[allow(unused_imports)]
pub use claude_cli::ClaudeCliProvider;
#[allow(unused_imports)]
pub use ollama::OllamaProvider;
#[allow(unused_imports)]
pub use traits::{
    LlmProvider, ModelInfo, ProviderCapabilities, ProviderConfig, ProviderMessage,
    ProviderStreamEvent, ProviderUsage, QuestionOption, StreamCallback,
};

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ProviderType {
    #[default]
    ClaudeCli,
    Ollama,
}

#[allow(dead_code)]
impl ProviderType {
    pub fn display_name(&self) -> &'static str {
        match self {
            ProviderType::ClaudeCli => "Claude CLI",
            ProviderType::Ollama => "Ollama (Local)",
        }
    }

    pub fn description(&self) -> &'static str {
        match self {
            ProviderType::ClaudeCli => "Use Claude Code CLI for AI assistance",
            ProviderType::Ollama => "Use locally running Ollama models",
        }
    }
}

#[allow(dead_code)]
pub fn create_provider(
    provider_type: ProviderType,
    config: ProviderConfig,
) -> Box<dyn LlmProvider> {
    match provider_type {
        ProviderType::ClaudeCli => Box::new(ClaudeCliProvider::new(config)),
        ProviderType::Ollama => Box::new(OllamaProvider::new(config)),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_provider_type_display_name() {
        assert_eq!(ProviderType::ClaudeCli.display_name(), "Claude CLI");
        assert_eq!(ProviderType::Ollama.display_name(), "Ollama (Local)");
    }

    #[test]
    fn test_provider_type_default() {
        let default: ProviderType = Default::default();
        assert_eq!(default, ProviderType::ClaudeCli);
    }

    #[test]
    fn test_provider_type_serialization() {
        let claude = ProviderType::ClaudeCli;
        let json = serde_json::to_string(&claude).unwrap();
        assert_eq!(json, "\"claude_cli\"");

        let ollama = ProviderType::Ollama;
        let json = serde_json::to_string(&ollama).unwrap();
        assert_eq!(json, "\"ollama\"");
    }

    #[test]
    fn test_provider_type_deserialization() {
        let claude: ProviderType = serde_json::from_str("\"claude_cli\"").unwrap();
        assert_eq!(claude, ProviderType::ClaudeCli);

        let ollama: ProviderType = serde_json::from_str("\"ollama\"").unwrap();
        assert_eq!(ollama, ProviderType::Ollama);
    }
}