use async_trait::async_trait;
use chrono::Datelike;
use erp_core::crypto::{self as pii, PiiCrypto};
use erp_core::error::{AppError, AppResult};
use erp_core::health_provider::{
    AnomalyInfo, AppointmentSummaryDto, HealthDataProvider, HealthReportDto, LabItemDto,
    LabReportDto, MedicationSummaryDto, MetricTrendAnalysis, PatientSummaryDto, RegressionStats,
    ReportSectionDto, TimeRange, TrendAnalysisDto, TrendDirection, VitalSignDto,
};
use num_traits::ToPrimitive;
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QueryOrder, QuerySelect};
use uuid::Uuid;

use crate::entity::{
    appointment, diagnosis, health_record, lab_report, medication_record, patient, vital_signs,
};

pub struct HealthDataProviderImpl {
    pub db: sea_orm::DatabaseConnection,
    pub crypto: PiiCrypto,
}

fn compute_age_group(birth_date: Option<chrono::NaiveDate>) -> String {
    let Some(bd) = birth_date else {
        return "未知".to_string();
    };
    let age = chrono::Utc::now().date_naive().year() - bd.year();
    match age {
        a if a < 14 => "儿童",
        a if a < 36 => "青年",
        a if a < 56 => "中年",
        _ => "老年",
    }
    .to_string()
}

async fn find_patient(
    db: &sea_orm::DatabaseConnection,
    tenant_id: Uuid,
    patient_id: Uuid,
) -> AppResult<patient::Model> {
    patient::Entity::find_by_id(patient_id)
        .filter(patient::Column::TenantId.eq(tenant_id))
        .filter(patient::Column::DeletedAt.is_null())
        .one(db)
        .await?
        .ok_or_else(|| AppError::NotFound(format!("患者 {patient_id} 不存在")))
}

async fn find_lab_report(
    db: &sea_orm::DatabaseConnection,
    tenant_id: Uuid,
    report_id: Uuid,
) -> AppResult<lab_report::Model> {
    lab_report::Entity::find_by_id(report_id)
        .filter(lab_report::Column::TenantId.eq(tenant_id))
        .filter(lab_report::Column::DeletedAt.is_null())
        .one(db)
        .await?
        .ok_or_else(|| AppError::NotFound(format!("化验报告 {report_id} 不存在")))
}

fn parse_lab_items(items_json: &Option<serde_json::Value>) -> Vec<LabItemDto> {
    let Some(arr) = items_json.as_ref().and_then(|v| v.as_array()) else {
        return vec![];
    };
    arr.iter()
        .filter_map(|item| {
            // 兼容两种存储格式：item_name/name
            let name = item
                .get("item_name")
                .or_else(|| item.get("name"))?
                .as_str()?
                .to_string();

            // 兼容 value 为字符串或数字
            let value = item
                .get("value")
                .and_then(|v| v.as_f64())
                .or_else(|| item.get("value")?.as_str()?.parse::<f64>().ok())
                .unwrap_or(0.0);

            let unit = item
                .get("unit")
                .and_then(|v| v.as_str())
                .unwrap_or("")
                .to_string();

            // 兼容两种参考范围格式：reference_range(string) 或 reference_low/reference_high(number)
            let reference_range = item
                .get("reference_range")
                .and_then(|v| v.as_str())
                .map(|s| s.to_string())
                .unwrap_or_else(|| {
                    let low = item
                        .get("reference_low")
                        .and_then(|v| v.as_f64())
                        .map(|l| l.to_string());
                    let high = item
                        .get("reference_high")
                        .and_then(|v| v.as_f64())
                        .map(|h| h.to_string());
                    match (low, high) {
                        (Some(l), Some(h)) => format!("{l}-{h}"),
                        (Some(l), None) => format!(">={l}"),
                        (None, Some(h)) => format!("<={h}"),
                        _ => "-".to_string(),
                    }
                });

            let is_abnormal = item
                .get("is_abnormal")
                .and_then(|v| v.as_bool())
                .unwrap_or(false);

            Some(LabItemDto {
                name,
                value,
                unit,
                reference_range,
                is_abnormal,
            })
        })
        .collect()
}

fn report_type_to_department(report_type: &str) -> &str {
    match report_type {
        "kidney_function" => "肾内科",
        "blood_routine" => "血液科",
        "electrolyte" => "检验科",
        "liver_function" => "肝胆科",
        _ => "检验科",
    }
}

#[async_trait]
impl HealthDataProvider for HealthDataProviderImpl {
    async fn get_lab_report(&self, tenant_id: Uuid, report_id: Uuid) -> AppResult<LabReportDto> {
        let report = find_lab_report(&self.db, tenant_id, report_id).await?;
        let patient = find_patient(&self.db, tenant_id, report.patient_id).await?;

        // 解密 items：加密时存储为 Value::String(ciphertext)
        let kek = self.crypto.kek();
        let decrypted_items = report
            .items
            .as_ref()
            .and_then(|v| v.as_str())
            .and_then(|s| pii::decrypt(kek, s).ok())
            .and_then(|s| serde_json::from_str(&s).ok())
            .or(report.items.clone());

        Ok(LabReportDto {
            age_group: compute_age_group(patient.birth_date),
            sex: patient.gender.unwrap_or_else(|| "未知".to_string()),
            department: report_type_to_department(&report.report_type).to_string(),
            report_date: report.report_date.to_string(),
            items: parse_lab_items(&decrypted_items),
        })
    }

    async fn get_vital_signs(
        &self,
        tenant_id: Uuid,
        patient_id: Uuid,
        metrics: &[String],
        range: &TimeRange,
    ) -> AppResult<Vec<VitalSignDto>> {
        let _ = find_patient(&self.db, tenant_id, patient_id).await?;

        let start_date = range.start.date_naive();
        let end_date = range.end.date_naive();

        let records = vital_signs::Entity::find()
            .filter(vital_signs::Column::TenantId.eq(tenant_id))
            .filter(vital_signs::Column::PatientId.eq(patient_id))
            .filter(vital_signs::Column::DeletedAt.is_null())
            .filter(vital_signs::Column::RecordDate.gte(start_date))
            .filter(vital_signs::Column::RecordDate.lte(end_date))
            .order_by_asc(vital_signs::Column::RecordDate)
            .all(&self.db)
            .await?;

        let metric_extractors: [(&str, Box<dyn Fn(&vital_signs::Model) -> Option<f64>>); 8] = [
            (
                "systolic_bp_morning",
                Box::new(|r| r.systolic_bp_morning.map(|v| v as f64)),
            ),
            (
                "diastolic_bp_morning",
                Box::new(|r| r.diastolic_bp_morning.map(|v| v as f64)),
            ),
            ("heart_rate", Box::new(|r| r.heart_rate.map(|v| v as f64))),
            (
                "weight",
                Box::new(|r| r.weight.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            (
                "blood_sugar",
                Box::new(|r| r.blood_sugar.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            (
                "body_temperature",
                Box::new(|r| r.body_temperature.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            ("spo2", Box::new(|r| r.spo2.map(|v| v as f64))),
            (
                "urine_output_ml",
                Box::new(|r| r.urine_output_ml.map(|v| v as f64)),
            ),
        ];

        let mut result = Vec::new();

        for (metric_name, extractor) in &metric_extractors {
            if !metrics.is_empty() && !metrics.iter().any(|m| m == *metric_name) {
                continue;
            }

            let values: Vec<(String, f64)> = records
                .iter()
                .filter_map(|r| extractor(r).map(|v| (r.record_date.to_string(), v)))
                .collect();

            if values.is_empty() {
                continue;
            }

            let unit = match *metric_name {
                "systolic_bp_morning" | "diastolic_bp_morning" => "mmHg",
                "heart_rate" => "bpm",
                "weight" => "kg",
                "blood_sugar" => "mmol/L",
                "body_temperature" => "°C",
                "spo2" => "%",
                "urine_output_ml" => "ml",
                _ => "",
            };

            result.push(VitalSignDto {
                metric: metric_name.to_string(),
                values,
                unit: unit.to_string(),
            });
        }

        Ok(result)
    }

    async fn get_patient_summary(
        &self,
        tenant_id: Uuid,
        patient_id: Uuid,
    ) -> AppResult<PatientSummaryDto> {
        let patient = find_patient(&self.db, tenant_id, patient_id).await?;

        let diagnoses: Vec<String> = diagnosis::Entity::find()
            .filter(diagnosis::Column::TenantId.eq(tenant_id))
            .filter(diagnosis::Column::PatientId.eq(patient_id))
            .filter(diagnosis::Column::DeletedAt.is_null())
            .filter(diagnosis::Column::Status.eq("active"))
            .order_by_desc(diagnosis::Column::DiagnosedDate)
            .all(&self.db)
            .await?
            .iter()
            .map(|d| format!("{}({})", d.diagnosis_name, d.icd_code))
            .collect();

        let medications: Vec<String> = medication_record::Entity::find()
            .filter(medication_record::Column::TenantId.eq(tenant_id))
            .filter(medication_record::Column::PatientId.eq(patient_id))
            .filter(medication_record::Column::DeletedAt.is_null())
            .filter(medication_record::Column::IsCurrent.eq(true))
            .all(&self.db)
            .await?
            .iter()
            .map(|m| {
                let mut s = m.medication_name.clone();
                if let Some(ref dosage) = m.dosage {
                    s.push_str(&format!(" {dosage}"));
                }
                s
            })
            .collect();

        let family_history = patient
            .medical_history_summary
            .as_ref()
            .map(|h| {
                h.split('；')
                    .chain(h.split(';'))
                    .map(|s| s.trim().to_string())
                    .filter(|s| !s.is_empty())
                    .collect()
            })
            .unwrap_or_default();

        let last_checkup = health_record::Entity::find()
            .filter(health_record::Column::TenantId.eq(tenant_id))
            .filter(health_record::Column::PatientId.eq(patient_id))
            .filter(health_record::Column::DeletedAt.is_null())
            .order_by_desc(health_record::Column::RecordDate)
            .one(&self.db)
            .await?;

        let last_checkup_date = last_checkup
            .map(|r| r.record_date.to_string())
            .unwrap_or_else(|| "无".to_string());

        Ok(PatientSummaryDto {
            age_group: compute_age_group(patient.birth_date),
            sex: patient.gender.unwrap_or_else(|| "未知".to_string()),
            chronic_conditions: diagnoses,
            medications,
            family_history,
            last_checkup_date,
        })
    }

    async fn get_full_report(
        &self,
        tenant_id: Uuid,
        report_id: Uuid,
    ) -> AppResult<HealthReportDto> {
        let record = health_record::Entity::find_by_id(report_id)
            .filter(health_record::Column::TenantId.eq(tenant_id))
            .filter(health_record::Column::DeletedAt.is_null())
            .one(&self.db)
            .await?
            .ok_or_else(|| AppError::NotFound(format!("健康报告 {report_id} 不存在")))?;

        let patient = find_patient(&self.db, tenant_id, record.patient_id).await?;

        let mut sections = Vec::new();

        let findings: Vec<String> = record
            .overall_assessment
            .as_ref()
            .map(|a| {
                a.split('；')
                    .chain(a.split(';'))
                    .map(|s| s.trim().to_string())
                    .filter(|s| !s.is_empty())
                    .collect()
            })
            .unwrap_or_default();

        if !findings.is_empty() {
            sections.push(ReportSectionDto {
                title: "总体评估".to_string(),
                findings,
                abnormal_items: vec![],
            });
        }

        let report_diagnoses = diagnosis::Entity::find()
            .filter(diagnosis::Column::TenantId.eq(tenant_id))
            .filter(diagnosis::Column::PatientId.eq(record.patient_id))
            .filter(diagnosis::Column::DeletedAt.is_null())
            .filter(
                diagnosis::Column::HealthRecordId
                    .eq(report_id)
                    .or(diagnosis::Column::Status.eq("active")),
            )
            .all(&self.db)
            .await?;

        if !report_diagnoses.is_empty() {
            let (abnormal, findings): (Vec<_>, Vec<_>) =
                report_diagnoses.iter().partition(|d| d.status == "active");
            sections.push(ReportSectionDto {
                title: "诊断记录".to_string(),
                findings: findings
                    .iter()
                    .map(|d| {
                        format!(
                            "{}({}) — {}",
                            d.diagnosis_name, d.icd_code, d.diagnosed_date
                        )
                    })
                    .collect(),
                abnormal_items: abnormal
                    .iter()
                    .map(|d| format!("{}({})", d.diagnosis_name, d.icd_code))
                    .collect(),
            });
        }

        let lab_reports = lab_report::Entity::find()
            .filter(lab_report::Column::TenantId.eq(tenant_id))
            .filter(lab_report::Column::PatientId.eq(record.patient_id))
            .filter(lab_report::Column::DeletedAt.is_null())
            .filter(
                lab_report::Column::ReportDate.gte(record.record_date - chrono::Duration::days(30)),
            )
            .filter(lab_report::Column::ReportDate.lte(record.record_date))
            .order_by_desc(lab_report::Column::ReportDate)
            .all(&self.db)
            .await?;

        for lr in &lab_reports {
            let items = parse_lab_items(&lr.items);
            let abnormal: Vec<String> = items
                .iter()
                .filter(|i| i.is_abnormal)
                .map(|i| format!("{} {}{}", i.name, i.value, i.unit))
                .collect();
            let findings: Vec<String> = items
                .iter()
                .map(|i| format!("{}: {}{} ({})", i.name, i.value, i.unit, i.reference_range))
                .collect();
            if !findings.is_empty() {
                sections.push(ReportSectionDto {
                    title: format!("化验报告 — {} ({})", lr.report_type, lr.report_date),
                    findings,
                    abnormal_items: abnormal,
                });
            }
        }

        Ok(HealthReportDto {
            age_group: compute_age_group(patient.birth_date),
            sex: patient.gender.unwrap_or_else(|| "未知".to_string()),
            department: record.record_type.clone(),
            report_date: record.record_date.to_string(),
            sections,
        })
    }

    async fn get_trend_analysis_data(
        &self,
        tenant_id: Uuid,
        patient_id: Uuid,
        metrics: &[String],
        range: &TimeRange,
    ) -> AppResult<TrendAnalysisDto> {
        let _ = find_patient(&self.db, tenant_id, patient_id).await?;

        let start_date = range.start.date_naive();
        let end_date = range.end.date_naive();

        let records = vital_signs::Entity::find()
            .filter(vital_signs::Column::TenantId.eq(tenant_id))
            .filter(vital_signs::Column::PatientId.eq(patient_id))
            .filter(vital_signs::Column::DeletedAt.is_null())
            .filter(vital_signs::Column::RecordDate.gte(start_date))
            .filter(vital_signs::Column::RecordDate.lte(end_date))
            .order_by_asc(vital_signs::Column::RecordDate)
            .all(&self.db)
            .await?;

        let metric_extractors: [(&str, Box<dyn Fn(&vital_signs::Model) -> Option<f64>>); 8] = [
            (
                "systolic_bp_morning",
                Box::new(|r| r.systolic_bp_morning.map(|v| v as f64)),
            ),
            (
                "diastolic_bp_morning",
                Box::new(|r| r.diastolic_bp_morning.map(|v| v as f64)),
            ),
            ("heart_rate", Box::new(|r| r.heart_rate.map(|v| v as f64))),
            (
                "weight",
                Box::new(|r| r.weight.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            (
                "blood_sugar",
                Box::new(|r| r.blood_sugar.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            (
                "body_temperature",
                Box::new(|r| r.body_temperature.map(|v| v.to_f64().unwrap_or(0.0))),
            ),
            ("spo2", Box::new(|r| r.spo2.map(|v| v as f64))),
            (
                "urine_output_ml",
                Box::new(|r| r.urine_output_ml.map(|v| v as f64)),
            ),
        ];

        let mut metric_results = Vec::new();

        for (metric_name, extractor) in &metric_extractors {
            if !metrics.is_empty() && !metrics.iter().any(|m| m == *metric_name) {
                continue;
            }

            // 构建时间序列数据
            let time_series: Vec<(chrono::NaiveDate, f64)> = records
                .iter()
                .filter_map(|r| extractor(r).map(|v| (r.record_date, v)))
                .collect();

            let data_point_count = time_series.len();
            if data_point_count == 0 {
                continue;
            }

            // 线性回归
            let regression = crate::service::trend_stats::compute_linear_regression(&time_series)
                .map(|r| RegressionStats {
                    slope: r.slope,
                    intercept: r.intercept,
                    r_squared: r.r_squared,
                    direction: match r.direction {
                        crate::service::trend_stats::TrendDirection::Rising => {
                            TrendDirection::Rising
                        }
                        crate::service::trend_stats::TrendDirection::Falling => {
                            TrendDirection::Falling
                        }
                        crate::service::trend_stats::TrendDirection::Stable => {
                            TrendDirection::Stable
                        }
                    },
                    daily_change: r.daily_change,
                    period_change: r.period_change,
                });

            // 异常检测（使用 2.0 倍标准差阈值）
            let anomaly_points = crate::service::trend_stats::detect_anomalies(&time_series, 2.0);
            let anomalies: Vec<AnomalyInfo> = anomaly_points
                .into_iter()
                .map(|a| AnomalyInfo {
                    date: a.date.to_string(),
                    value: a.value,
                    mean: a.mean,
                    std_dev: a.std_dev,
                    deviation: a.deviation,
                })
                .collect();

            let unit = match *metric_name {
                "systolic_bp_morning" | "diastolic_bp_morning" => "mmHg",
                "heart_rate" => "bpm",
                "weight" => "kg",
                "blood_sugar" => "mmol/L",
                "body_temperature" => "°C",
                "spo2" => "%",
                "urine_output_ml" => "ml",
                _ => "",
            };

            metric_results.push(MetricTrendAnalysis {
                metric: metric_name.to_string(),
                unit: unit.to_string(),
                data_point_count,
                regression,
                anomalies,
            });
        }

        Ok(TrendAnalysisDto {
            patient_id,
            period_start: start_date.to_string(),
            period_end: end_date.to_string(),
            metrics: metric_results,
        })
    }

    async fn get_upcoming_appointments(
        &self,
        tenant_id: Uuid,
        patient_id: Uuid,
    ) -> AppResult<Vec<AppointmentSummaryDto>> {
        let _ = find_patient(&self.db, tenant_id, patient_id).await?;

        let today = chrono::Utc::now().date_naive();
        let records = appointment::Entity::find()
            .filter(appointment::Column::TenantId.eq(tenant_id))
            .filter(appointment::Column::PatientId.eq(patient_id))
            .filter(appointment::Column::DeletedAt.is_null())
            .filter(appointment::Column::AppointmentDate.gte(today))
            .filter(
                appointment::Column::Status
                    .is_in(vec!["scheduled".to_string(), "confirmed".to_string()]),
            )
            .order_by_asc(appointment::Column::AppointmentDate)
            .order_by_asc(appointment::Column::StartTime)
            .limit(10)
            .all(&self.db)
            .await?;

        let result = records
            .into_iter()
            .map(|r| AppointmentSummaryDto {
                id: r.id,
                department: r.appointment_type,
                doctor_name: r
                    .doctor_id
                    .map_or("待定".to_string(), |_| "医生".to_string()),
                scheduled_at: format!("{} {}", r.appointment_date, r.start_time),
                status: r.status,
            })
            .collect();

        Ok(result)
    }

    async fn get_medication_list(
        &self,
        tenant_id: Uuid,
        patient_id: Uuid,
    ) -> AppResult<Vec<MedicationSummaryDto>> {
        let _ = find_patient(&self.db, tenant_id, patient_id).await?;

        let records = medication_record::Entity::find()
            .filter(medication_record::Column::TenantId.eq(tenant_id))
            .filter(medication_record::Column::PatientId.eq(patient_id))
            .filter(medication_record::Column::DeletedAt.is_null())
            .filter(medication_record::Column::IsCurrent.eq(true))
            .all(&self.db)
            .await?;

        let result = records
            .into_iter()
            .map(|m| MedicationSummaryDto {
                name: m.medication_name,
                dosage: m.dosage.unwrap_or_default(),
                frequency: m.frequency.unwrap_or_default(),
            })
            .collect();

        Ok(result)
    }
}