use anyhow::Result;
use rusqlite::Connection;
use tracing::{info, warn};

/// 数据库优化工具
/// 负责创建索引、优化查询性能和数据库配置
pub struct DatabaseOptimizer;

impl DatabaseOptimizer {
    /// 创建所有性能优化索引
    pub fn create_performance_indexes(conn: &Connection) -> Result<()> {
        info!("开始创建数据库性能索引");

        // 工作流模板表索引
        Self::create_workflow_template_indexes(conn)?;
        
        // 执行记录表索引
        Self::create_execution_record_indexes(conn)?;
        
        // 执行环境表索引
        Self::create_execution_environment_indexes(conn)?;

        info!("数据库性能索引创建完成");
        Ok(())
    }

    /// 创建工作流模板表索引
    fn create_workflow_template_indexes(conn: &Connection) -> Result<()> {
        let indexes = vec![
            // 基础名称索引（用于版本查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_base_name ON workflow_templates(base_name)",
            
            // 基础名称+版本复合索引（用于唯一性查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_base_name_version ON workflow_templates(base_name, version)",
            
            // 工作流类型索引（用于类型筛选）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_workflow_type ON workflow_templates(workflow_type)",
            
            // 活跃状态索引（用于活跃模板查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_is_active ON workflow_templates(is_active)",
            
            // 发布状态索引（用于发布模板查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_is_published ON workflow_templates(is_published)",
            
            // 创建时间索引（用于时间范围查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_created_at ON workflow_templates(created_at)",
            
            // 更新时间索引（用于最近更新查询）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_updated_at ON workflow_templates(updated_at)",
            
            // 分类索引（用于分类筛选）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_category ON workflow_templates(category)",
            
            // 作者索引（用于作者筛选）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_author ON workflow_templates(author)",
            
            // 复合索引：活跃+发布状态（用于前端展示）
            "CREATE INDEX IF NOT EXISTS idx_workflow_templates_active_published ON workflow_templates(is_active, is_published)",
        ];

        for index_sql in indexes {
            if let Err(e) = conn.execute(index_sql, []) {
                warn!("创建工作流模板索引失败: {} - {}", index_sql, e);
            }
        }

        Ok(())
    }

    /// 创建执行记录表索引
    fn create_execution_record_indexes(conn: &Connection) -> Result<()> {
        let indexes = vec![
            // 工作流模板ID索引（用于模板相关查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_template_id ON workflow_execution_records(workflow_template_id)",
            
            // 执行环境ID索引（用于环境相关查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_environment_id ON workflow_execution_records(execution_environment_id)",
            
            // 执行状态索引（用于状态筛选）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_status ON workflow_execution_records(status)",
            
            // 创建时间索引（用于时间范围查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_created_at ON workflow_execution_records(created_at)",
            
            // 开始时间索引（用于执行时间分析）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_started_at ON workflow_execution_records(started_at)",
            
            // 完成时间索引（用于完成时间分析）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_completed_at ON workflow_execution_records(completed_at)",
            
            // 用户ID索引（用于用户相关查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_user_id ON workflow_execution_records(user_id)",
            
            // 会话ID索引（用于会话相关查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_session_id ON workflow_execution_records(session_id)",
            
            // ComfyUI提示ID索引（用于ComfyUI集成）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_comfyui_prompt_id ON workflow_execution_records(comfyui_prompt_id)",
            
            // 复合索引：模板+状态（用于模板执行统计）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_template_status ON workflow_execution_records(workflow_template_id, status)",
            
            // 复合索引：环境+状态（用于环境负载分析）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_environment_status ON workflow_execution_records(execution_environment_id, status)",
            
            // 复合索引：状态+创建时间（用于队列管理）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_status_created ON workflow_execution_records(status, created_at)",
            
            // 复合索引：用户+创建时间（用于用户历史查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_records_user_created ON workflow_execution_records(user_id, created_at)",
        ];

        for index_sql in indexes {
            if let Err(e) = conn.execute(index_sql, []) {
                warn!("创建执行记录索引失败: {} - {}", index_sql, e);
            }
        }

        Ok(())
    }

    /// 创建执行环境表索引
    fn create_execution_environment_indexes(conn: &Connection) -> Result<()> {
        let indexes = vec![
            // 环境类型索引（用于类型筛选）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_type ON workflow_execution_environments(environment_type)",
            
            // 活跃状态索引（用于活跃环境查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_is_active ON workflow_execution_environments(is_active)",
            
            // 可用状态索引（用于可用环境查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_is_available ON workflow_execution_environments(is_available)",
            
            // 健康状态索引（用于健康检查）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_health_status ON workflow_execution_environments(health_status)",
            
            // 优先级索引（用于优先级排序）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_priority ON workflow_execution_environments(priority)",
            
            // 最后健康检查时间索引（用于健康检查调度）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_last_health_check ON workflow_execution_environments(last_health_check)",
            
            // 创建时间索引（用于时间范围查询）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_created_at ON workflow_execution_environments(created_at)",
            
            // 复合索引：活跃+可用+健康（用于环境选择）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_available ON workflow_execution_environments(is_active, is_available, health_status)",
            
            // 复合索引：活跃+优先级（用于优先级排序）
            "CREATE INDEX IF NOT EXISTS idx_execution_environments_active_priority ON workflow_execution_environments(is_active, priority DESC)",
        ];

        for index_sql in indexes {
            if let Err(e) = conn.execute(index_sql, []) {
                warn!("创建执行环境索引失败: {} - {}", index_sql, e);
            }
        }

        Ok(())
    }

    /// 优化数据库配置
    pub fn optimize_database_settings(conn: &Connection) -> Result<()> {
        info!("开始优化数据库配置");

        let optimizations = vec![
            // 启用WAL模式以提高并发性能
            "PRAGMA journal_mode = WAL",
            
            // 设置同步模式为NORMAL以平衡性能和安全性
            "PRAGMA synchronous = NORMAL",
            
            // 增加缓存大小（10MB）
            "PRAGMA cache_size = -10000",
            
            // 设置临时存储为内存
            "PRAGMA temp_store = MEMORY",
            
            // 启用内存映射I/O（256MB）
            "PRAGMA mmap_size = 268435456",
            
            // 设置页面大小为4KB（适合现代SSD）
            "PRAGMA page_size = 4096",
            
            // 启用外键约束
            "PRAGMA foreign_keys = ON",
            
            // 设置自动清理
            "PRAGMA auto_vacuum = INCREMENTAL",
        ];

        for pragma_sql in optimizations {
            if let Err(e) = conn.execute(pragma_sql, []) {
                warn!("数据库配置优化失败: {} - {}", pragma_sql, e);
            }
        }

        info!("数据库配置优化完成");
        Ok(())
    }

    /// 分析表统计信息
    pub fn analyze_tables(conn: &Connection) -> Result<()> {
        info!("开始分析表统计信息");

        let tables = vec![
            "workflow_templates",
            "workflow_execution_records", 
            "workflow_execution_environments",
        ];

        for table in tables {
            let analyze_sql = format!("ANALYZE {}", table);
            if let Err(e) = conn.execute(&analyze_sql, []) {
                warn!("分析表 {} 失败: {}", table, e);
            }
        }

        // 分析所有表
        if let Err(e) = conn.execute("ANALYZE", []) {
            warn!("全局表分析失败: {}", e);
        }

        info!("表统计信息分析完成");
        Ok(())
    }

    /// 清理数据库碎片
    pub fn vacuum_database(conn: &Connection) -> Result<()> {
        info!("开始清理数据库碎片");

        // 增量清理
        if let Err(e) = conn.execute("PRAGMA incremental_vacuum", []) {
            warn!("增量清理失败: {}", e);
        }

        info!("数据库碎片清理完成");
        Ok(())
    }

    /// 获取数据库统计信息
    pub fn get_database_stats(conn: &Connection) -> Result<DatabaseStats> {
        let mut stats = DatabaseStats::default();

        // 获取页面数量
        if let Ok(page_count) = conn.query_row("PRAGMA page_count", [], |row| {
            Ok(row.get::<_, i64>(0)?)
        }) {
            stats.total_pages = page_count;
        }

        // 获取页面大小
        if let Ok(page_size) = conn.query_row("PRAGMA page_size", [], |row| {
            Ok(row.get::<_, i64>(0)?)
        }) {
            stats.page_size = page_size;
        }

        // 计算数据库大小
        stats.database_size_mb = (stats.total_pages * stats.page_size) as f64 / (1024.0 * 1024.0);

        // 获取表统计信息
        stats.table_stats = Self::get_table_stats(conn)?;

        Ok(stats)
    }

    /// 获取表统计信息
    fn get_table_stats(conn: &Connection) -> Result<Vec<TableStats>> {
        let mut table_stats = Vec::new();

        let tables = vec![
            "workflow_templates",
            "workflow_execution_records",
            "workflow_execution_environments",
        ];

        for table_name in tables {
            let count_sql = format!("SELECT COUNT(*) FROM {}", table_name);
            let row_count = conn.query_row(&count_sql, [], |row| {
                Ok(row.get::<_, i64>(0)?)
            }).unwrap_or(0);

            table_stats.push(TableStats {
                table_name: table_name.to_string(),
                row_count,
            });
        }

        Ok(table_stats)
    }

    /// 检查索引使用情况
    pub fn check_index_usage(conn: &Connection) -> Result<Vec<IndexUsageStats>> {
        let mut usage_stats = Vec::new();

        // 查询索引信息
        let mut stmt = conn.prepare("SELECT name, tbl_name FROM sqlite_master WHERE type = 'index' AND name NOT LIKE 'sqlite_%'")?;
        let index_rows = stmt.query_map([], |row| {
            Ok((
                row.get::<_, String>(0)?, // index name
                row.get::<_, String>(1)?, // table name
            ))
        })?;

        for index_row in index_rows {
            if let Ok((index_name, table_name)) = index_row {
                usage_stats.push(IndexUsageStats {
                    index_name,
                    table_name,
                    is_used: true, // 简化实现，实际需要查询使用统计
                });
            }
        }

        Ok(usage_stats)
    }
}

/// 数据库统计信息
#[derive(Debug, Default)]
pub struct DatabaseStats {
    pub total_pages: i64,
    pub page_size: i64,
    pub database_size_mb: f64,
    pub table_stats: Vec<TableStats>,
}

/// 表统计信息
#[derive(Debug)]
pub struct TableStats {
    pub table_name: String,
    pub row_count: i64,
}

/// 索引使用统计
#[derive(Debug)]
pub struct IndexUsageStats {
    pub index_name: String,
    pub table_name: String,
    pub is_used: bool,
}
