use serde::{Deserialize, Serialize};

// === 分析请求 ===

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalyzeRequest {
    pub analysis_type: AnalysisType,
    pub source_ref: String,
    pub options: AnalyzeOptions,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AnalysisType {
    LabReport,
    Trends,
    CheckupPlan,
    ReportSummary,
}

impl AnalysisType {
    pub fn as_str(&self) -> &str {
        match self {
            Self::LabReport => "lab_report",
            Self::Trends => "trend",
            Self::CheckupPlan => "checkup_plan",
            Self::ReportSummary => "report_summary",
        }
    }

    pub fn prompt_name(&self) -> &str {
        match self {
            Self::LabReport => "lab_report_interpretation",
            Self::Trends => "health_trend_analysis",
            Self::CheckupPlan => "personalized_checkup_plan",
            Self::ReportSummary => "report_summary_generation",
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalyzeOptions {
    pub detail_level: Option<String>,
    pub language: Option<String>,
}

impl Default for AnalyzeOptions {
    fn default() -> Self {
        Self {
            detail_level: Some("patient_friendly".into()),
            language: Some("zh-CN".into()),
        }
    }
}

// === AI Provider 请求/响应 ===

#[derive(Debug, Clone)]
pub struct GenerateRequest {
    pub system_prompt: String,
    pub user_prompt: String,
    pub model: String,
    pub temperature: f32,
    pub max_tokens: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GenerateResponse {
    pub content: String,
    pub model: String,
    pub input_tokens: u32,
    pub output_tokens: u32,
    pub duration_ms: u64,
}

// === SSE 事件 ===

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenUsage {
    pub input: u32,
    pub output: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum AnalysisSseEvent {
    #[serde(rename = "chunk")]
    Chunk { content: String, index: u32 },
    #[serde(rename = "metadata")]
    Metadata {
        model: String,
        tokens: TokenUsage,
        duration_ms: u64,
    },
    #[serde(rename = "done")]
    Done {
        analysis_id: uuid::Uuid,
        status: String,
    },
    #[serde(rename = "error")]
    Error { message: String },
}