//! 历史跟踪系统
//! 
//! 提供估值历史记录、趋势分析、数据可视化和导出功能

use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use anyhow::{Result, Context};
use std::collections::VecDeque;
use chrono::{DateTime, Utc};
use std::fs::File;
use std::io::Write;
use std::path::Path;

use crate::{FinalValuationResult, Jurisdiction, InternationalAgreement};

/// 历史记录条目
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValuationHistoryEntry {
    /// 资产ID
    pub asset_id: String,
    /// 辖区
    pub jurisdiction: Jurisdiction,
    /// 国际协定
    pub agreement: InternationalAgreement,
    /// 估值结果
    pub result: FinalValuationResult,
    /// 记录时间
    pub timestamp: DateTime<Utc>,
    /// 用户ID（可选）
    pub user_id: Option<String>,
    /// 备注（可选）
    pub notes: Option<String>,
}

impl ValuationHistoryEntry {
    /// 创建新的历史记录
    pub fn new(
        asset_id: String,
        jurisdiction: Jurisdiction,
        agreement: InternationalAgreement,
        result: FinalValuationResult,
    ) -> Self {
        Self {
            asset_id,
            jurisdiction,
            agreement,
            result,
            timestamp: Utc::now(),
            user_id: None,
            notes: None,
        }
    }

    /// 设置用户ID
    pub fn with_user_id(mut self, user_id: String) -> Self {
        self.user_id = Some(user_id);
        self
    }

    /// 设置备注
    pub fn with_notes(mut self, notes: String) -> Self {
        self.notes = Some(notes);
        self
    }
}

/// 历史记录存储
pub struct ValuationHistory {
    /// 内存存储（最近的记录）
    memory_storage: VecDeque<ValuationHistoryEntry>,
    /// 最大内存记录数
    max_memory_entries: usize,
    /// 持久化文件路径
    persistence_path: Option<String>,
}

impl ValuationHistory {
    /// 创建新的历史记录存储
    pub fn new(max_memory_entries: usize) -> Self {
        Self {
            memory_storage: VecDeque::new(),
            max_memory_entries,
            persistence_path: None,
        }
    }

    /// 设置持久化路径
    pub fn with_persistence(mut self, path: String) -> Self {
        self.persistence_path = Some(path);
        self
    }

    /// 添加历史记录
    pub fn add(&mut self, entry: ValuationHistoryEntry) -> Result<()> {
        // 添加到内存存储
        self.memory_storage.push_back(entry.clone());
        
        // 如果超过最大数量，移除最旧的记录
        if self.memory_storage.len() > self.max_memory_entries {
            self.memory_storage.pop_front();
        }

        // 持久化到文件
        if let Some(ref path) = self.persistence_path {
            self.persist_entry(&entry, path)?;
        }

        Ok(())
    }

    /// 持久化单条记录到文件
    fn persist_entry(&self, entry: &ValuationHistoryEntry, path: &str) -> Result<()> {
        let mut file = std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(path)
            .context("打开持久化文件失败")?;

        let json = serde_json::to_string(entry)?;
        writeln!(file, "{}", json)?;

        Ok(())
    }

    /// 获取指定资产的所有历史记录
    pub fn get_by_asset(&self, asset_id: &str) -> Vec<ValuationHistoryEntry> {
        self.memory_storage
            .iter()
            .filter(|entry| entry.asset_id == asset_id)
            .cloned()
            .collect()
    }

    /// 获取指定时间范围内的历史记录
    pub fn get_by_time_range(
        &self,
        start: DateTime<Utc>,
        end: DateTime<Utc>,
    ) -> Vec<ValuationHistoryEntry> {
        self.memory_storage
            .iter()
            .filter(|entry| entry.timestamp >= start && entry.timestamp <= end)
            .cloned()
            .collect()
    }

    /// 获取最近N条记录
    pub fn get_recent(&self, count: usize) -> Vec<ValuationHistoryEntry> {
        self.memory_storage
            .iter()
            .rev()
            .take(count)
            .cloned()
            .collect()
    }

    /// 获取所有记录
    pub fn get_all(&self) -> Vec<ValuationHistoryEntry> {
        self.memory_storage.iter().cloned().collect()
    }

    /// 清空内存存储
    pub fn clear(&mut self) {
        self.memory_storage.clear();
    }

    /// 从持久化文件加载历史记录
    pub fn load_from_file(&mut self, path: &str) -> Result<usize> {
        let content = std::fs::read_to_string(path)
            .context("读取持久化文件失败")?;

        let mut count = 0;
        for line in content.lines() {
            if line.trim().is_empty() {
                continue;
            }
            
            match serde_json::from_str::<ValuationHistoryEntry>(line) {
                Ok(entry) => {
                    self.memory_storage.push_back(entry);
                    count += 1;
                    
                    // 保持最大数量限制
                    if self.memory_storage.len() > self.max_memory_entries {
                        self.memory_storage.pop_front();
                    }
                }
                Err(e) => {
                    log::warn!("解析历史记录失败: {}", e);
                }
            }
        }

        Ok(count)
    }
}

/// 趋势分析结果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendAnalysis {
    /// 资产ID
    pub asset_id: String,
    /// 分析时间范围
    pub time_range: (DateTime<Utc>, DateTime<Utc>),
    /// 数据点数量
    pub data_points: usize,
    /// 平均估值
    pub average_valuation: Decimal,
    /// 最小估值
    pub min_valuation: Decimal,
    /// 最大估值
    pub max_valuation: Decimal,
    /// 标准差
    pub std_deviation: f64,
    /// 变化率（%）
    pub change_rate: f64,
    /// 趋势方向
    pub trend_direction: TrendDirection,
    /// 波动性
    pub volatility: f64,
    /// 置信度平均值
    pub avg_confidence: f64,
}

/// 趋势方向
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TrendDirection {
    /// 上升
    Upward,
    /// 下降
    Downward,
    /// 稳定
    Stable,
    /// 波动
    Volatile,
}

/// 趋势分析器
pub struct TrendAnalyzer;

impl TrendAnalyzer {
    /// 分析资产估值趋势
    pub fn analyze(entries: &[ValuationHistoryEntry]) -> Result<TrendAnalysis> {
        if entries.is_empty() {
            anyhow::bail!("没有历史数据可供分析");
        }

        let asset_id = entries[0].asset_id.clone();
        
        // 按时间排序
        let mut sorted_entries = entries.to_vec();
        sorted_entries.sort_by_key(|e| e.timestamp);

        let valuations: Vec<Decimal> = sorted_entries
            .iter()
            .map(|e| e.result.valuation_xtzh)
            .collect();

        let confidences: Vec<f64> = sorted_entries
            .iter()
            .map(|e| e.result.confidence)
            .collect();

        // 计算统计指标
        let average_valuation = Self::calculate_average(&valuations);
        let min_valuation = valuations.iter().min().expect("mainnet: handle error").clone();
        let max_valuation = valuations.iter().max().expect("mainnet: handle error").clone();
        let std_deviation = Self::calculate_std_deviation(&valuations, average_valuation);
        
        // 计算变化率
        let first_val = valuations.first().expect("mainnet: handle error");
        let last_val = valuations.last().expect("mainnet: handle error");
        let change_rate = if *first_val > Decimal::ZERO {
            ((*last_val - *first_val) / *first_val * Decimal::new(100, 0))
                .to_string()
                .parse::<f64>()
                .unwrap_or(0.0)
        } else {
            0.0
        };

        // 判断趋势方向
        let trend_direction = Self::determine_trend_direction(change_rate, std_deviation);

        // 计算波动性
        let volatility = Self::calculate_volatility(&valuations);

        // 计算平均置信度
        let avg_confidence = confidences.iter().sum::<f64>() / confidences.len() as f64;

        let time_range = (
            sorted_entries.first().expect("mainnet: handle error").timestamp,
            sorted_entries.last().expect("mainnet: handle error").timestamp,
        );

        Ok(TrendAnalysis {
            asset_id,
            time_range,
            data_points: entries.len(),
            average_valuation,
            min_valuation,
            max_valuation,
            std_deviation,
            change_rate,
            trend_direction,
            volatility,
            avg_confidence,
        })
    }

    /// 计算平均值
    fn calculate_average(values: &[Decimal]) -> Decimal {
        let sum: Decimal = values.iter().sum();
        sum / Decimal::new(values.len() as i64, 0)
    }

    /// 计算标准差
    fn calculate_std_deviation(values: &[Decimal], mean: Decimal) -> f64 {
        let variance: f64 = values
            .iter()
            .map(|v| {
                let diff = (*v - mean).to_string().parse::<f64>().unwrap_or(0.0);
                diff * diff
            })
            .sum::<f64>() / values.len() as f64;
        
        variance.sqrt()
    }

    /// 判断趋势方向
    fn determine_trend_direction(change_rate: f64, std_deviation: f64) -> TrendDirection {
        if std_deviation > 1000.0 {
            TrendDirection::Volatile
        } else if change_rate > 5.0 {
            TrendDirection::Upward
        } else if change_rate < -5.0 {
            TrendDirection::Downward
        } else {
            TrendDirection::Stable
        }
    }

    /// 计算波动性
    fn calculate_volatility(values: &[Decimal]) -> f64 {
        if values.len() < 2 {
            return 0.0;
        }

        let returns: Vec<f64> = values
            .windows(2)
            .map(|w| {
                let prev = w[0].to_string().parse::<f64>().unwrap_or(1.0);
                let curr = w[1].to_string().parse::<f64>().unwrap_or(1.0);
                (curr - prev) / prev
            })
            .collect();

        let mean_return = returns.iter().sum::<f64>() / returns.len() as f64;
        let variance = returns
            .iter()
            .map(|r| (r - mean_return).powi(2))
            .sum::<f64>() / returns.len() as f64;

        variance.sqrt()
    }
}

/// 数据导出器
pub struct DataExporter;

impl DataExporter {
    /// 导出为JSON格式
    pub fn export_json(entries: &[ValuationHistoryEntry], path: &Path) -> Result<()> {
        let json = serde_json::to_string_pretty(entries)?;
        let mut file = File::create(path)?;
        file.write_all(json.as_bytes())?;
        Ok(())
    }

    /// 导出为CSV格式
    pub fn export_csv(entries: &[ValuationHistoryEntry], path: &Path) -> Result<()> {
        let mut file = File::create(path)?;
        
        // 写入CSV头
        writeln!(
            file,
            "Timestamp,Asset ID,Jurisdiction,Agreement,Valuation (XTZH),Confidence,Requires Review,Notes"
        )?;

        // 写入数据行
        for entry in entries {
            writeln!(
                file,
                "{},{},{:?},{:?},{},{},{},{}",
                entry.timestamp.to_rfc3339(),
                entry.asset_id,
                entry.jurisdiction,
                entry.agreement,
                entry.result.valuation_xtzh,
                entry.result.confidence,
                entry.result.requires_human_review,
                entry.notes.as_deref().unwrap_or(""),
            )?;
        }

        Ok(())
    }

    /// 导出为Markdown报告
    pub fn export_markdown(
        entries: &[ValuationHistoryEntry],
        trend: &TrendAnalysis,
        path: &Path,
    ) -> Result<()> {
        let mut file = File::create(path)?;

        writeln!(file, "# NAC资产估值历史报告\n")?;
        writeln!(file, "## 趋势分析\n")?;
        writeln!(file, "- **资产ID**: {}", trend.asset_id)?;
        writeln!(file, "- **数据点数量**: {}", trend.data_points)?;
        writeln!(file, "- **时间范围**: {} 至 {}", 
            trend.time_range.0.format("%Y-%m-%d %H:%M:%S"),
            trend.time_range.1.format("%Y-%m-%d %H:%M:%S")
        )?;
        writeln!(file, "- **平均估值**: {} XTZH", trend.average_valuation)?;
        writeln!(file, "- **估值范围**: {} - {} XTZH", trend.min_valuation, trend.max_valuation)?;
        writeln!(file, "- **标准差**: {:.2}", trend.std_deviation)?;
        writeln!(file, "- **变化率**: {:.2}%", trend.change_rate)?;
        writeln!(file, "- **趋势方向**: {:?}", trend.trend_direction)?;
        writeln!(file, "- **波动性**: {:.4}", trend.volatility)?;
        writeln!(file, "- **平均置信度**: {:.1}%\n", trend.avg_confidence * 100.0)?;

        writeln!(file, "## 历史记录\n")?;
        writeln!(file, "| 时间 | 估值 (XTZH) | 置信度 | 需要审核 |")?;
        writeln!(file, "|------|-------------|--------|----------|")?;

        for entry in entries {
            writeln!(
                file,
                "| {} | {} | {:.1}% | {} |",
                entry.timestamp.format("%Y-%m-%d %H:%M"),
                entry.result.valuation_xtzh,
                entry.result.confidence * 100.0,
                if entry.result.requires_human_review { "是" } else { "否" }
            )?;
        }

        Ok(())
    }

    /// 导出为HTML可视化报告
    pub fn export_html(
        entries: &[ValuationHistoryEntry],
        trend: &TrendAnalysis,
        path: &Path,
    ) -> Result<()> {
        let mut file = File::create(path)?;

        writeln!(file, "<!DOCTYPE html>")?;
        writeln!(file, "<html lang='zh-CN'>")?;
        writeln!(file, "<head>")?;
        writeln!(file, "    <meta charset='UTF-8'>")?;
        writeln!(file, "    <meta name='viewport' content='width=device-width, initial-scale=1.0'>")?;
        writeln!(file, "    <title>NAC资产估值历史报告</title>")?;
        writeln!(file, "    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>")?;
        writeln!(file, "    <style>")?;
        writeln!(file, "        body {{ font-family: Arial, sans-serif; margin: 20px; }}")?;
        writeln!(file, "        h1 {{ color: #333; }}")?;
        writeln!(file, "        .stats {{ display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; margin: 20px 0; }}")?;
        writeln!(file, "        .stat-card {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}")?;
        writeln!(file, "        .stat-label {{ font-size: 14px; color: #666; }}")?;
        writeln!(file, "        .stat-value {{ font-size: 24px; font-weight: bold; color: #333; }}")?;
        writeln!(file, "        canvas {{ max-width: 100%; height: 400px; }}")?;
        writeln!(file, "    </style>")?;
        writeln!(file, "</head>")?;
        writeln!(file, "<body>")?;
        writeln!(file, "    <h1>NAC资产估值历史报告</h1>")?;
        
        writeln!(file, "    <div class='stats'>")?;
        writeln!(file, "        <div class='stat-card'>")?;
        writeln!(file, "            <div class='stat-label'>平均估值</div>")?;
        writeln!(file, "            <div class='stat-value'>{} XTZH</div>", trend.average_valuation)?;
        writeln!(file, "        </div>")?;
        writeln!(file, "        <div class='stat-card'>")?;
        writeln!(file, "            <div class='stat-label'>变化率</div>")?;
        writeln!(file, "            <div class='stat-value'>{:.2}%</div>", trend.change_rate)?;
        writeln!(file, "        </div>")?;
        writeln!(file, "        <div class='stat-card'>")?;
        writeln!(file, "            <div class='stat-label'>平均置信度</div>")?;
        writeln!(file, "            <div class='stat-value'>{:.1}%</div>", trend.avg_confidence * 100.0)?;
        writeln!(file, "        </div>")?;
        writeln!(file, "    </div>")?;

        writeln!(file, "    <canvas id='valuationChart'></canvas>")?;
        
        writeln!(file, "    <script>")?;
        writeln!(file, "        const ctx = document.getElementById('valuationChart').getContext('2d');")?;
        writeln!(file, "        const chart = new Chart(ctx, {{")?;
        writeln!(file, "            type: 'line',")?;
        writeln!(file, "            data: {{")?;
        writeln!(file, "                labels: [")?;
        for entry in entries {
            writeln!(file, "                    '{}',", entry.timestamp.format("%m-%d %H:%M"))?;
        }
        writeln!(file, "                ],")?;
        writeln!(file, "                datasets: [{{")?;
        writeln!(file, "                    label: '估值 (XTZH)',")?;
        writeln!(file, "                    data: [")?;
        for entry in entries {
            writeln!(file, "                        {},", entry.result.valuation_xtzh)?;
        }
        writeln!(file, "                    ],")?;
        writeln!(file, "                    borderColor: 'rgb(75, 192, 192)',")?;
        writeln!(file, "                    tension: 0.1")?;
        writeln!(file, "                }}]")?;
        writeln!(file, "            }},")?;
        writeln!(file, "            options: {{")?;
        writeln!(file, "                responsive: true,")?;
        writeln!(file, "                plugins: {{")?;
        writeln!(file, "                    title: {{ display: true, text: '估值趋势图' }}")?;
        writeln!(file, "                }}")?;
        writeln!(file, "            }}")?;
        writeln!(file, "        }});")?;
        writeln!(file, "    </script>")?;
        writeln!(file, "</body>")?;
        writeln!(file, "</html>")?;

        Ok(())
    }
}

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

    fn create_test_entry(valuation: i64) -> ValuationHistoryEntry {
        ValuationHistoryEntry::new(
            "test_asset".to_string(),
            Jurisdiction::US,
            InternationalAgreement::WTO,
            FinalValuationResult {
                valuation_xtzh: Decimal::new(valuation, 0),
                confidence: 0.85,
                model_results: vec![],
                weights: HashMap::new(),
                is_anomaly: false,
                anomaly_report: None,
                divergence_report: "Test".to_string(),
                requires_human_review: false,
            },
        )
    }

    #[test]
    fn test_history_storage() {
        let mut history = ValuationHistory::new(10);
        
        let entry = create_test_entry(1000000);
        history.add(entry.clone()).expect("mainnet: handle error");

        let entries = history.get_by_asset("test_asset");
        assert_eq!(entries.len(), 1);
        assert_eq!(entries[0].result.valuation_xtzh, Decimal::new(1000000, 0));
    }

    #[test]
    fn test_trend_analysis() {
        let entries = vec![
            create_test_entry(1000000),
            create_test_entry(1050000),
            create_test_entry(1100000),
            create_test_entry(1150000),
        ];

        let trend = TrendAnalyzer::analyze(&entries).expect("mainnet: handle error");
        assert_eq!(trend.data_points, 4);
        assert!(trend.change_rate > 0.0); // 上升趋势
    }

    #[test]
    fn test_data_export_json() {
        let entries = vec![create_test_entry(1000000)];
        let path = Path::new("/tmp/test_export.json");
        
        let result = DataExporter::export_json(&entries, path);
        assert!(result.is_ok());
    }
}