burncloud-database-client 0.1.1

// BurnCloud AI管理专用的Repository实现

use crate::{BaseRepository, QueryExecutor, QueryContext, QueryOptions};
use burncloud_database_core::error::DatabaseResult;
use crate::models::*;
use burncloud_database_core::error::DatabaseError;
use async_trait::async_trait;
use std::sync::Arc;
use chrono::{DateTime, Utc};
use uuid::Uuid;

/// AI模型管理Repository
pub struct AiModelRepository {
    pub base: BaseRepository<AiModel>,
}

impl AiModelRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "ai_models".to_string()),
        }
    }

    /// 根据状态查找模型
    pub async fn find_by_status(&self, status: ModelStatus, context: &QueryContext) -> DatabaseResult<Vec<AiModel>> {
        let query = "SELECT * FROM ai_models WHERE status = $1";
        let status_str = serde_json::to_string(&status)
            .map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
        let status_param = burncloud_database_impl::StringParam(status_str);
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&status_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut models = Vec::new();
        for row in result.rows {
            let model: AiModel = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            models.push(model);
        }

        Ok(models)
    }

    /// 根据模型类型查找
    pub async fn find_by_type(&self, model_type: ModelType, context: &QueryContext) -> DatabaseResult<Vec<AiModel>> {
        let query = "SELECT * FROM ai_models WHERE model_type = $1";
        let type_str = serde_json::to_string(&model_type)
            .map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
        let type_param = burncloud_database_impl::StringParam(type_str);
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&type_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut models = Vec::new();
        for row in result.rows {
            let model: AiModel = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            models.push(model);
        }

        Ok(models)
    }

    /// 搜索模型
    pub async fn search(&self, query_text: &str, context: &QueryContext) -> DatabaseResult<Vec<AiModel>> {
        let query = "SELECT * FROM ai_models WHERE name ILIKE $1 OR description ILIKE $1";
        let search_pattern = format!("%{}%", query_text);
        let search_param = burncloud_database_impl::StringParam(search_pattern);
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&search_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut models = Vec::new();
        for row in result.rows {
            let model: AiModel = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            models.push(model);
        }

        Ok(models)
    }
}

/// 模型部署Repository
pub struct ModelDeploymentRepository {
    pub base: BaseRepository<ModelDeployment>,
}

impl ModelDeploymentRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "model_deployments".to_string()),
        }
    }

    /// 根据模型ID查找部署
    pub async fn find_by_model_id(&self, model_id: Uuid, context: &QueryContext) -> DatabaseResult<Vec<ModelDeployment>> {
        let query = "SELECT * FROM model_deployments WHERE model_id = $1";
        let model_id_param = burncloud_database_impl::StringParam(model_id.to_string());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&model_id_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut deployments = Vec::new();
        for row in result.rows {
            let deployment: ModelDeployment = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            deployments.push(deployment);
        }

        Ok(deployments)
    }

    /// 根据状态查找部署
    pub async fn find_by_status(&self, status: DeploymentStatus, context: &QueryContext) -> DatabaseResult<Vec<ModelDeployment>> {
        let query = "SELECT * FROM model_deployments WHERE status = $1";
        let status_str = serde_json::to_string(&status)
            .map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
        let status_param = burncloud_database_impl::StringParam(status_str);
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&status_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut deployments = Vec::new();
        for row in result.rows {
            let deployment: ModelDeployment = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            deployments.push(deployment);
        }

        Ok(deployments)
    }

    /// 根据端口查找部署
    pub async fn find_by_port(&self, port: u16, context: &QueryContext) -> DatabaseResult<Option<ModelDeployment>> {
        let query = "SELECT * FROM model_deployments WHERE port = $1 LIMIT 1";
        let port_param = burncloud_database_impl::I64Param(port as i64);
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&port_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        if result.rows.is_empty() {
            Ok(None)
        } else {
            let deployment: ModelDeployment = serde_json::from_value(serde_json::Value::Object(
                result.rows[0].iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            Ok(Some(deployment))
        }
    }

    /// 获取运行中的部署
    pub async fn get_running_deployments(&self, context: &QueryContext) -> DatabaseResult<Vec<ModelDeployment>> {
        self.find_by_status(DeploymentStatus::Running, context).await
    }
}

/// 系统监控指标Repository
pub struct SystemMetricsRepository {
    pub base: BaseRepository<SystemMetrics>,
}

impl SystemMetricsRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "system_metrics".to_string()),
        }
    }

    /// 获取指定时间范围内的指标
    pub async fn find_by_time_range(
        &self,
        start_time: DateTime<Utc>,
        end_time: DateTime<Utc>,
        context: &QueryContext,
    ) -> DatabaseResult<Vec<SystemMetrics>> {
        let query = "SELECT * FROM system_metrics WHERE timestamp >= $1 AND timestamp <= $2 ORDER BY timestamp DESC";
        let start_param = burncloud_database_impl::StringParam(start_time.to_rfc3339());
        let end_param = burncloud_database_impl::StringParam(end_time.to_rfc3339());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&start_param, &end_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut metrics = Vec::new();
        for row in result.rows {
            let metric: SystemMetrics = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            metrics.push(metric);
        }

        Ok(metrics)
    }

    /// 获取最新的指标
    pub async fn get_latest(&self, context: &QueryContext) -> DatabaseResult<Option<SystemMetrics>> {
        let query = "SELECT * FROM system_metrics ORDER BY timestamp DESC LIMIT 1";
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        if result.rows.is_empty() {
            Ok(None)
        } else {
            let metric: SystemMetrics = serde_json::from_value(serde_json::Value::Object(
                result.rows[0].iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            Ok(Some(metric))
        }
    }

    /// 清理旧指标数据
    pub async fn cleanup_old_metrics(&self, before_time: DateTime<Utc>, context: &QueryContext) -> DatabaseResult<u64> {
        let query = "DELETE FROM system_metrics WHERE timestamp < $1";
        let time_param = burncloud_database_impl::StringParam(before_time.to_rfc3339());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&time_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;
        Ok(result.rows_affected)
    }
}

/// 模型性能指标Repository
pub struct ModelMetricsRepository {
    pub base: BaseRepository<ModelMetrics>,
}

impl ModelMetricsRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "model_metrics".to_string()),
        }
    }

    /// 根据部署ID获取指标
    pub async fn find_by_deployment_id(
        &self,
        deployment_id: Uuid,
        start_time: DateTime<Utc>,
        end_time: DateTime<Utc>,
        context: &QueryContext,
    ) -> DatabaseResult<Vec<ModelMetrics>> {
        let query = "SELECT * FROM model_metrics WHERE deployment_id = $1 AND timestamp >= $2 AND timestamp <= $3 ORDER BY timestamp DESC";
        let deployment_param = burncloud_database_impl::StringParam(deployment_id.to_string());
        let start_param = burncloud_database_impl::StringParam(start_time.to_rfc3339());
        let end_param = burncloud_database_impl::StringParam(end_time.to_rfc3339());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&deployment_param, &start_param, &end_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut metrics = Vec::new();
        for row in result.rows {
            let metric: ModelMetrics = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            metrics.push(metric);
        }

        Ok(metrics)
    }

    /// 获取部署的最新指标
    pub async fn get_latest_for_deployment(&self, deployment_id: Uuid, context: &QueryContext) -> DatabaseResult<Option<ModelMetrics>> {
        let query = "SELECT * FROM model_metrics WHERE deployment_id = $1 ORDER BY timestamp DESC LIMIT 1";
        let deployment_param = burncloud_database_impl::StringParam(deployment_id.to_string());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&deployment_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        if result.rows.is_empty() {
            Ok(None)
        } else {
            let metric: ModelMetrics = serde_json::from_value(serde_json::Value::Object(
                result.rows[0].iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            Ok(Some(metric))
        }
    }
}

/// 请求日志Repository
pub struct RequestLogRepository {
    pub base: BaseRepository<RequestLog>,
}

impl RequestLogRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "request_logs".to_string()),
        }
    }

    /// 根据部署ID获取日志
    pub async fn find_by_deployment_id(
        &self,
        deployment_id: Uuid,
        start_time: DateTime<Utc>,
        end_time: DateTime<Utc>,
        context: &QueryContext,
    ) -> DatabaseResult<Vec<RequestLog>> {
        let query = "SELECT * FROM request_logs WHERE deployment_id = $1 AND timestamp >= $2 AND timestamp <= $3 ORDER BY timestamp DESC";
        let deployment_param = burncloud_database_impl::StringParam(deployment_id.to_string());
        let start_param = burncloud_database_impl::StringParam(start_time.to_rfc3339());
        let end_param = burncloud_database_impl::StringParam(end_time.to_rfc3339());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&deployment_param, &start_param, &end_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut logs = Vec::new();
        for row in result.rows {
            let log: RequestLog = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            logs.push(log);
        }

        Ok(logs)
    }

    /// 获取错误日志
    pub async fn find_errors(
        &self,
        start_time: DateTime<Utc>,
        end_time: DateTime<Utc>,
        context: &QueryContext,
    ) -> DatabaseResult<Vec<RequestLog>> {
        let query = "SELECT * FROM request_logs WHERE status_code >= 400 AND timestamp >= $1 AND timestamp <= $2 ORDER BY timestamp DESC";
        let start_param = burncloud_database_impl::StringParam(start_time.to_rfc3339());
        let end_param = burncloud_database_impl::StringParam(end_time.to_rfc3339());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&start_param, &end_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        let mut logs = Vec::new();
        for row in result.rows {
            let log: RequestLog = serde_json::from_value(serde_json::Value::Object(
                row.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            logs.push(log);
        }

        Ok(logs)
    }
}

/// 用户设置Repository
pub struct UserSettingsRepository {
    pub base: BaseRepository<UserSettings>,
}

impl UserSettingsRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "user_settings".to_string()),
        }
    }

    /// 根据用户ID获取设置
    pub async fn find_by_user_id(&self, user_id: &str, context: &QueryContext) -> DatabaseResult<Option<UserSettings>> {
        let query = "SELECT * FROM user_settings WHERE user_id = $1 LIMIT 1";
        let user_param = burncloud_database_impl::StringParam(user_id.to_string());
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&user_param];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        if result.rows.is_empty() {
            Ok(None)
        } else {
            let settings: UserSettings = serde_json::from_value(serde_json::Value::Object(
                result.rows[0].iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            Ok(Some(settings))
        }
    }
}

/// 安全配置Repository
pub struct SecurityConfigRepository {
    pub base: BaseRepository<SecurityConfig>,
}

impl SecurityConfigRepository {
    pub fn new(query_executor: Box<dyn QueryExecutor>) -> Self {
        Self {
            base: BaseRepository::new(query_executor, "security_configs".to_string()),
        }
    }

    /// 获取当前安全配置
    pub async fn get_current(&self, context: &QueryContext) -> DatabaseResult<Option<SecurityConfig>> {
        let query = "SELECT * FROM security_configs ORDER BY created_at DESC LIMIT 1";
        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![];

        let result = self.base.query_executor.execute_query(query, &params, context).await?;

        if result.rows.is_empty() {
            Ok(None)
        } else {
            let config: SecurityConfig = serde_json::from_value(serde_json::Value::Object(
                result.rows[0].iter().map(|(k, v)| (k.clone(), v.clone())).collect()
            )).map_err(|e| DatabaseError::SerializationError(e.to_string()))?;
            Ok(Some(config))
        }
    }
}