//! 性能优化系统
//!
//! 实现完整的性能优化功能，包括存储优化、计算优化、Gas优化和并发处理

use std::collections::HashMap;
use std::sync::{Arc, Mutex, RwLock};

/// 存储优化器
#[derive(Debug)]
pub struct StorageOptimizer {
    /// 缓存
    cache: Arc<RwLock<HashMap<String, CachedValue>>>,
    /// 缓存大小限制
    max_cache_size: usize,
    /// 缓存命中次数
    cache_hits: Arc<Mutex<u64>>,
    /// 缓存未命中次数
    cache_misses: Arc<Mutex<u64>>,
}

/// 缓存值
#[derive(Debug, Clone)]
struct CachedValue {
    /// 值
    value: Vec<u8>,
    /// 过期时间
    expiry: u64,
    /// 访问次数
    access_count: u64,
}

impl StorageOptimizer {
    /// 创建新的存储优化器
    pub fn new(max_cache_size: usize) -> Self {
        Self {
            cache: Arc::new(RwLock::new(HashMap::new())),
            max_cache_size,
            cache_hits: Arc::new(Mutex::new(0)),
            cache_misses: Arc::new(Mutex::new(0)),
        }
    }

    /// 从缓存获取值
    pub fn get(&self, key: &str) -> Option<Vec<u8>> {
        let mut cache = self.cache.write().unwrap();
        
        if let Some(cached) = cache.get_mut(key) {
            // 检查是否过期
            if cached.expiry > Self::current_timestamp() {
                cached.access_count += 1;
                *self.cache_hits.lock().unwrap() += 1;
                return Some(cached.value.clone());
            } else {
                // 过期，移除
                cache.remove(key);
            }
        }

        *self.cache_misses.lock().unwrap() += 1;
        None
    }

    /// 设置缓存值
    pub fn set(&self, key: String, value: Vec<u8>, ttl: u64) {
        let mut cache = self.cache.write().unwrap();

        // 如果缓存已满，移除最少使用的项
        if cache.len() >= self.max_cache_size {
            self.evict_lru(&mut cache);
        }

        let cached = CachedValue {
            value,
            expiry: Self::current_timestamp() + ttl,
            access_count: 0,
        };

        cache.insert(key, cached);
    }

    /// 移除最少使用的缓存项
    fn evict_lru(&self, cache: &mut HashMap<String, CachedValue>) {
        if let Some((key, _)) = cache
            .iter()
            .min_by_key(|(_, v)| v.access_count)
        {
            let key = key.clone();
            cache.remove(&key);
        }
    }

    /// 清空缓存
    pub fn clear(&self) {
        self.cache.write().unwrap().clear();
    }

    /// 获取缓存统计
    pub fn get_cache_stats(&self) -> CacheStatistics {
        let hits = *self.cache_hits.lock().unwrap();
        let misses = *self.cache_misses.lock().unwrap();
        let total = hits + misses;
        let hit_rate = if total > 0 {
            (hits as f64 / total as f64) * 100.0
        } else {
            0.0
        };

        CacheStatistics {
            cache_size: self.cache.read().unwrap().len(),
            max_cache_size: self.max_cache_size,
            cache_hits: hits,
            cache_misses: misses,
            hit_rate,
        }
    }

    /// 获取当前时间戳
    fn current_timestamp() -> u64 {
        use std::time::{SystemTime, UNIX_EPOCH};
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs()
    }
}

/// 缓存统计
#[derive(Debug, Clone)]
pub struct CacheStatistics {
    /// 当前缓存大小
    pub cache_size: usize,
    /// 最大缓存大小
    pub max_cache_size: usize,
    /// 缓存命中次数
    pub cache_hits: u64,
    /// 缓存未命中次数
    pub cache_misses: u64,
    /// 命中率（百分比）
    pub hit_rate: f64,
}

/// 计算优化器
#[derive(Debug)]
pub struct ComputationOptimizer {
    /// 结果缓存
    result_cache: Arc<RwLock<HashMap<String, ComputationResult>>>,
}

/// 计算结果
#[derive(Debug, Clone)]
struct ComputationResult {
    /// 结果
    result: Vec<u8>,
    /// 计算时间（毫秒）
    computation_time_ms: u64,
}

impl ComputationOptimizer {
    /// 创建新的计算优化器
    pub fn new() -> Self {
        Self {
            result_cache: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    /// 执行计算（带缓存）
    pub fn compute<F>(&self, key: &str, computation: F) -> Vec<u8>
    where
        F: FnOnce() -> Vec<u8>,
    {
        // 检查缓存
        {
            let cache = self.result_cache.read().unwrap();
            if let Some(cached) = cache.get(key) {
                return cached.result.clone();
            }
        }

        // 执行计算
        let start = std::time::Instant::now();
        let result = computation();
        let computation_time_ms = start.elapsed().as_millis() as u64;

        // 缓存结果
        {
            let mut cache = self.result_cache.write().unwrap();
            cache.insert(
                key.to_string(),
                ComputationResult {
                    result: result.clone(),
                    computation_time_ms,
                },
            );
        }

        result
    }

    /// 清空计算缓存
    pub fn clear(&self) {
        self.result_cache.write().unwrap().clear();
    }
}

/// Gas优化器
#[derive(Debug)]
pub struct GasOptimizer {
    /// Gas价格
    gas_price: u64,
    /// Gas使用统计
    gas_usage: Arc<Mutex<HashMap<String, u64>>>,
}

impl GasOptimizer {
    /// 创建新的Gas优化器
    pub fn new(gas_price: u64) -> Self {
        Self {
            gas_price,
            gas_usage: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    /// 估算操作的Gas成本
    pub fn estimate_gas(&self, operation: &str) -> u64 {
        match operation {
            "transfer" => 21000,
            "mint" => 50000,
            "burn" => 30000,
            "create_partition" => 100000,
            "close_partition" => 50000,
            "authorize_operator" => 40000,
            "revoke_operator" => 30000,
            "batch_transfer" => 100000, // 基础成本，每个转账额外21000
            "batch_mint" => 150000,     // 基础成本，每个铸造额外50000
            "batch_burn" => 100000,     // 基础成本，每个销毁额外30000
            _ => 10000,
        }
    }

    /// 估算批量操作的Gas成本
    pub fn estimate_batch_gas(&self, operation: &str, count: usize) -> u64 {
        let base_gas = self.estimate_gas(operation);
        let per_item_gas = match operation {
            "batch_transfer" => 21000,
            "batch_mint" => 50000,
            "batch_burn" => 30000,
            _ => 0,
        };

        base_gas + (per_item_gas * count as u64)
    }

    /// 记录Gas使用
    pub fn record_gas_usage(&self, operation: String, gas_used: u64) {
        let mut usage = self.gas_usage.lock().unwrap();
        *usage.entry(operation).or_insert(0) += gas_used;
    }

    /// 获取Gas使用统计
    pub fn get_gas_statistics(&self) -> GasStatistics {
        let usage = self.gas_usage.lock().unwrap();
        let total_gas = usage.values().sum();
        let total_cost = total_gas * self.gas_price;

        GasStatistics {
            total_gas_used: total_gas,
            gas_price: self.gas_price,
            total_cost,
            operations: usage.clone(),
        }
    }

    /// 优化建议
    pub fn get_optimization_suggestions(&self) -> Vec<String> {
        let mut suggestions = Vec::new();
        let usage = self.gas_usage.lock().unwrap();

        // 检查批量操作使用情况
        let batch_operations = ["batch_transfer", "batch_mint", "batch_burn"];
        for op in &batch_operations {
            if usage.get(*op).unwrap_or(&0) == &0 {
                suggestions.push(format!(
                    "Consider using {} for multiple operations to save gas",
                    op
                ));
            }
        }

        // 检查高Gas操作
        for (op, gas) in usage.iter() {
            if *gas > 1000000 {
                suggestions.push(format!(
                    "Operation '{}' has high gas usage ({}), consider optimization",
                    op, gas
                ));
            }
        }

        suggestions
    }
}

/// Gas统计
#[derive(Debug, Clone)]
pub struct GasStatistics {
    /// 总Gas使用量
    pub total_gas_used: u64,
    /// Gas价格
    pub gas_price: u64,
    /// 总成本
    pub total_cost: u64,
    /// 各操作的Gas使用量
    pub operations: HashMap<String, u64>,
}

/// 并发处理器
#[derive(Debug)]
pub struct ConcurrentProcessor {
    /// 工作线程数
    worker_count: usize,
}

impl ConcurrentProcessor {
    /// 创建新的并发处理器
    pub fn new(worker_count: usize) -> Self {
        Self { worker_count }
    }

    /// 并发处理批量任务
    pub fn process_batch<T, F, R>(&self, items: Vec<T>, processor: F) -> Vec<R>
    where
        T: Send + Clone + 'static,
        F: Fn(T) -> R + Send + Sync + 'static,
        R: Send + 'static,
    {
        use std::sync::mpsc;
        use std::thread;

        let (tx, rx) = mpsc::channel();
        let processor = Arc::new(processor);
        let chunk_size = (items.len() + self.worker_count - 1) / self.worker_count;

        let mut handles = Vec::new();

        for chunk in items.chunks(chunk_size) {
            let tx = tx.clone();
            let processor = Arc::clone(&processor);
            let chunk = chunk.to_vec();

            let handle = thread::spawn(move || {
                for item in chunk {
                    let result = processor(item);
                    tx.send(result).unwrap();
                }
            });

            handles.push(handle);
        }

        drop(tx);

        // 等待所有线程完成
        for handle in handles {
            handle.join().unwrap();
        }

        // 收集结果
        rx.iter().collect()
    }
}

impl Default for ComputationOptimizer {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_storage_optimizer_cache() {
        let optimizer = StorageOptimizer::new(100);

        // 设置缓存
        optimizer.set("key1".to_string(), vec![1, 2, 3], 60);

        // 获取缓存
        let value = optimizer.get("key1");
        assert_eq!(value, Some(vec![1, 2, 3]));

        // 获取不存在的键
        let value = optimizer.get("key2");
        assert_eq!(value, None);
    }

    #[test]
    fn test_storage_optimizer_stats() {
        let optimizer = StorageOptimizer::new(100);

        optimizer.set("key1".to_string(), vec![1, 2, 3], 60);
        optimizer.get("key1");
        optimizer.get("key2");

        let stats = optimizer.get_cache_stats();
        assert_eq!(stats.cache_hits, 1);
        assert_eq!(stats.cache_misses, 1);
        assert_eq!(stats.hit_rate, 50.0);
    }

    #[test]
    fn test_computation_optimizer() {
        let optimizer = ComputationOptimizer::new();

        let mut call_count = 0;
        let computation = || {
            call_count += 1;
            vec![1, 2, 3]
        };

        // 第一次调用，执行计算
        let result1 = optimizer.compute("test", computation);
        assert_eq!(result1, vec![1, 2, 3]);

        // 第二次调用，使用缓存
        let result2 = optimizer.compute("test", || vec![4, 5, 6]);
        assert_eq!(result2, vec![1, 2, 3]); // 应该返回缓存的结果
    }

    #[test]
    fn test_gas_optimizer_estimate() {
        let optimizer = GasOptimizer::new(100);

        assert_eq!(optimizer.estimate_gas("transfer"), 21000);
        assert_eq!(optimizer.estimate_gas("mint"), 50000);
        assert_eq!(optimizer.estimate_gas("burn"), 30000);
    }

    #[test]
    fn test_gas_optimizer_batch_estimate() {
        let optimizer = GasOptimizer::new(100);

        // 批量转账10笔
        let gas = optimizer.estimate_batch_gas("batch_transfer", 10);
        assert_eq!(gas, 100000 + 21000 * 10);
    }

    #[test]
    fn test_gas_optimizer_statistics() {
        let optimizer = GasOptimizer::new(100);

        optimizer.record_gas_usage("transfer".to_string(), 21000);
        optimizer.record_gas_usage("mint".to_string(), 50000);

        let stats = optimizer.get_gas_statistics();
        assert_eq!(stats.total_gas_used, 71000);
        assert_eq!(stats.total_cost, 7100000);
    }

    #[test]
    fn test_gas_optimizer_suggestions() {
        let optimizer = GasOptimizer::new(100);

        // 记录一些操作
        optimizer.record_gas_usage("transfer".to_string(), 21000);

        let suggestions = optimizer.get_optimization_suggestions();
        assert!(!suggestions.is_empty());
    }

    #[test]
    fn test_concurrent_processor() {
        let processor = ConcurrentProcessor::new(4);

        let items: Vec<u32> = (0..100).collect();
        let results = processor.process_batch(items, |x| x * 2);

        assert_eq!(results.len(), 100);
        // 注意：由于并发处理，结果顺序可能不同
    }

    #[test]
    fn test_cache_eviction() {
        let optimizer = StorageOptimizer::new(2);

        // 添加3个项，应该触发LRU驱逐
        optimizer.set("key1".to_string(), vec![1], 60);
        optimizer.set("key2".to_string(), vec![2], 60);
        optimizer.set("key3".to_string(), vec![3], 60);

        // 缓存大小应该是2
        let stats = optimizer.get_cache_stats();
        assert_eq!(stats.cache_size, 2);
    }

    #[test]
    fn test_cache_expiry() {
        let optimizer = StorageOptimizer::new(100);

        // 设置一个立即过期的缓存
        optimizer.set("key1".to_string(), vec![1, 2, 3], 0);

        // 等待1秒
        std::thread::sleep(std::time::Duration::from_secs(1));

        // 应该无法获取（已过期）
        let value = optimizer.get("key1");
        assert_eq!(value, None);
    }
}