opencrates 3.0.1

//! Application state management for the OpenCrates TUI
//!
//! This module defines the main application state that drives the terminal interface,
//! managing data updates, user interactions, and coordination with the OpenCrates core.

use crate::utils::health::{HealthInfo, HealthStatus};
use crate::utils::project::ProjectAnalysis;
use anyhow::Result;
use std::collections::HashMap;
use std::sync::Arc;
use tracing::{debug, info, warn};

/// Main application state for the TUI
///
/// Contains all the data and state necessary to render the interface and handle user interactions
#[derive(Debug)]
pub struct App {
    /// Reference to the `OpenCrates` core for business logic operations
    pub opencrates: Arc<crate::core::OpenCrates>,
    /// Current project analysis data, if available
    pub analysis: Option<ProjectAnalysis>,
    /// System health status information
    pub health: Option<HealthInfo>,
    /// List of project dependencies
    pub dependencies: Vec<String>,
    /// Flag indicating whether the application should quit
    pub should_quit: bool,
}

impl App {
    /// Creates a new App instance with the provided `OpenCrates` core
    ///
    /// # Arguments
    /// * `opencrates` - Arc reference to the `OpenCrates` core instance
    ///
    /// # Returns
    /// A new App instance with initialized state
    ///
    /// # Errors
    /// Returns an error if initial data refresh fails
    pub async fn new(opencrates: Arc<crate::core::OpenCrates>) -> Result<Self> {
        info!("Initializing TUI application");

        let mut app = Self {
            opencrates,
            analysis: None,
            health: None,
            dependencies: Vec::new(),
            should_quit: false,
        };

        // Initialize data
        if let Err(e) = app.refresh().await {
            warn!("Failed to load initial data: {}", e);
        }

        debug!("TUI application initialized successfully");
        Ok(app)
    }

    /// Refreshes all application data from the `OpenCrates` core
    ///
    /// This method updates project analysis, health status, and dependency information
    ///
    /// # Returns
    /// Result indicating successful refresh or error details
    ///
    /// # Errors
    /// Returns an error if any data refresh operation fails
    pub async fn refresh(&mut self) -> Result<()> {
        info!("Refreshing application data");

        let refresh_start = std::time::Instant::now();

        // Update all data sources sequentially to avoid borrow issues
        let analysis_result = self.update_analysis().await;
        let health_result = self.update_health().await;
        let deps_result = self.update_dependencies().await;

        // Log any individual failures but don't fail the entire refresh
        if let Err(e) = analysis_result {
            warn!("Failed to update analysis: {}", e);
        }

        if let Err(e) = health_result {
            warn!("Failed to update health: {}", e);
        }

        if let Err(e) = deps_result {
            warn!("Failed to update dependencies: {}", e);
        }

        let refresh_duration = refresh_start.elapsed();
        debug!("Data refresh completed in {:?}", refresh_duration);

        Ok(())
    }

    /// Performs periodic updates for real-time data
    ///
    /// This method is called regularly to update time-sensitive information
    /// without requiring user interaction
    ///
    /// # Returns
    /// Result indicating successful update
    ///
    /// # Errors
    /// Returns an error if update operations fail
    pub async fn update(&mut self) -> Result<()> {
        // Perform lightweight periodic updates
        // Update health more frequently than analysis for responsiveness
        self.update_health().await.ok(); // Don't fail on health update errors

        Ok(())
    }

    /// Updates project analysis data
    ///
    /// Analyzes the current directory or project and updates the analysis state
    ///
    /// # Returns
    /// Result indicating successful analysis update
    ///
    /// # Errors
    /// Returns an error if project analysis fails
    pub async fn update_analysis(&mut self) -> Result<()> {
        debug!("Updating project analysis");

        let current_dir = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));

        match self.opencrates.analyze_crate(&current_dir).await {
            Ok(analysis) => {
                debug!("Project analysis updated successfully");
                self.analysis = Some(analysis);
                Ok(())
            }
            Err(e) => {
                warn!("Failed to update project analysis: {}", e);
                self.analysis = None;
                Err(e)
            }
        }
    }

    /// Updates system health information
    ///
    /// Checks the health of various system components and services
    ///
    /// # Returns
    /// Result indicating successful health update
    ///
    /// # Errors
    /// Returns an error if health check fails
    pub async fn update_health(&mut self) -> Result<()> {
        debug!("Updating health information");

        match self.opencrates.health_check().await {
            Ok(health) => {
                debug!("Health information updated successfully");
                self.health = Some(health);
                Ok(())
            }
            Err(e) => {
                warn!("Failed to update health information: {}", e);
                self.health = None;
                Err(e)
            }
        }
    }

    /// Updates dependency information
    ///
    /// Loads and analyzes project dependencies from Cargo.toml and other sources
    ///
    /// # Returns
    /// Result indicating successful dependency update
    ///
    /// # Errors
    /// Returns an error if dependency analysis fails
    pub async fn update_dependencies(&mut self) -> Result<()> {
        debug!("Updating dependency information");

        // Try to read Cargo.toml from current directory
        let cargo_path = std::env::current_dir()
            .unwrap_or_else(|_| std::path::PathBuf::from("."))
            .join("Cargo.toml");

        if cargo_path.exists() {
            match self.parse_cargo_dependencies(&cargo_path).await {
                Ok(deps) => {
                    debug!("Found {} dependencies", deps.len());
                    self.dependencies = deps;
                    Ok(())
                }
                Err(e) => {
                    warn!("Failed to parse Cargo.toml: {}", e);
                    self.dependencies.clear();
                    Err(e)
                }
            }
        } else {
            debug!("No Cargo.toml found in current directory");
            self.dependencies.clear();
            Ok(())
        }
    }

    /// Parses dependencies from a Cargo.toml file
    ///
    /// # Arguments
    /// * `cargo_path` - Path to the Cargo.toml file
    ///
    /// # Returns
    /// Vector of dependency names
    ///
    /// # Errors
    /// Returns an error if file reading or parsing fails
    async fn parse_cargo_dependencies(&self, cargo_path: &std::path::Path) -> Result<Vec<String>> {
        let content = tokio::fs::read_to_string(cargo_path).await?;
        let cargo_toml: toml::Value = toml::from_str(&content)?;

        let mut dependencies = Vec::new();

        // Parse [dependencies] section
        if let Some(deps) = cargo_toml.get("dependencies").and_then(|v| v.as_table()) {
            for (name, _) in deps {
                dependencies.push(name.clone());
            }
        }

        // Parse [dev-dependencies] section
        if let Some(dev_deps) = cargo_toml
            .get("dev-dependencies")
            .and_then(|v| v.as_table())
        {
            for (name, _) in dev_deps {
                if !dependencies.contains(name) {
                    dependencies.push(format!("{name} (dev)"));
                }
            }
        }

        // Parse [build-dependencies] section
        if let Some(build_deps) = cargo_toml
            .get("build-dependencies")
            .and_then(|v| v.as_table())
        {
            for (name, _) in build_deps {
                if !dependencies.iter().any(|d| d.starts_with(name)) {
                    dependencies.push(format!("{name} (build)"));
                }
            }
        }

        dependencies.sort();
        Ok(dependencies)
    }

    /// Gets the current project name if available
    ///
    /// # Returns
    /// Optional project name string
    #[must_use]
    pub fn project_name(&self) -> Option<&str> {
        self.analysis.as_ref().map(|a| a.name.as_str())
    }

    /// Gets the current project description if available
    ///
    /// # Returns
    /// Optional project description string
    #[must_use]
    pub fn project_description(&self) -> Option<&str> {
        self.analysis.as_ref().map(|_a| "No description available")
    }

    /// Gets the current project version if available
    ///
    /// # Returns
    /// Optional project version string
    #[must_use]
    pub fn project_version(&self) -> Option<&str> {
        self.analysis.as_ref().map(|_a| "0.1.0")
    }

    /// Gets the number of dependencies
    ///
    /// # Returns
    /// Number of dependencies
    #[must_use]
    pub fn dependency_count(&self) -> usize {
        self.dependencies.len()
    }

    /// Checks if the project appears to be a valid Rust project
    ///
    /// # Returns
    /// True if this appears to be a valid Rust project
    #[must_use]
    pub fn is_rust_project(&self) -> bool {
        self.analysis.is_some() || !self.dependencies.is_empty()
    }

    /// Gets health status summary
    ///
    /// # Returns
    /// A summary string of the current health status
    #[must_use]
    pub fn health_status(&self) -> String {
        match &self.health {
            Some(health) => match health.overall_status {
                HealthStatus::Healthy => "Healthy".to_string(),
                HealthStatus::Degraded => "Degraded".to_string(),
                HealthStatus::Unhealthy => "Unhealthy".to_string(),
                HealthStatus::Critical => "Critical".to_string(),
                HealthStatus::Warning => "Warning".to_string(),
                // Unknown status removed from enum
            },
            None => "Unknown".to_string(),
        }
    }

    /// Gets a summary of the current application state
    ///
    /// # Returns
    /// A formatted string containing key application state information
    #[must_use]
    pub fn state_summary(&self) -> String {
        format!(
            "Project: {} | Dependencies: {} | Health: {} | Analysis: {}",
            self.project_name().unwrap_or("None"),
            self.dependency_count(),
            self.health_status(),
            if self.analysis.is_some() {
                "Available"
            } else {
                "None"
            }
        )
    }

    /// Handles user input for navigation and actions
    ///
    /// # Arguments
    /// * `key` - The key event to handle
    ///
    /// # Returns
    /// Result indicating whether the application should continue (Ok(false)) or quit (Ok(true))
    ///
    /// # Errors
    /// Returns an error if the key handling operation fails
    pub async fn handle_key_event(&mut self, key: crossterm::event::KeyEvent) -> Result<bool> {
        use crossterm::event::{KeyCode, KeyModifiers};

        match (key.code, key.modifiers) {
            // Quit application
            (KeyCode::Char('q'), KeyModifiers::NONE)
            | (KeyCode::Char('c'), KeyModifiers::CONTROL) => {
                info!("User requested application quit");
                self.should_quit = true;
                Ok(true)
            }

            // Refresh data
            (KeyCode::Char('r'), KeyModifiers::NONE) => {
                info!("User requested data refresh");
                if let Err(e) = self.refresh().await {
                    warn!("Manual refresh failed: {}", e);
                }
                Ok(false)
            }

            // Force refresh (with Ctrl+R)
            (KeyCode::Char('r'), KeyModifiers::CONTROL) => {
                info!("User requested forced refresh");
                // Clear all data first, then refresh
                self.analysis = None;
                self.health = None;
                self.dependencies.clear();

                if let Err(e) = self.refresh().await {
                    warn!("Forced refresh failed: {}", e);
                }
                Ok(false)
            }

            // Show help (placeholder)
            (KeyCode::Char('?'), KeyModifiers::NONE) => {
                debug!("Help requested");
                // TODO: Implement help display
                Ok(false)
            }

            // Any other key - continue running
            _ => {
                debug!("Unhandled key event: {:?}", key);
                Ok(false)
            }
        }
    }

    /// Updates the application's internal tick counter for animations and periodic updates
    pub fn tick(&mut self) {
        // This method can be used for periodic updates that don't require async operations
        // Currently it's a placeholder for future features like animations or counters
    }

    /// Checks if the application has meaningful data to display
    ///
    /// # Returns
    /// True if there's meaningful data to show in the UI
    #[must_use]
    pub fn has_data(&self) -> bool {
        self.analysis.is_some() || self.health.is_some() || !self.dependencies.is_empty()
    }

    /// Gets a list of available actions based on current state
    ///
    /// # Returns
    /// Vector of action descriptions
    #[must_use]
    pub fn available_actions(&self) -> Vec<String> {
        let mut actions = vec![
            "q - Quit".to_string(),
            "r - Refresh".to_string(),
            "? - Help".to_string(),
        ];

        if self.is_rust_project() {
            actions.push("Ctrl+R - Force Refresh".to_string());
        }

        actions
    }

    /// Gets diagnostic information for debugging
    ///
    /// # Returns
    /// A formatted string with diagnostic information
    #[must_use]
    pub fn diagnostics(&self) -> String {
        format!(
            "Analysis: {} | Health: {} | Dependencies: {} | Should Quit: {}",
            self.analysis.is_some(),
            self.health.is_some(),
            self.dependencies.len(),
            self.should_quit
        )
    }

    /// Validates the current application state
    ///
    /// # Returns
    /// Vector of validation issues, empty if all is well
    #[must_use]
    pub fn validate_state(&self) -> Vec<String> {
        let mut issues = Vec::new();

        if std::ptr::from_ref(self.opencrates.as_ref()) as usize == 0 {
            issues.push("OpenCrates core reference is invalid".to_string());
        }

        // Add more validation checks as needed

        issues
    }

    /// Exports the current application state for debugging or persistence
    ///
    /// # Returns
    /// A JSON representation of the current state
    ///
    /// # Errors
    /// Returns an error if serialization fails
    pub fn export_state(&self) -> Result<String> {
        let state = serde_json::json!({
            "has_analysis": self.analysis.is_some(),
            "has_health": self.health.is_some(),
            "dependency_count": self.dependencies.len(),
            "dependencies": self.dependencies,
            "should_quit": self.should_quit,
            "project_name": self.project_name(),
            "health_status": self.health_status(),
            "timestamp": chrono::Utc::now().to_rfc3339()
        });

        Ok(serde_json::to_string_pretty(&state)?)
    }
}