use anyhow::Result;

use crate::config::Config;
use crate::core::{
    create_client, get_provider_for_model, provider::get_all_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?;
            }
            "/new" => {
                self.handle_new_session(&parts)?;
            }
            "/switch" => {
                self.session_manager().await?;
            }
            "/clear" => {
                self.session.clear_messages();
                self.session.save()?;
                self.display.print_command_result("Conversation cleared");
            }
            "/tools" => {
                self.tools_manager().await?;
            }
            _ => {
                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 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(())
    }

}