use anyhow::Result;

use crate::config::Config;
use crate::core::{
    create_client, get_provider_for_model, provider::get_all_models, provider::get_supported_models,
    ChatClient, Session,
};
use crate::utils::{Display, InputHandler, SessionAction};

pub struct ChatCLI {
    session: Session,
    client: Option<ChatClient>,
    current_model: Option<String>,
    display: Display,
    input: InputHandler,
    config: Config,
}

impl ChatCLI {
    pub fn new(session: Session, config: Config) -> Result<Self> {
        Ok(Self {
            session,
            client: None,
            current_model: None,
            display: Display::new(),
            input: InputHandler::new()?,
            config,
        })
    }

    fn get_client(&mut self) -> Result<&ChatClient> {
        if self.client.is_none() || self.current_model.as_ref() != Some(&self.session.model) {
            let client = create_client(&self.session.model, &self.config)?;
            self.current_model = Some(self.session.model.clone());
            self.client = Some(client);
        }
        Ok(self.client.as_ref().unwrap())
    }

    pub async fn run(&mut self) -> Result<()> {
        self.display.print_header();
        self.display.print_info("Type your message and press Enter. Commands start with '/'.");
        self.display.print_info("Type /help for help.");
        
        let provider = get_provider_for_model(&self.session.model);
        self.display.print_model_info(&self.session.model, provider.as_str());
        self.display.print_session_info(&self.session.name);
        
        println!();

        loop {
            match self.input.read_line("👤> ")? {
                Some(line) => {
                    let line = line.trim();
                    if line.is_empty() {
                        continue;
                    }

                    if line.starts_with('/') {
                        if !self.handle_command(line).await? {
                            break;
                        }
                    } else {
                        if let Err(e) = self.handle_user_message(line).await {
                            self.display.print_error(&format!("Error: {}", e));
                        }
                    }
                }
                None => {
                    self.display.print_info("Goodbye!");
                    break;
                }
            }
        }

        self.session.save()?;
        self.input.save_history()?;
        Ok(())
    }

    async fn handle_user_message(&mut self, message: &str) -> Result<()> {
        self.session.add_user_message(message.to_string());
        self.session.save()?;

        let spinner = self.display.show_spinner("Thinking");
        
        // Clone data needed for the API call before getting mutable client reference
        let model = self.session.model.clone();
        let messages = self.session.messages.clone();
        let enable_web_search = self.session.enable_web_search;
        let enable_reasoning_summary = self.session.enable_reasoning_summary;
        let reasoning_effort = self.session.reasoning_effort.clone();
        
        let client = self.get_client()?;
        
        match client
            .chat_completion(
                &model,
                &messages,
                enable_web_search,
                enable_reasoning_summary,
                &reasoning_effort,
            )
            .await
        {
            Ok(response) => {
                spinner.finish("Done");
                self.display.print_assistant_response(&response);
                self.session.add_assistant_message(response);
                self.session.save()?;
            }
            Err(e) => {
                spinner.finish_with_error("Failed");
                return Err(e);
            }
        }

        Ok(())
    }

    async fn handle_command(&mut self, command: &str) -> Result<bool> {
        let parts: Vec<&str> = command.split_whitespace().collect();
        if parts.is_empty() {
            return Ok(true);
        }

        match parts[0].to_lowercase().as_str() {
            "/help" => {
                self.display.print_help();
            }
            "/exit" => {
                self.session.save()?;
                self.display.print_info("Session saved. Goodbye!");
                return Ok(false);
            }
            "/model" => {
                self.model_switcher().await?;
            }
            "/models" => {
                self.list_models();
            }
            "/list" => {
                self.list_sessions()?;
            }
            "/new" => {
                self.handle_new_session(&parts)?;
            }
            "/switch" | "/sessions" => {
                self.session_manager().await?;
            }
            "/clear" => {
                self.session.clear_messages();
                self.session.save()?;
                self.display.print_command_result("Conversation cleared");
            }
            "/tools" => {
                self.tools_manager().await?;
            }
            "/effort" => {
                self.handle_effort_command(&parts)?;
            }
            "/stats" => {
                self.show_session_stats()?;
            }
            "/optimize" => {
                self.optimize_session()?;
            }
            "/cleanup" => {
                self.cleanup_session()?;
            }
            _ => {
                self.display.print_error(&format!("Unknown command: {} (see /help)", parts[0]));
            }
        }

        Ok(true)
    }

    async fn model_switcher(&mut self) -> Result<()> {
        let all_models = get_all_models();
        let selection = self.input.select_from_list(
            "Select a model:",
            &all_models,
            Some(&self.session.model),
        )?;
        
        match selection {
            Some(model) => {
                if model.to_string() == self.session.model {
                    self.display.print_info("Already using that model");
                } else {
                    self.session.model = model.to_string();
                    let provider = get_provider_for_model(&self.session.model);
                    self.display.print_command_result(&format!(
                        "Model switched to {} ({})",
                        self.session.model,
                        provider.as_str()
                    ));
                    self.client = None; // Force client recreation
                    self.session.save()?; // Save the model change
                }
            }
            None => {
                self.display.print_info("Model selection cancelled");
            }
        }
        
        Ok(())
    }

    fn list_models(&self) {
        self.display.print_info("Supported models:");
        let supported = get_supported_models();
        
        for (provider, models) in supported {
            println!("  {}:", provider.as_str().to_uppercase());
            for model in models {
                let marker = if model == self.session.model { " <- current" } else { "" };
                println!("    {}{}", model, marker);
            }
        }
    }

    fn list_sessions(&self) -> Result<()> {
        use crate::core::session::Session;
        let sessions = Session::list_sessions_lazy(true)?;
        
        if sessions.is_empty() {
            self.display.print_info("No saved sessions");
            return Ok(());
        }

        self.display.print_info("Saved sessions:");
        for session_info in sessions {
            let marker = if session_info.name == self.session.name { "★" } else { " " };
            let date_str = session_info.last_modified.format("%Y-%m-%d %H:%M:%S");
            let model = session_info.model.as_deref().unwrap_or("unknown");
            let msg_count = session_info.message_count.unwrap_or(0);
            let file_size = session_info.file_size.unwrap_or(0);
            let size_str = if file_size > 1024 { 
                format!("{:.1}KB", file_size as f64 / 1024.0) 
            } else { 
                format!("{}B", file_size) 
            };
            
            println!("  {} {} ({}msgs, {}, {}, {})", 
                marker, session_info.name, msg_count, model, size_str, date_str);
        }
        
        Ok(())
    }

    fn handle_new_session(&mut self, parts: &[&str]) -> Result<()> {
        if parts.len() != 2 {
            self.display.print_error("Usage: /new <session_name>");
            return Ok(());
        }

        self.session.save()?;
        let new_session = Session::new(parts[1].to_string(), self.session.model.clone());
        self.session = new_session;
        self.display.print_command_result(&format!("New session '{}' started", self.session.name));
        
        Ok(())
    }

    async fn session_manager(&mut self) -> Result<()> {
        loop {
            let sessions = Session::list_sessions()?;
            let session_names: Vec<String> = sessions
                .into_iter()
                .map(|(name, _)| name)
                .collect();

            if session_names.is_empty() {
                self.display.print_info("No sessions available");
                return Ok(());
            }

            let action = self.input.session_manager(
                "Session Manager:",
                &session_names,
                Some(&self.session.name),
            )?;

            match action {
                SessionAction::Switch(session_name) => {
                    if session_name == self.session.name {
                        self.display.print_info("Already in that session");
                        return Ok(());
                    }
                    
                    self.session.save()?;
                    match Session::load(&session_name) {
                        Ok(session) => {
                            self.session = session;
                            self.display.print_command_result(&format!(
                                "Switched to session '{}' (model={})",
                                self.session.name, self.session.model
                            ));
                            self.client = None; // Force client recreation
                            return Ok(());
                        }
                        Err(e) => {
                            self.display.print_error(&format!("Failed to load session: {}", e));
                            // Don't return, allow user to try again or cancel
                        }
                    }
                }
                SessionAction::Delete(session_name) => {
                    match Session::delete_session(&session_name) {
                        Ok(()) => {
                            self.display.print_command_result(&format!("Session '{}' deleted", session_name));
                            
                            // If we deleted the current session, we need to handle this specially
                            if session_name == self.session.name {
                                // Try to switch to another session or create a default one
                                let remaining_sessions = Session::list_sessions()?;
                                let remaining_names: Vec<String> = remaining_sessions
                                    .into_iter()
                                    .map(|(name, _)| name)
                                    .collect();
                                
                                if remaining_names.is_empty() {
                                    // No sessions left, create a default one
                                    self.session = Session::new("default".to_string(), self.session.model.clone());
                                    self.display.print_command_result("Created new default session");
                                    return Ok(());
                                } else {
                                    // Switch to the first available session
                                    match Session::load(&remaining_names[0]) {
                                        Ok(session) => {
                                            self.session = session;
                                            self.display.print_command_result(&format!(
                                                "Switched to session '{}' (model={})",
                                                self.session.name, self.session.model
                                            ));
                                            self.client = None;
                                            return Ok(());
                                        }
                                        Err(e) => {
                                            self.display.print_error(&format!("Failed to load fallback session: {}", e));
                                            // Create a new default session as fallback
                                            self.session = Session::new("default".to_string(), self.session.model.clone());
                                            self.display.print_command_result("Created new default session");
                                            return Ok(());
                                        }
                                    }
                                }
                            }
                            // Continue to show updated session list if we didn't delete current session
                        }
                        Err(e) => {
                            self.display.print_error(&format!("Failed to delete session: {}", e));
                            // Continue to allow retry
                        }
                    }
                }
                SessionAction::Cancel => {
                    return Ok(());
                }
            }
        }
    }


    async fn tools_manager(&mut self) -> Result<()> {
        loop {
            // Show current tool status
            self.display.print_info("Tool Management:");
            
            let web_status = if self.session.enable_web_search { "✓ enabled" } else { "✗ disabled" };
            let reasoning_status = if self.session.enable_reasoning_summary { "✓ enabled" } else { "✗ disabled" };
            
            println!("  Web Search: {}", web_status);
            println!("  Reasoning Summaries: {}", reasoning_status);
            println!("  Reasoning Effort: {}", self.session.reasoning_effort);
            
            // Check model compatibility
            let model = self.session.model.clone();
            let provider = get_provider_for_model(&model);
            let web_enabled = self.session.enable_web_search;
            let reasoning_enabled = self.session.enable_reasoning_summary;
            
            // Show compatibility warnings based on provider
            match provider {
                crate::core::provider::Provider::Anthropic => {
                    if web_enabled {
                        self.display.print_warning("Web search is not supported by Anthropic models");
                    }
                    if reasoning_enabled {
                        self.display.print_warning("Reasoning summaries are not supported by Anthropic models");
                    }
                }
                crate::core::provider::Provider::OpenAI => {
                    // OpenAI models generally support these features
                }
            }
            
            // Tool management options
            let options = vec![
                "Toggle Web Search",
                "Toggle Reasoning Summaries", 
                "Set Reasoning Effort",
                "Done"
            ];
            
            let selection = self.input.select_from_list(
                "Select an option:",
                &options,
                None,
            )?;
            
            match selection.as_deref() {
                Some("Toggle Web Search") => {
                    self.session.enable_web_search = !self.session.enable_web_search;
                    let state = if self.session.enable_web_search { "enabled" } else { "disabled" };
                    self.display.print_command_result(&format!("Web search {}", state));
                }
                Some("Toggle Reasoning Summaries") => {
                    self.session.enable_reasoning_summary = !self.session.enable_reasoning_summary;
                    let state = if self.session.enable_reasoning_summary { "enabled" } else { "disabled" };
                    self.display.print_command_result(&format!("Reasoning summaries {}", state));
                }
                Some("Set Reasoning Effort") => {
                    let effort_options = vec!["low", "medium", "high"];
                    if let Some(effort) = self.input.select_from_list(
                        "Select reasoning effort:",
                        &effort_options,
                        Some(&self.session.reasoning_effort),
                    )? {
                        self.session.reasoning_effort = effort.to_string();
                        self.display.print_command_result(&format!("Reasoning effort set to {}", effort));
                        
                        if !self.session.model.starts_with("gpt-5") {
                            self.display.print_warning("Reasoning effort is only supported by GPT-5 models");
                        }
                    }
                }
                Some("Done") | None => {
                    break;
                }
                _ => {}
            }
            
            self.session.save()?; // Save changes after each modification
            println!(); // Add spacing
        }
        
        Ok(())
    }

    fn handle_effort_command(&mut self, parts: &[&str]) -> Result<()> {
        if parts.len() == 1 {
            self.display.print_info(&format!("Current reasoning effort: {}", self.session.reasoning_effort));
            self.display.print_info("Available levels: low, medium, high");
            if !self.session.model.starts_with("gpt-5") {
                self.display.print_warning("Reasoning effort is only supported by GPT-5 models");
            }
        } else if parts.len() == 2 {
            let effort = parts[1];
            if !["low", "medium", "high"].contains(&effort) {
                self.display.print_error("Invalid effort level. Use: low, medium, or high");
            } else {
                if !self.session.model.starts_with("gpt-5") {
                    self.display.print_warning("Reasoning effort is only supported by GPT-5 models");
                }
                self.session.reasoning_effort = effort.to_string();
                self.display.print_command_result(&format!("Reasoning effort set to {}", effort));
            }
        } else {
            self.display.print_error("Usage: /effort [low|medium|high]");
        }
        
        Ok(())
    }

    fn show_session_stats(&self) -> Result<()> {
        let stats = self.session.get_stats();
        
        self.display.print_info("Session Statistics:");
        println!("  Total messages: {}", stats.total_messages);
        println!("  User messages: {}", stats.user_messages);
        println!("  Assistant messages: {}", stats.assistant_messages);
        println!("  Total characters: {}", stats.total_characters);
        println!("  Average message length: {}", stats.average_message_length);
        
        let memory_usage = std::mem::size_of_val(&self.session) + 
                          self.session.messages.iter()
                              .map(|m| m.content.len() + m.role.len())
                              .sum::<usize>();
        
        let memory_str = if memory_usage > 1024 * 1024 {
            format!("{:.1} MB", memory_usage as f64 / (1024.0 * 1024.0))
        } else if memory_usage > 1024 {
            format!("{:.1} KB", memory_usage as f64 / 1024.0)
        } else {
            format!("{} bytes", memory_usage)
        };
        
        println!("  Estimated memory usage: {}", memory_str);
        
        if self.session.needs_cleanup() {
            self.display.print_warning("Session is large and may benefit from cleanup (/cleanup)");
        }
        
        Ok(())
    }

    fn optimize_session(&mut self) -> Result<()> {
        let stats_before = self.session.get_stats();
        
        self.session.optimize_for_memory();
        self.session.save()?;
        
        let stats_after = self.session.get_stats();
        let chars_saved = stats_before.total_characters.saturating_sub(stats_after.total_characters);
        
        self.display.print_command_result(&format!(
            "Session optimized: {} characters cleaned up",
            chars_saved
        ));
        
        Ok(())
    }

    fn cleanup_session(&mut self) -> Result<()> {
        let stats_before = self.session.get_stats();
        
        if self.input.confirm("This will remove older messages to reduce memory usage. Continue?")? {
            self.session.cleanup_for_memory();
            self.session.save()?;
            
            let stats_after = self.session.get_stats();
            let messages_removed = stats_before.total_messages.saturating_sub(stats_after.total_messages);
            
            self.display.print_command_result(&format!(
                "Session cleaned up: {} messages removed, keeping most recent conversations",
                messages_removed
            ));
        } else {
            self.display.print_info("Cleanup cancelled");
        }
        
        Ok(())
    }
}