//! ComfyUI V2 服务管理器
//! 统一管理所有 ComfyUI V2 相关服务的生命周期和依赖关系

use anyhow::{Result, anyhow};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{info, warn, error, debug};

use crate::business::services::{
    comfyui_v2_service::ComfyUIV2Service,
    realtime_monitor_v2::RealtimeMonitorV2,
    queue_manager::QueueManager,
    cache_manager::{CacheManager, CacheConfig},
    template_engine::TemplateEngine,
    comfyui_manager::ComfyUIManager,
};
use crate::data::repositories::comfyui_repository::ComfyUIRepository;
use crate::data::models::comfyui::ComfyUIConfig;

/// ComfyUI V2 服务管理器
/// 负责管理所有 ComfyUI V2 相关服务的生命周期
pub struct ComfyUIV2ServiceManager {
    /// 数据仓库
    repository: Arc<ComfyUIRepository>,
    /// 核心 ComfyUI V2 服务
    comfyui_service: Arc<ComfyUIV2Service>,
    /// 实时监控服务
    realtime_monitor: Arc<RealtimeMonitorV2>,
    /// 队列管理器
    queue_manager: Arc<QueueManager>,
    /// 缓存管理器
    cache_manager: Arc<CacheManager<String, serde_json::Value>>,
    /// 模板引擎
    template_engine: Arc<TemplateEngine>,
    /// 是否已初始化
    initialized: Arc<RwLock<bool>>,
    /// 是否正在运行
    running: Arc<RwLock<bool>>,
}

impl ComfyUIV2ServiceManager {
    /// 创建新的服务管理器
    pub fn new(repository: Arc<ComfyUIRepository>) -> Result<Self> {
        // 创建缓存管理器
        let cache_manager = Arc::new(CacheManager::new(CacheConfig::default()));
        
        // 创建 ComfyUI 管理器 - 使用默认配置
        let default_config = ComfyUIConfig {
            base_url: "http://127.0.0.1:8188".to_string(),
            timeout_seconds: 30,
            retry_attempts: 3,
            retry_delay_ms: 1000,
            enable_websocket: true,
            enable_cache: true,
            max_concurrency: 10,
            custom_headers: None,
        };
        let comfyui_manager = Arc::new(ComfyUIManager::new(default_config)?);
        let comfyui_manager_result = comfyui_manager;

        // 创建模板引擎
        let template_engine = Arc::new(TemplateEngine::new(repository.clone()));

        // 创建队列管理器
        let queue_manager = Arc::new(QueueManager::new(repository.clone(), None));

        // 创建实时监控服务
        let realtime_monitor = Arc::new(RealtimeMonitorV2::new(
            comfyui_manager_result.clone(),
            repository.clone(),
            None
        ));
        
        // 创建核心 ComfyUI V2 服务
        let comfyui_service = Arc::new(ComfyUIV2Service::new(
            repository.clone(),
            realtime_monitor.clone(),
            queue_manager.clone(),
            template_engine.clone(),
        ));

        Ok(Self {
            repository,
            comfyui_service,
            realtime_monitor,
            queue_manager,
            cache_manager,
            template_engine,
            initialized: Arc::new(RwLock::new(false)),
            running: Arc::new(RwLock::new(false)),
        })
    }

    /// 初始化所有服务
    pub async fn initialize(&self) -> Result<()> {
        info!("初始化 ComfyUI V2 服务管理器");

        // 检查是否已经初始化
        {
            let initialized = self.initialized.read().await;
            if *initialized {
                return Err(anyhow!("服务管理器已经初始化"));
            }
        }

        // 初始化缓存管理器
        if let Err(e) = self.cache_manager.start().await {
            error!("初始化缓存管理器失败: {}", e);
            return Err(anyhow!("初始化缓存管理器失败: {}", e));
        }

        // 初始化队列管理器
        if let Err(e) = self.queue_manager.start().await {
            error!("初始化队列管理器失败: {}", e);
            return Err(anyhow!("初始化队列管理器失败: {}", e));
        }

        // 标记为已初始化
        {
            let mut initialized = self.initialized.write().await;
            *initialized = true;
        }

        info!("ComfyUI V2 服务管理器初始化完成");
        Ok(())
    }

    /// 启动所有服务
    pub async fn start(&self) -> Result<()> {
        info!("启动 ComfyUI V2 服务管理器");

        // 检查是否已初始化
        {
            let initialized = self.initialized.read().await;
            if !*initialized {
                return Err(anyhow!("服务管理器未初始化"));
            }
        }

        // 检查是否已经在运行
        {
            let running = self.running.read().await;
            if *running {
                return Err(anyhow!("服务管理器已在运行"));
            }
        }

        // 启动实时监控服务
        if let Err(e) = self.realtime_monitor.start().await {
            warn!("启动实时监控服务失败: {}", e);
        }

        // 标记为运行中
        {
            let mut running = self.running.write().await;
            *running = true;
        }

        info!("ComfyUI V2 服务管理器启动完成");
        Ok(())
    }

    /// 停止所有服务
    pub async fn stop(&self) -> Result<()> {
        info!("停止 ComfyUI V2 服务管理器");

        // 停止 ComfyUI 服务
        if let Err(e) = self.comfyui_service.disconnect().await {
            warn!("停止 ComfyUI 服务失败: {}", e);
        }

        // 停止实时监控服务
        if let Err(e) = self.realtime_monitor.stop().await {
            warn!("停止实时监控服务失败: {}", e);
        }

        // 停止队列管理器
        if let Err(e) = self.queue_manager.stop().await {
            warn!("停止队列管理器失败: {}", e);
        }

        // 停止缓存管理器
        if let Err(e) = self.cache_manager.stop().await {
            warn!("停止缓存管理器失败: {}", e);
        }

        // 标记为停止
        {
            let mut running = self.running.write().await;
            *running = false;
        }

        info!("ComfyUI V2 服务管理器停止完成");
        Ok(())
    }

    /// 重启所有服务
    pub async fn restart(&self) -> Result<()> {
        info!("重启 ComfyUI V2 服务管理器");

        self.stop().await?;
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
        self.start().await?;

        info!("ComfyUI V2 服务管理器重启完成");
        Ok(())
    }

    /// 获取服务状态
    pub async fn get_service_status(&self) -> ServiceStatus {
        let initialized = *self.initialized.read().await;
        let running = *self.running.read().await;
        let comfyui_connected = self.comfyui_service.get_connection_status().await.connected;
        let realtime_monitor_running = self.realtime_monitor.is_running().await;
        let queue_manager_running = self.queue_manager.is_running().await;
        let cache_manager_running = self.cache_manager.is_running().await;

        ServiceStatus {
            initialized,
            running,
            comfyui_connected,
            realtime_monitor_running,
            queue_manager_running,
            cache_manager_running,
        }
    }

    // ==================== 服务访问器 ====================

    /// 获取 ComfyUI V2 服务
    pub fn get_comfyui_service(&self) -> Arc<ComfyUIV2Service> {
        self.comfyui_service.clone()
    }

    /// 获取实时监控服务
    pub fn get_realtime_monitor(&self) -> Arc<RealtimeMonitorV2> {
        self.realtime_monitor.clone()
    }

    /// 获取队列管理器
    pub fn get_queue_manager(&self) -> Arc<QueueManager> {
        self.queue_manager.clone()
    }

    /// 获取缓存管理器
    pub fn get_cache_manager(&self) -> Arc<CacheManager<String, serde_json::Value>> {
        self.cache_manager.clone()
    }

    /// 获取模板引擎
    pub fn get_template_engine(&self) -> Arc<TemplateEngine> {
        self.template_engine.clone()
    }

    /// 获取数据仓库
    pub fn get_repository(&self) -> Arc<ComfyUIRepository> {
        self.repository.clone()
    }

    /// 检查是否已初始化
    pub async fn is_initialized(&self) -> bool {
        *self.initialized.read().await
    }

    /// 检查是否正在运行
    pub async fn is_running(&self) -> bool {
        *self.running.read().await
    }

    /// 健康检查
    pub async fn health_check(&self) -> HealthCheckResult {
        let status = self.get_service_status().await;
        
        let mut issues = Vec::new();
        let mut score = 100;

        if !status.initialized {
            issues.push("服务管理器未初始化".to_string());
            score -= 50;
        }

        if !status.running {
            issues.push("服务管理器未运行".to_string());
            score -= 30;
        }

        if !status.comfyui_connected {
            issues.push("ComfyUI 服务未连接".to_string());
            score -= 20;
        }

        if !status.realtime_monitor_running {
            issues.push("实时监控服务未运行".to_string());
            score -= 10;
        }

        if !status.queue_manager_running {
            issues.push("队列管理器未运行".to_string());
            score -= 10;
        }

        if !status.cache_manager_running {
            issues.push("缓存管理器未运行".to_string());
            score -= 5;
        }

        let health_status = if score >= 90 {
            "excellent"
        } else if score >= 70 {
            "good"
        } else if score >= 50 {
            "fair"
        } else {
            "poor"
        };

        HealthCheckResult {
            status: health_status.to_string(),
            score,
            issues,
            timestamp: chrono::Utc::now().to_rfc3339(),
        }
    }
}

/// 服务状态
#[derive(Debug, Clone)]
pub struct ServiceStatus {
    pub initialized: bool,
    pub running: bool,
    pub comfyui_connected: bool,
    pub realtime_monitor_running: bool,
    pub queue_manager_running: bool,
    pub cache_manager_running: bool,
}

/// 健康检查结果
#[derive(Debug, Clone)]
pub struct HealthCheckResult {
    pub status: String,
    pub score: i32,
    pub issues: Vec<String>,
    pub timestamp: String,
}
