// Fluid Block Model (FBM)
// 流体区块模型 - 动态调整区块大小和出块频率

use serde::{Deserialize, Serialize};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

/// 流体区块配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FluidBlockConfig {
    /// 最小出块间隔（毫秒）
    pub min_block_interval_ms: u64,
    
    /// 初始软上限（字节）
    pub initial_soft_limit: usize,
    
    /// 最大软上限（字节）
    pub max_soft_limit: usize,
    
    /// 软上限调整阈值（百分比，0-100）
    pub adjustment_threshold: u8,
    
    /// 软上限增长率（百分比，0-100）
    pub growth_rate: u8,
    
    /// 软上限收缩率（百分比，0-100）
    pub shrink_rate: u8,
    
    /// 调整窗口大小（区块数量）
    pub adjustment_window: usize,
}

impl Default for FluidBlockConfig {
    fn default() -> Self {
        Self {
            min_block_interval_ms: 100,     // 0.1秒
            initial_soft_limit: 1_000_000,  // 1MB
            max_soft_limit: 10_000_000,     // 10MB
            adjustment_threshold: 90,        // 90%
            growth_rate: 10,                 // 增长10%
            shrink_rate: 5,                  // 收缩5%
            adjustment_window: 10,           // 最近10个区块
        }
    }
}

/// 区块大小统计
#[derive(Debug, Clone)]
struct BlockSizeStats {
    /// 区块大小（字节）
    size: usize,
    /// 区块时间戳
    timestamp: u64,
}

/// 流体区块模型管理器
pub struct FluidBlockModel {
    /// 配置
    config: FluidBlockConfig,
    
    /// 当前软上限
    current_soft_limit: usize,
    
    /// 最近的区块统计
    recent_blocks: Vec<BlockSizeStats>,
    
    /// 上一个区块的时间戳
    last_block_time: u64,
    
    /// 待打包的交易总大小
    pending_tx_size: usize,
}

impl FluidBlockModel {
    /// 创建新的流体区块模型
    pub fn new(config: FluidBlockConfig) -> Self {
        Self {
            current_soft_limit: config.initial_soft_limit,
            config,
            recent_blocks: Vec::new(),
            last_block_time: 0,
            pending_tx_size: 0,
        }
    }

    /// 使用默认配置创建
    pub fn with_defaults() -> Self {
        Self::new(FluidBlockConfig::default())
    }

    /// 检查是否可以出块
    pub fn can_produce_block(&self) -> bool {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64;

        // 检查是否满足最小间隔
        let interval_ok = if self.last_block_time == 0 {
            true
        } else {
            now - self.last_block_time >= self.config.min_block_interval_ms
        };

        // 检查是否有待打包的交易
        let has_pending = self.pending_tx_size > 0;

        interval_ok && has_pending
    }

    /// 获取当前软上限
    pub fn get_soft_limit(&self) -> usize {
        self.current_soft_limit
    }

    /// 更新待打包交易大小
    pub fn update_pending_size(&mut self, size: usize) {
        self.pending_tx_size = size;
    }

    /// 记录新产生的区块
    pub fn record_block(&mut self, block_size: usize) {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64;

        // 记录区块统计
        self.recent_blocks.push(BlockSizeStats {
            size: block_size,
            timestamp: now,
        });

        // 只保留最近的N个区块
        if self.recent_blocks.len() > self.config.adjustment_window {
            self.recent_blocks.remove(0);
        }

        // 更新最后区块时间
        self.last_block_time = now;

        // 重置待打包交易大小
        self.pending_tx_size = 0;

        // 触发软上限调整
        self.adjust_soft_limit();
    }

    /// 调整软上限
    fn adjust_soft_limit(&mut self) {
        if self.recent_blocks.len() < self.config.adjustment_window {
            return; // 数据不足，不调整
        }

        // 计算平均区块大小
        let total_size: usize = self.recent_blocks.iter().map(|b| b.size).sum();
        let avg_size = total_size / self.recent_blocks.len();

        // 计算使用率
        let usage_rate = (avg_size * 100) / self.current_soft_limit;

        // 根据使用率调整软上限
        if usage_rate >= self.config.adjustment_threshold as usize {
            // 使用率高，增加软上限
            let increase = (self.current_soft_limit * self.config.growth_rate as usize) / 100;
            self.current_soft_limit = (self.current_soft_limit + increase)
                .min(self.config.max_soft_limit);
        } else if usage_rate < 50 {
            // 使用率低，减少软上限
            let decrease = (self.current_soft_limit * self.config.shrink_rate as usize) / 100;
            self.current_soft_limit = (self.current_soft_limit - decrease)
                .max(self.config.initial_soft_limit);
        }
    }

    /// 获取建议的出块时间
    pub fn get_suggested_block_time(&self) -> Duration {
        Duration::from_millis(self.config.min_block_interval_ms)
    }

    /// 获取统计信息
    pub fn get_stats(&self) -> FluidBlockStats {
        let avg_size = if !self.recent_blocks.is_empty() {
            let total: usize = self.recent_blocks.iter().map(|b| b.size).sum();
            total / self.recent_blocks.len()
        } else {
            0
        };

        let avg_interval = if self.recent_blocks.len() > 1 {
            let first = self.recent_blocks.first().unwrap().timestamp;
            let last = self.recent_blocks.last().unwrap().timestamp;
            let total_time = last - first;
            total_time / (self.recent_blocks.len() - 1) as u64
        } else {
            0
        };

        FluidBlockStats {
            current_soft_limit: self.current_soft_limit,
            avg_block_size: avg_size,
            avg_block_interval_ms: avg_interval,
            recent_blocks_count: self.recent_blocks.len(),
            pending_tx_size: self.pending_tx_size,
        }
    }

    /// 重置统计
    pub fn reset(&mut self) {
        self.recent_blocks.clear();
        self.current_soft_limit = self.config.initial_soft_limit;
        self.last_block_time = 0;
        self.pending_tx_size = 0;
    }
}

/// 流体区块统计信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FluidBlockStats {
    /// 当前软上限（字节）
    pub current_soft_limit: usize,
    
    /// 平均区块大小（字节）
    pub avg_block_size: usize,
    
    /// 平均出块间隔（毫秒）
    pub avg_block_interval_ms: u64,
    
    /// 最近区块数量
    pub recent_blocks_count: usize,
    
    /// 待打包交易大小（字节）
    pub pending_tx_size: usize,
}

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

    #[test]
    fn test_fbm_creation() {
        let fbm = FluidBlockModel::with_defaults();
        assert_eq!(fbm.get_soft_limit(), 1_000_000);
    }

    #[test]
    fn test_can_produce_block() {
        let mut fbm = FluidBlockModel::with_defaults();
        
        // 初始状态，没有待打包交易，不能出块
        assert!(!fbm.can_produce_block());
        
        // 添加待打包交易
        fbm.update_pending_size(1000);
        
        // 现在应该可以出块
        assert!(fbm.can_produce_block());
    }

    #[test]
    fn test_min_block_interval() {
        let mut config = FluidBlockConfig::default();
        config.min_block_interval_ms = 100;
        let mut fbm = FluidBlockModel::new(config);
        
        fbm.update_pending_size(1000);
        assert!(fbm.can_produce_block());
        
        // 记录一个区块
        fbm.record_block(1000);
        
        // 立即检查，应该不能出块（未满足最小间隔）
        fbm.update_pending_size(1000);
        assert!(!fbm.can_produce_block());
        
        // 等待最小间隔
        thread::sleep(Duration::from_millis(150));
        assert!(fbm.can_produce_block());
    }

    #[test]
    fn test_soft_limit_increase() {
        let mut config = FluidBlockConfig::default();
        config.adjustment_window = 3;
        config.adjustment_threshold = 90;
        config.growth_rate = 10;
        
        let mut fbm = FluidBlockModel::new(config);
        let initial_limit = fbm.get_soft_limit();
        
        // 记录多个接近软上限的区块
        for _ in 0..3 {
            thread::sleep(Duration::from_millis(150));
            fbm.update_pending_size(950_000);
            fbm.record_block(950_000); // 95%使用率
        }
        
        // 软上限应该增加
        assert!(fbm.get_soft_limit() > initial_limit);
    }

    #[test]
    fn test_soft_limit_decrease() {
        // 测试软上限不会低于initial_soft_limit
        let mut config = FluidBlockConfig::default();
        config.adjustment_window = 3;
        config.shrink_rate = 10;
        
        let mut fbm = FluidBlockModel::new(config);
        let initial_limit = fbm.get_soft_limit();
        
        // 记录多个小区块
        for _ in 0..5 {
            thread::sleep(Duration::from_millis(150));
            fbm.update_pending_size(100_000);
            fbm.record_block(100_000);
        }
        
        // 软上限不应该低于initial_soft_limit
        assert!(fbm.get_soft_limit() >= initial_limit);
    }

    #[test]
    fn test_soft_limit_bounds() {
        let mut config = FluidBlockConfig::default();
        config.adjustment_window = 3;
        config.initial_soft_limit = 1_000_000;
        config.max_soft_limit = 2_000_000;
        config.growth_rate = 50; // 50%增长
        
        let mut fbm = FluidBlockModel::new(config);
        
        // 记录多个大区块，触发多次增长
        for _ in 0..10 {
            thread::sleep(Duration::from_millis(150));
            fbm.update_pending_size(950_000);
            fbm.record_block(950_000);
        }
        
        // 软上限不应超过最大值
        assert!(fbm.get_soft_limit() <= 2_000_000);
    }

    #[test]
    fn test_stats() {
        let mut fbm = FluidBlockModel::with_defaults();
        
        // 记录一些区块
        for i in 1..=5 {
            thread::sleep(Duration::from_millis(150));
            fbm.update_pending_size(i * 100_000);
            fbm.record_block(i * 100_000);
        }
        
        let stats = fbm.get_stats();
        assert_eq!(stats.recent_blocks_count, 5);
        assert!(stats.avg_block_size > 0);
        assert!(stats.avg_block_interval_ms > 0);
    }

    #[test]
    fn test_reset() {
        let mut fbm = FluidBlockModel::with_defaults();
        
        fbm.update_pending_size(1000);
        fbm.record_block(1000);
        
        fbm.reset();
        
        let stats = fbm.get_stats();
        assert_eq!(stats.recent_blocks_count, 0);
        assert_eq!(stats.pending_tx_size, 0);
        assert_eq!(fbm.get_soft_limit(), 1_000_000);
    }

    #[test]
    fn test_pending_size_update() {
        let mut fbm = FluidBlockModel::with_defaults();
        
        fbm.update_pending_size(5000);
        let stats = fbm.get_stats();
        assert_eq!(stats.pending_tx_size, 5000);
        
        // 记录区块后应该重置
        fbm.record_block(5000);
        let stats = fbm.get_stats();
        assert_eq!(stats.pending_tx_size, 0);
    }
}


// === 流体区块模型高级功能 ===

/// 网络负载级别
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum NetworkLoad {
    /// 空闲（<30%）
    Idle,
    /// 正常（30-70%）
    Normal,
    /// 繁忙（70-90%）
    Busy,
    /// 拥塞（>90%）
    Congested,
}

/// 交易优先级
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub enum TransactionPriority {
    /// 低优先级
    Low = 1,
    /// 正常优先级
    Normal = 2,
    /// 高优先级
    High = 3,
    /// 紧急优先级
    Urgent = 4,
}

/// 拥塞控制策略
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CongestionControl {
    /// 拥塞阈值（百分比，0-100）
    pub congestion_threshold: u8,
    
    /// 拥塞时的最小Gas价格倍数
    pub min_gas_multiplier: f64,
    
    /// 是否启用优先级队列
    pub enable_priority_queue: bool,
    
    /// 最大待处理交易数
    pub max_pending_txs: usize,
}

impl Default for CongestionControl {
    fn default() -> Self {
        Self {
            congestion_threshold: 85,
            min_gas_multiplier: 1.5,
            enable_priority_queue: true,
            max_pending_txs: 10000,
        }
    }
}

/// 增强的流体区块模型
pub struct EnhancedFluidBlockModel {
    /// 基础流体区块模型
    base: FluidBlockModel,
    
    /// 拥塞控制配置
    congestion_control: CongestionControl,
    
    /// 当前网络负载
    current_load: NetworkLoad,
    
    /// 待处理交易数量（按优先级）
    pending_txs_by_priority: [usize; 4], // Low, Normal, High, Urgent
}

impl EnhancedFluidBlockModel {
    /// 创建增强的流体区块模型
    pub fn new(config: FluidBlockConfig, congestion_control: CongestionControl) -> Self {
        Self {
            base: FluidBlockModel::new(config),
            congestion_control,
            current_load: NetworkLoad::Idle,
            pending_txs_by_priority: [0; 4],
        }
    }
    
    /// 使用默认配置创建
    pub fn with_defaults() -> Self {
        Self::new(FluidBlockConfig::default(), CongestionControl::default())
    }
    
    /// 计算当前网络负载
    pub fn calculate_network_load(&self) -> NetworkLoad {
        let stats = self.base.get_stats();
        let usage_rate = if stats.current_soft_limit > 0 {
            (stats.avg_block_size * 100) / stats.current_soft_limit
        } else {
            0
        };
        
        match usage_rate {
            0..=30 => NetworkLoad::Idle,
            31..=70 => NetworkLoad::Normal,
            71..=90 => NetworkLoad::Busy,
            _ => NetworkLoad::Congested,
        }
    }
    
    /// 更新网络负载
    pub fn update_network_load(&mut self) {
        self.current_load = self.calculate_network_load();
    }
    
    /// 获取当前网络负载
    pub fn get_network_load(&self) -> NetworkLoad {
        self.current_load
    }
    
    /// 添加待处理交易
    pub fn add_pending_tx(&mut self, priority: TransactionPriority, size: usize) -> Result<(), String> {
        // 检查是否超过最大待处理交易数
        let total_pending: usize = self.pending_txs_by_priority.iter().sum();
        if total_pending >= self.congestion_control.max_pending_txs {
            return Err("达到最大待处理交易数".to_string());
        }
        
        // 根据优先级添加
        let priority_index = priority as usize - 1;
        self.pending_txs_by_priority[priority_index] += 1;
        
        // 更新基础模型的待处理大小
        let current_pending = self.base.get_stats().pending_tx_size;
        self.base.update_pending_size(current_pending + size);
        
        Ok(())
    }
    
    /// 获取建议的Gas价格倍数
    pub fn get_suggested_gas_multiplier(&self) -> f64 {
        match self.current_load {
            NetworkLoad::Idle => 1.0,
            NetworkLoad::Normal => 1.0,
            NetworkLoad::Busy => 1.2,
            NetworkLoad::Congested => self.congestion_control.min_gas_multiplier,
        }
    }
    
    /// 获取建议的出块策略
    pub fn get_block_production_strategy(&self) -> BlockProductionStrategy {
        match self.current_load {
            NetworkLoad::Idle => BlockProductionStrategy::Conservative,
            NetworkLoad::Normal => BlockProductionStrategy::Normal,
            NetworkLoad::Busy => BlockProductionStrategy::Aggressive,
            NetworkLoad::Congested => BlockProductionStrategy::Emergency,
        }
    }
    
    /// 检查是否应该出块（增强版）
    pub fn should_produce_block(&self) -> bool {
        // 基础检查
        if !self.base.can_produce_block() {
            return false;
        }
        
        // 根据网络负载和优先级决定
        match self.current_load {
            NetworkLoad::Idle | NetworkLoad::Normal => {
                // 正常情况，按基础模型决定
                true
            }
            NetworkLoad::Busy => {
                // 繁忙时，优先处理高优先级交易
                self.pending_txs_by_priority[2] > 0 || self.pending_txs_by_priority[3] > 0
            }
            NetworkLoad::Congested => {
                // 拥塞时，只处理紧急交易
                self.pending_txs_by_priority[3] > 0
            }
        }
    }
    
    /// 获取下一批应该打包的交易优先级
    pub fn get_next_batch_priority(&self) -> Vec<TransactionPriority> {
        let mut priorities = Vec::new();
        
        match self.current_load {
            NetworkLoad::Idle | NetworkLoad::Normal => {
                // 正常情况，按优先级顺序处理
                if self.pending_txs_by_priority[3] > 0 {
                    priorities.push(TransactionPriority::Urgent);
                }
                if self.pending_txs_by_priority[2] > 0 {
                    priorities.push(TransactionPriority::High);
                }
                if self.pending_txs_by_priority[1] > 0 {
                    priorities.push(TransactionPriority::Normal);
                }
                if self.pending_txs_by_priority[0] > 0 {
                    priorities.push(TransactionPriority::Low);
                }
            }
            NetworkLoad::Busy => {
                // 繁忙时，只处理高优先级和紧急
                if self.pending_txs_by_priority[3] > 0 {
                    priorities.push(TransactionPriority::Urgent);
                }
                if self.pending_txs_by_priority[2] > 0 {
                    priorities.push(TransactionPriority::High);
                }
            }
            NetworkLoad::Congested => {
                // 拥塞时，只处理紧急
                if self.pending_txs_by_priority[3] > 0 {
                    priorities.push(TransactionPriority::Urgent);
                }
            }
        }
        
        priorities
    }
    
    /// 记录区块生产（增强版）
    pub fn record_block_production(&mut self, block_size: usize, included_priorities: &[TransactionPriority]) {
        // 更新基础模型
        self.base.record_block(block_size);
        
        // 减少已打包的交易数量
        for priority in included_priorities {
            let priority_index = *priority as usize - 1;
            if self.pending_txs_by_priority[priority_index] > 0 {
                self.pending_txs_by_priority[priority_index] -= 1;
            }
        }
        
        // 更新网络负载
        self.update_network_load();
    }
    
    /// 获取增强统计信息
    pub fn get_enhanced_stats(&self) -> EnhancedFluidBlockStats {
        let base_stats = self.base.get_stats();
        
        EnhancedFluidBlockStats {
            base_stats,
            network_load: self.current_load,
            pending_low: self.pending_txs_by_priority[0],
            pending_normal: self.pending_txs_by_priority[1],
            pending_high: self.pending_txs_by_priority[2],
            pending_urgent: self.pending_txs_by_priority[3],
            suggested_gas_multiplier: self.get_suggested_gas_multiplier(),
        }
    }
}

/// 出块策略
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum BlockProductionStrategy {
    /// 保守策略（等待更多交易）
    Conservative,
    /// 正常策略
    Normal,
    /// 激进策略（快速出块）
    Aggressive,
    /// 紧急策略（只处理紧急交易）
    Emergency,
}

/// 增强的流体区块统计信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnhancedFluidBlockStats {
    /// 基础统计
    pub base_stats: FluidBlockStats,
    
    /// 当前网络负载
    pub network_load: NetworkLoad,
    
    /// 低优先级待处理交易数
    pub pending_low: usize,
    
    /// 正常优先级待处理交易数
    pub pending_normal: usize,
    
    /// 高优先级待处理交易数
    pub pending_high: usize,
    
    /// 紧急优先级待处理交易数
    pub pending_urgent: usize,
    
    /// 建议的Gas价格倍数
    pub suggested_gas_multiplier: f64,
}

#[cfg(test)]
mod enhanced_tests {
    use super::*;
    use std::thread;
    
    #[test]
    fn test_network_load_calculation() {
        let mut efbm = EnhancedFluidBlockModel::with_defaults();
        
        // 初始状态应该是空闲
        efbm.update_network_load();
        assert_eq!(efbm.get_network_load(), NetworkLoad::Idle);
        
        // 记录一些大区块，增加负载
        for _ in 0..5 {
            thread::sleep(Duration::from_millis(150));
            efbm.base.update_pending_size(800_000);
            efbm.base.record_block(800_000);
        }
        
        efbm.update_network_load();
        // 80%使用率应该是繁忙
        assert_eq!(efbm.get_network_load(), NetworkLoad::Busy);
    }
    
    #[test]
    fn test_priority_queue() {
        let mut efbm = EnhancedFluidBlockModel::with_defaults();
        
        // 添加不同优先级的交易
        assert!(efbm.add_pending_tx(TransactionPriority::Low, 1000).is_ok());
        assert!(efbm.add_pending_tx(TransactionPriority::Normal, 1000).is_ok());
        assert!(efbm.add_pending_tx(TransactionPriority::High, 1000).is_ok());
        assert!(efbm.add_pending_tx(TransactionPriority::Urgent, 1000).is_ok());
        
        let stats = efbm.get_enhanced_stats();
        assert_eq!(stats.pending_low, 1);
        assert_eq!(stats.pending_normal, 1);
        assert_eq!(stats.pending_high, 1);
        assert_eq!(stats.pending_urgent, 1);
    }
    
    #[test]
    fn test_congestion_control() {
        let mut efbm = EnhancedFluidBlockModel::with_defaults();
        
        // 模拟拥塞状态
        for _ in 0..5 {
            thread::sleep(Duration::from_millis(150));
            efbm.base.update_pending_size(950_000);
            efbm.base.record_block(950_000);
        }
        
        efbm.update_network_load();
        
        // 拥塞时，Gas倍数应该增加
        let multiplier = efbm.get_suggested_gas_multiplier();
        assert!(multiplier > 1.0);
        
        // 拥塞时，只处理紧急交易
        efbm.add_pending_tx(TransactionPriority::Low, 1000).ok();
        efbm.add_pending_tx(TransactionPriority::Urgent, 1000).ok();
        
        let priorities = efbm.get_next_batch_priority();
        assert_eq!(priorities.len(), 1);
        assert_eq!(priorities[0], TransactionPriority::Urgent);
    }
    
    #[test]
    fn test_block_production_strategy() {
        let mut efbm = EnhancedFluidBlockModel::with_defaults();
        
        // 空闲状态
        efbm.update_network_load();
        assert_eq!(efbm.get_block_production_strategy(), BlockProductionStrategy::Conservative);
        
        // 记录一些区块，增加负载
        for _ in 0..5 {
            thread::sleep(Duration::from_millis(150));
            efbm.base.update_pending_size(500_000);
            efbm.base.record_block(500_000);
        }
        
        efbm.update_network_load();
        assert_eq!(efbm.get_block_production_strategy(), BlockProductionStrategy::Normal);
    }
    
    #[test]
    fn test_max_pending_txs() {
        let mut config = FluidBlockConfig::default();
        let mut congestion_control = CongestionControl::default();
        congestion_control.max_pending_txs = 5;
        
        let mut efbm = EnhancedFluidBlockModel::new(config, congestion_control);
        
        // 添加5个交易应该成功
        for _ in 0..5 {
            assert!(efbm.add_pending_tx(TransactionPriority::Normal, 1000).is_ok());
        }
        
        // 第6个应该失败
        assert!(efbm.add_pending_tx(TransactionPriority::Normal, 1000).is_err());
    }
}