//! 统一存储接口
//!
//! 提供 UnifiedStorage trait 和实现，用于抽象数据访问层

use crate::connection::DuckDbConnection;
use crate::error::DuckDbResult;
use crate::models::{
    CleanupResult, ContainerRecord, IdleContainerInfo, ProjectRecord, StorageStats,
};
use crate::repositories::{ContainerRepository, ProjectRepository};
use crate::schema::SchemaInitializer;
use shared_types::ServiceType;
use std::sync::Arc;

/// 统一存储接口
///
/// 提供高层次的数据访问抽象，隐藏底层实现细节
pub trait UnifiedStorage: Send + Sync {
    // ========== 容器操作 ==========

    /// 保存或更新容器
    fn save_container(&self, record: &ContainerRecord) -> DuckDbResult<()>;

    /// 获取容器
    fn get_container(&self, container_id: &str) -> DuckDbResult<Option<ContainerRecord>>;

    /// 删除容器
    fn delete_container(&self, container_id: &str) -> DuckDbResult<bool>;

    /// 检查容器是否存在
    fn container_exists(&self, container_id: &str) -> DuckDbResult<bool>;

    /// 更新容器活动时间
    fn update_container_activity(&self, container_id: &str) -> DuckDbResult<bool>;

    /// 使用指定时间更新容器活动时间（用于保持项目和容器时间一致）
    fn update_container_activity_with_time(
        &self,
        container_id: &str,
        time: chrono::DateTime<chrono::Utc>,
    ) -> DuckDbResult<bool>;

    /// 获取所有容器
    fn get_all_containers(&self) -> DuckDbResult<Vec<ContainerRecord>>;

    /// 按服务类型获取容器
    fn get_containers_by_service_type(
        &self,
        service_type: ServiceType,
    ) -> DuckDbResult<Vec<ContainerRecord>>;

    /// 查找闲置容器
    fn find_idle_containers(
        &self,
        idle_minutes: i64,
        protection_minutes: i64,
    ) -> DuckDbResult<Vec<IdleContainerInfo>>;

    // ========== 项目操作 ==========

    /// 保存或更新项目
    fn save_project(&self, record: &ProjectRecord) -> DuckDbResult<()>;

    /// 获取项目
    fn get_project(&self, project_id: &str) -> DuckDbResult<Option<ProjectRecord>>;

    /// 删除项目
    fn delete_project(&self, project_id: &str) -> DuckDbResult<bool>;

    /// 检查项目是否存在
    fn project_exists(&self, project_id: &str) -> DuckDbResult<bool>;

    /// 更新项目活动时间，返回实际更新使用的时间戳
    fn update_project_activity(
        &self,
        project_id: &str,
    ) -> DuckDbResult<Option<chrono::DateTime<chrono::Utc>>>;

    /// 获取所有项目
    fn get_all_projects(&self) -> DuckDbResult<Vec<ProjectRecord>>;

    /// 根据用户ID查找所有项目（ComputerAgentRunner模式）
    ///
    /// 返回该用户的所有项目记录，按最后活动时间倒序排列
    fn find_projects_by_user_id(&self, user_id: &str) -> DuckDbResult<Vec<ProjectRecord>>;

    /// 获取用户最新活跃项目的容器ID（ComputerAgentRunner核心用例）
    ///
    /// 在 ComputerAgentRunner 模式下，一个用户对应一个容器，
    /// 此方法返回该用户最近活跃项目关联的容器ID
    fn get_latest_container_id_by_user_id(&self, user_id: &str) -> DuckDbResult<Option<String>>;

    /// 获取 Pod 最新活跃项目的容器ID（共享容器模式）
    ///
    /// 在共享容器模式下，多个项目可能共享同一个容器（通过 pod_id 标识），
    /// 此方法返回该 Pod 下最近活跃项目关联的容器ID
    fn get_latest_container_id_by_pod_id(&self, pod_id: &str) -> DuckDbResult<Option<String>>;

    /// 根据 pod_id 查找所有项目（RCoder 共享容器模式）
    ///
    /// 返回该 Pod 下所有项目记录，按最后活动时间倒序排列
    fn find_projects_by_pod_id(&self, pod_id: &str) -> DuckDbResult<Vec<ProjectRecord>>;

    // ========== 会话操作 ==========

    /// 根据会话ID获取项目
    fn get_project_by_session(&self, session_id: &str) -> DuckDbResult<Option<ProjectRecord>>;

    /// 根据会话ID获取容器名称
    ///
    /// 与 `get_container_id_by_session` 不同，返回稳定的 `container_name`。
    /// 即使容器被重建，container_name 保持不变，可用于通过 Docker API 查询容器状态。
    fn get_container_name_by_session(&self, session_id: &str) -> DuckDbResult<Option<String>>;

    /// 更新会话
    fn update_session(&self, project_id: &str, session_id: &str) -> DuckDbResult<bool>;

    /// 清除会话（将 session_id 设置为 NULL）
    fn clear_session(&self, project_id: &str) -> DuckDbResult<bool>;

    /// 更新会话活动时间
    fn update_session_activity(&self, session_id: &str) -> DuckDbResult<bool>;

    // ========== 状态操作 ==========

    /// 原子更新 Agent 状态
    fn update_agent_status(
        &self,
        project_id: &str,
        status_code: i32,
        status_name: &str,
    ) -> DuckDbResult<bool>;

    // ========== 关联操作 ==========

    /// 根据容器ID获取关联的项目
    fn get_projects_by_container(&self, container_id: &str) -> DuckDbResult<Vec<ProjectRecord>>;

    /// 删除容器及其关联的项目
    fn delete_container_with_projects(&self, container_id: &str) -> DuckDbResult<(bool, usize)>;

    // ========== 清理操作 ==========

    /// 执行清理（删除闲置的容器和项目）
    fn cleanup(&self, idle_minutes: i64, protection_minutes: i64) -> DuckDbResult<CleanupResult>;

    // ========== 统计操作 ==========

    /// 获取存储统计信息
    fn get_stats(&self) -> DuckDbResult<StorageStats>;
}

/// DuckDB 统一存储实现
pub struct DuckDbStorage {
    conn: DuckDbConnection,
}

impl DuckDbStorage {
    /// 创建新的 DuckDB 存储
    pub fn new() -> DuckDbResult<Self> {
        let conn = DuckDbConnection::open_in_memory()?;
        SchemaInitializer::initialize(&conn)?;

        Ok(Self { conn })
    }

    /// 从现有连接创建存储
    pub fn from_connection(conn: DuckDbConnection) -> DuckDbResult<Self> {
        SchemaInitializer::initialize(&conn)?;
        Ok(Self { conn })
    }

    /// 获取容器 Repository
    ///
    /// 注意：返回的 Repository 共享同一个 `Arc<Mutex<Connection>>`，
    /// 确保并发访问时的线程安全。
    fn containers(&self) -> DuckDbResult<ContainerRepository> {
        Ok(ContainerRepository::new(self.conn.clone()))
    }

    /// 获取项目 Repository
    ///
    /// 注意：返回的 Repository 共享同一个 `Arc<Mutex<Connection>>`，
    /// 确保并发访问时的线程安全。
    fn projects(&self) -> DuckDbResult<ProjectRepository> {
        Ok(ProjectRepository::new(self.conn.clone()))
    }

    /// 执行原始 SQL 查询（仅用于调试）
    ///
    /// ⚠️ 此方法仅用于开发和调试目的
    pub fn execute_raw_query(
        &self,
        sql: &str,
    ) -> DuckDbResult<(Vec<String>, Vec<serde_json::Value>)> {
        self.conn.with_connection(|c| {
            let mut stmt = c.prepare(sql)?;
            let column_count = stmt.column_count();

            // 获取列名
            let columns: Vec<String> = (0..column_count)
                .map(|i| {
                    stmt.column_name(i)
                        .map_or("?".to_string(), |v| v.to_string())
                })
                .collect();

            // 执行查询并收集结果
            let mut rows: Vec<serde_json::Value> = Vec::new();
            let mut result_rows = stmt.query([])?;

            while let Some(row) = result_rows.next()? {
                let mut row_obj = serde_json::Map::new();
                for (i, col_name) in columns.iter().enumerate() {
                    // 尝试以字符串形式获取值
                    let value: serde_json::Value = if let Ok(v) = row.get::<_, String>(i) {
                        serde_json::Value::String(v)
                    } else if let Ok(v) = row.get::<_, i64>(i) {
                        serde_json::Value::Number(v.into())
                    } else if let Ok(v) = row.get::<_, f64>(i) {
                        if let Some(n) = serde_json::Number::from_f64(v) {
                            serde_json::Value::Number(n)
                        } else {
                            serde_json::Value::Null
                        }
                    } else if let Ok(v) = row.get::<_, bool>(i) {
                        serde_json::Value::Bool(v)
                    } else {
                        serde_json::Value::Null
                    };
                    row_obj.insert(col_name.clone(), value);
                }
                rows.push(serde_json::Value::Object(row_obj));
            }

            Ok((columns, rows))
        })
    }

    /// 获取 DuckDB 内存使用统计（用于调试和监控）
    ///
    /// 返回内存使用的详细信息，帮助定位内存问题
    pub fn get_memory_stats(&self) -> DuckDbResult<String> {
        self.conn.get_memory_stats()
    }
}

impl UnifiedStorage for DuckDbStorage {
    // ========== 容器操作 ==========

    fn save_container(&self, record: &ContainerRecord) -> DuckDbResult<()> {
        self.containers()?.upsert(record)
    }

    fn get_container(&self, container_id: &str) -> DuckDbResult<Option<ContainerRecord>> {
        self.containers()?.find_by_id(container_id)
    }

    fn delete_container(&self, container_id: &str) -> DuckDbResult<bool> {
        self.containers()?.delete(container_id)
    }

    fn container_exists(&self, container_id: &str) -> DuckDbResult<bool> {
        self.containers()?.exists(container_id)
    }

    fn update_container_activity(&self, container_id: &str) -> DuckDbResult<bool> {
        self.containers()?.update_activity(container_id)
    }

    fn update_container_activity_with_time(
        &self,
        container_id: &str,
        time: chrono::DateTime<chrono::Utc>,
    ) -> DuckDbResult<bool> {
        self.containers()?
            .update_activity_with_time(container_id, time)
    }

    fn get_all_containers(&self) -> DuckDbResult<Vec<ContainerRecord>> {
        self.containers()?.find_all()
    }

    fn get_containers_by_service_type(
        &self,
        service_type: ServiceType,
    ) -> DuckDbResult<Vec<ContainerRecord>> {
        self.containers()?.find_by_service_type(service_type)
    }

    fn find_idle_containers(
        &self,
        idle_minutes: i64,
        protection_minutes: i64,
    ) -> DuckDbResult<Vec<IdleContainerInfo>> {
        let mut idle_containers = self
            .containers()?
            .find_idle_containers(idle_minutes, protection_minutes)?;

        // 为每个闲置容器填充关联的项目ID
        let projects_repo = self.projects()?;
        for container in &mut idle_containers {
            let projects = projects_repo.find_by_container_id(&container.container_id)?;
            container.project_ids = projects.iter().map(|p| p.project_id.clone()).collect();
        }

        Ok(idle_containers)
    }

    // ========== 项目操作 ==========

    fn save_project(&self, record: &ProjectRecord) -> DuckDbResult<()> {
        self.projects()?.upsert(record)
    }

    fn get_project(&self, project_id: &str) -> DuckDbResult<Option<ProjectRecord>> {
        self.projects()?.find_by_id(project_id)
    }

    fn delete_project(&self, project_id: &str) -> DuckDbResult<bool> {
        self.projects()?.delete(project_id)
    }

    fn project_exists(&self, project_id: &str) -> DuckDbResult<bool> {
        self.projects()?.exists(project_id)
    }

    fn update_project_activity(
        &self,
        project_id: &str,
    ) -> DuckDbResult<Option<chrono::DateTime<chrono::Utc>>> {
        self.projects()?.update_activity(project_id)
    }

    fn get_all_projects(&self) -> DuckDbResult<Vec<ProjectRecord>> {
        self.projects()?.find_all()
    }

    fn find_projects_by_user_id(&self, user_id: &str) -> DuckDbResult<Vec<ProjectRecord>> {
        self.projects()?.find_projects_by_user_id(user_id)
    }

    fn get_latest_container_id_by_user_id(&self, user_id: &str) -> DuckDbResult<Option<String>> {
        self.projects()?.get_latest_container_id_by_user_id(user_id)
    }

    fn get_latest_container_id_by_pod_id(&self, pod_id: &str) -> DuckDbResult<Option<String>> {
        self.projects()?.get_latest_container_id_by_pod_id(pod_id)
    }

    fn find_projects_by_pod_id(&self, pod_id: &str) -> DuckDbResult<Vec<ProjectRecord>> {
        self.projects()?.find_projects_by_pod_id(pod_id)
    }

    // ========== 会话操作 ==========

    fn get_project_by_session(&self, session_id: &str) -> DuckDbResult<Option<ProjectRecord>> {
        self.projects()?.find_by_session_id(session_id)
    }

    fn get_container_name_by_session(&self, session_id: &str) -> DuckDbResult<Option<String>> {
        self.projects()?.get_container_name_by_session(session_id)
    }

    fn update_session(&self, project_id: &str, session_id: &str) -> DuckDbResult<bool> {
        self.projects()?.update_session(project_id, session_id)
    }

    fn clear_session(&self, project_id: &str) -> DuckDbResult<bool> {
        self.projects()?.clear_session(project_id)
    }

    /// 更新会话活动时间（同时也更新关联容器的活动时间）
    fn update_session_activity(&self, session_id: &str) -> DuckDbResult<bool> {
        let updated = self.projects()?.update_session_activity(session_id)?;

        // 如果会话活跃，同时也更新关联容器的活跃状态
        if updated {
            // 使用新方法直接通过 session_id 更新容器活动时间，无需获取 container_id
            let _ = self.containers()?.update_activity_by_session(session_id);
        }

        Ok(updated)
    }

    // ========== 状态操作 ==========

    fn update_agent_status(
        &self,
        project_id: &str,
        status_code: i32,
        status_name: &str,
    ) -> DuckDbResult<bool> {
        self.projects()?
            .update_status_atomic(project_id, status_code, status_name)
    }

    // ========== 关联操作 ==========

    fn get_projects_by_container(&self, container_id: &str) -> DuckDbResult<Vec<ProjectRecord>> {
        self.projects()?.find_by_container_id(container_id)
    }

    fn delete_container_with_projects(&self, container_id: &str) -> DuckDbResult<(bool, usize)> {
        // 先删除关联的项目
        let deleted_projects = self.projects()?.delete_by_container_id(container_id)?;

        // 再删除容器
        let container_deleted = self.containers()?.delete(container_id)?;

        Ok((container_deleted, deleted_projects))
    }

    // ========== 清理操作 ==========

    fn cleanup(&self, idle_minutes: i64, protection_minutes: i64) -> DuckDbResult<CleanupResult> {
        let mut result = CleanupResult::new();

        // 查找闲置容器
        let idle_containers = self.find_idle_containers(idle_minutes, protection_minutes)?;

        for container in idle_containers {
            // 删除容器及其关联的项目
            match self.delete_container_with_projects(&container.container_id) {
                Ok((container_deleted, projects_deleted)) => {
                    if container_deleted {
                        result.cleaned_containers += 1;
                    }
                    result.cleaned_projects += projects_deleted;
                }
                Err(e) => {
                    result.add_error(format!("failed to delete container {}: {}", container.container_id, e));
                }
            }
        }

        Ok(result)
    }

    // ========== 统计操作 ==========

    fn get_stats(&self) -> DuckDbResult<StorageStats> {
        let containers = self.containers()?;
        let projects = self.projects()?;

        let total_containers = containers.count()?;
        let total_projects = projects.count()?;
        let active_sessions = projects.count_active_sessions()?;
        let projects_by_service_type = projects.count_by_service_type()?;

        // 计算活跃和闲置容器
        let all_containers = containers.find_all()?;
        let idle_threshold_minutes = 30;

        let mut active_containers = 0;
        let mut idle_containers = 0;

        for container in &all_containers {
            if container.is_idle(idle_threshold_minutes) {
                idle_containers += 1;
            } else {
                active_containers += 1;
            }
        }

        Ok(StorageStats {
            total_containers,
            total_projects,
            active_sessions,
            active_containers,
            idle_containers,
            projects_by_service_type,
        })
    }
}

impl Clone for DuckDbStorage {
    fn clone(&self) -> Self {
        Self {
            conn: self.conn.clone(),
        }
    }
}

impl std::fmt::Debug for DuckDbStorage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DuckDbStorage").finish()
    }
}

/// 创建共享的 UnifiedStorage 实例
pub fn create_storage() -> DuckDbResult<Arc<dyn UnifiedStorage>> {
    Ok(Arc::new(DuckDbStorage::new()?))
}

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

    fn create_test_storage() -> DuckDbStorage {
        DuckDbStorage::new().unwrap()
    }

    #[test]
    fn test_container_crud() {
        let storage = create_test_storage();

        let record = ContainerRecord::new(
            "c1".to_string(),
            "container-1".to_string(),
            "127.0.0.1".to_string(),
            8080,
            8080,
            ServiceType::RCoder,
            "running".to_string(),
            "http://localhost:8080".to_string(),
        );

        // Create
        storage.save_container(&record).unwrap();

        // Read
        let found = storage.get_container("c1").unwrap();
        assert!(found.is_some());
        assert_eq!(found.unwrap().container_name, "container-1");

        // Update
        storage.update_container_activity("c1").unwrap();

        // Delete
        storage.delete_container("c1").unwrap();
        assert!(!storage.container_exists("c1").unwrap());
    }

    #[test]
    fn test_project_crud() {
        let storage = create_test_storage();

        let record = ProjectRecord::new("p1".to_string(), ServiceType::RCoder, "c1".to_string());

        // Create
        storage.save_project(&record).unwrap();

        // Read
        let found = storage.get_project("p1").unwrap();
        assert!(found.is_some());

        // Update
        storage.update_project_activity("p1").unwrap();

        // Delete
        storage.delete_project("p1").unwrap();
        assert!(!storage.project_exists("p1").unwrap());
    }

    #[test]
    fn test_session_operations() {
        let storage = create_test_storage();

        // 创建容器 (必须先创建容器,因为项目关联到容器)
        let container = ContainerRecord::new(
            "c1".to_string(),
            "container-1".to_string(),
            "127.0.0.1".to_string(),
            8080,
            8080,
            ServiceType::RCoder,
            "running".to_string(),
            "http://localhost:8080".to_string(),
        );
        storage.save_container(&container).unwrap();

        // 创建项目
        let record = ProjectRecord::new("p1".to_string(), ServiceType::RCoder, "c1".to_string());
        storage.save_project(&record).unwrap();

        // 更新会话
        storage.update_session("p1", "session-1").unwrap();

        // 通过会话ID查询
        let project = storage.get_project_by_session("session-1").unwrap();
        assert!(project.is_some());
        assert_eq!(project.unwrap().project_id, "p1");

        // 获取容器名称
        let container_name = storage.get_container_name_by_session("session-1").unwrap();
        assert_eq!(container_name, Some("container-1".to_string()));
    }

    #[test]
    fn test_delete_container_with_projects() {
        let storage = create_test_storage();

        // 创建容器
        let container = ContainerRecord::new(
            "c1".to_string(),
            "container-1".to_string(),
            "127.0.0.1".to_string(),
            8080,
            8080,
            ServiceType::RCoder,
            "running".to_string(),
            "http://localhost:8080".to_string(),
        );
        storage.save_container(&container).unwrap();

        // 创建多个关联项目
        for i in 1..=3 {
            let project =
                ProjectRecord::new(format!("p{}", i), ServiceType::RCoder, "c1".to_string());
            storage.save_project(&project).unwrap();
        }

        // 删除容器及关联项目
        let (container_deleted, projects_deleted) =
            storage.delete_container_with_projects("c1").unwrap();

        assert!(container_deleted);
        assert_eq!(projects_deleted, 3);

        // 验证数据已删除
        assert!(!storage.container_exists("c1").unwrap());
        assert!(!storage.project_exists("p1").unwrap());
    }

    #[test]
    fn test_get_stats() {
        let storage = create_test_storage();

        // 添加容器
        let container = ContainerRecord::new(
            "c1".to_string(),
            "container-1".to_string(),
            "127.0.0.1".to_string(),
            8080,
            8080,
            ServiceType::RCoder,
            "running".to_string(),
            "http://localhost:8080".to_string(),
        );
        storage.save_container(&container).unwrap();

        // 添加项目
        let project = ProjectRecord::new("p1".to_string(), ServiceType::RCoder, "c1".to_string());
        storage.save_project(&project).unwrap();

        // 添加会话
        storage.update_session("p1", "session-1").unwrap();

        let stats = storage.get_stats().unwrap();

        assert_eq!(stats.total_containers, 1);
        assert_eq!(stats.total_projects, 1);
        assert_eq!(stats.active_sessions, 1);
        assert_eq!(stats.active_containers, 1);
        assert_eq!(stats.idle_containers, 0);
    }
}