///! 分层碎片化管理器
///!
///! 实现多层级碎片化和跨层转换

use crate::primitives::Address;
use super::{FragmentLayer, LayerConfig};
use std::collections::HashMap;

/// 分层碎片化管理器
pub struct LayeredFragmentationManager {
    /// 资产的分层配置 (asset_address => (asset_id => layers))
    asset_layers: HashMap<Address, HashMap<u64, Vec<LayerConfig>>>,
    /// 层级转换比例 (from_layer, to_layer) => conversion_rate
    conversion_rates: HashMap<(FragmentLayer, FragmentLayer), u64>,
}

impl LayeredFragmentationManager {
    /// 创建新的分层碎片化管理器
    pub fn new() -> Self {
        let mut manager = Self {
            asset_layers: HashMap::new(),
            conversion_rates: HashMap::new(),
        };
        
        // 设置默认转换比例（1:1）
        manager.set_conversion_rate(FragmentLayer::L1Core, FragmentLayer::L2Trading, 1_000_000_000_000_000_000);
        manager.set_conversion_rate(FragmentLayer::L2Trading, FragmentLayer::L1Core, 1_000_000_000_000_000_000);
        manager.set_conversion_rate(FragmentLayer::L2Trading, FragmentLayer::L3Derivative, 1_000_000_000_000_000_000);
        manager.set_conversion_rate(FragmentLayer::L3Derivative, FragmentLayer::L2Trading, 1_000_000_000_000_000_000);
        
        manager
    }
    
    /// 设置层级转换比例
    pub fn set_conversion_rate(&mut self, from: FragmentLayer, to: FragmentLayer, rate: u64) {
        self.conversion_rates.insert((from, to), rate);
    }
    
    /// 获取层级转换比例
    pub fn get_conversion_rate(&self, from: FragmentLayer, to: FragmentLayer) -> u64 {
        self.conversion_rates
            .get(&(from, to))
            .copied()
            .unwrap_or(1_000_000_000_000_000_000) // 默认1:1
    }
    
    /// 创建分层碎片化
    pub fn create_layered_fragmentation(
        &mut self,
        asset_address: Address,
        asset_id: u64,
        layer_configs: Vec<LayerConfig>,
    ) -> Result<(), String> {
        // 验证至少有一层
        if layer_configs.is_empty() {
            return Err("At least one layer required".to_string());
        }
        
        // 验证层级唯一性
        let mut seen_layers = std::collections::HashSet::new();
        for config in &layer_configs {
            if !seen_layers.insert(config.layer) {
                return Err(format!("Duplicate layer: {:?}", config.layer));
            }
        }
        
        // 存储层级配置
        self.asset_layers
            .entry(asset_address)
            .or_insert_with(HashMap::new)
            .insert(asset_id, layer_configs);
        
        Ok(())
    }
    
    /// 获取资产的层级配置
    pub fn get_layer_configs(&self, asset_address: &Address, asset_id: u64) -> Option<&Vec<LayerConfig>> {
        self.asset_layers
            .get(asset_address)
            .and_then(|asset_map| asset_map.get(&asset_id))
    }
    
    /// 获取特定层级的配置
    pub fn get_layer_config(
        &self,
        asset_address: &Address,
        asset_id: u64,
        layer: FragmentLayer,
    ) -> Option<&LayerConfig> {
        self.get_layer_configs(asset_address, asset_id)?
            .iter()
            .find(|config| config.layer == layer)
    }
    
    /// 计算跨层转换数量
    pub fn calculate_conversion(
        &self,
        amount: u64,
        from_layer: FragmentLayer,
        to_layer: FragmentLayer,
    ) -> u64 {
        let rate = self.get_conversion_rate(from_layer, to_layer);
        let amount_128 = amount as u128;
        let rate_128 = rate as u128;
        let result = (amount_128 * rate_128) / 1_000_000_000_000_000_000u128;
        result as u64
    }
    
    /// 验证跨层转换是否可行
    pub fn can_convert(
        &self,
        asset_address: &Address,
        asset_id: u64,
        from_layer: FragmentLayer,
        to_layer: FragmentLayer,
    ) -> bool {
        // 获取两个层级的配置
        let from_config = self.get_layer_config(asset_address, asset_id, from_layer);
        let to_config = self.get_layer_config(asset_address, asset_id, to_layer);
        
        // 两个层级都必须存在且可组合
        from_config.map(|c| c.composable).unwrap_or(false) &&
        to_config.is_some()
    }
    
    /// 获取所有支持的层级
    pub fn get_supported_layers(&self, asset_address: &Address, asset_id: u64) -> Vec<FragmentLayer> {
        self.get_layer_configs(asset_address, asset_id)
            .map(|configs| configs.iter().map(|c| c.layer).collect())
            .unwrap_or_default()
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::l1_protocol::gnacs::{GNACSCode, AssetCategory, Jurisdiction, ComplianceLevel, RiskLevel};
    
    #[test]
    fn test_manager_creation() {
        let manager = LayeredFragmentationManager::new();
        
        // 验证默认转换比例
        assert_eq!(
            manager.get_conversion_rate(FragmentLayer::L1Core, FragmentLayer::L2Trading),
            1_000_000_000_000_000_000
        );
    }
    
    #[test]
    fn test_create_layered_fragmentation() {
        let mut manager = LayeredFragmentationManager::new();
        let asset = Address::from_slice(&[1u8; 20]).unwrap();
        
        let configs = vec![
            LayerConfig::new(
                FragmentLayer::L1Core,
                Address::from_slice(&[2u8; 20]).unwrap(),
                1000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
            LayerConfig::new(
                FragmentLayer::L2Trading,
                Address::from_slice(&[3u8; 20]).unwrap(),
                2000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
        ];
        
        let result = manager.create_layered_fragmentation(asset.clone(), 1, configs);
        assert!(result.is_ok());
        
        // 验证层级已创建
        let layers = manager.get_layer_configs(&asset, 1);
        assert!(layers.is_some());
        assert_eq!(layers.unwrap().len(), 2);
    }
    
    #[test]
    fn test_duplicate_layer_rejection() {
        let mut manager = LayeredFragmentationManager::new();
        let asset = Address::from_slice(&[1u8; 20]).unwrap();
        
        let configs = vec![
            LayerConfig::new(
                FragmentLayer::L1Core,
                Address::from_slice(&[2u8; 20]).unwrap(),
                1000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
            LayerConfig::new(
                FragmentLayer::L1Core, // 重复
                Address::from_slice(&[3u8; 20]).unwrap(),
                2000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
        ];
        
        let result = manager.create_layered_fragmentation(asset, 1, configs);
        assert!(result.is_err());
    }
    
    #[test]
    fn test_conversion_calculation() {
        let manager = LayeredFragmentationManager::new();
        
        // 1:1转换
        let converted = manager.calculate_conversion(
            1000,
            FragmentLayer::L1Core,
            FragmentLayer::L2Trading,
        );
        assert_eq!(converted, 1000);
    }
    
    #[test]
    fn test_custom_conversion_rate() {
        let mut manager = LayeredFragmentationManager::new();
        
        // 设置1:2转换率
        manager.set_conversion_rate(
            FragmentLayer::L1Core,
            FragmentLayer::L3Derivative,
            2_000_000_000_000_000_000,
        );
        
        let converted = manager.calculate_conversion(
            1000,
            FragmentLayer::L1Core,
            FragmentLayer::L3Derivative,
        );
        assert_eq!(converted, 2000);
    }
    
    #[test]
    fn test_can_convert() {
        let mut manager = LayeredFragmentationManager::new();
        let asset = Address::from_slice(&[1u8; 20]).unwrap();
        
        let configs = vec![
            LayerConfig::new(
                FragmentLayer::L1Core,
                Address::from_slice(&[2u8; 20]).unwrap(),
                1000,
                true,
                true, // 可组合
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
            LayerConfig::new(
                FragmentLayer::L2Trading,
                Address::from_slice(&[3u8; 20]).unwrap(),
                2000,
                true,
                false, // 不可组合
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
        ];
        
        manager.create_layered_fragmentation(asset.clone(), 1, configs).unwrap();
        
        // L1 -> L2 应该可以（L1可组合）
        assert!(manager.can_convert(&asset, 1, FragmentLayer::L1Core, FragmentLayer::L2Trading));
        
        // L2 -> L1 应该不可以（L2不可组合）
        assert!(!manager.can_convert(&asset, 1, FragmentLayer::L2Trading, FragmentLayer::L1Core));
    }
    
    #[test]
    fn test_get_supported_layers() {
        let mut manager = LayeredFragmentationManager::new();
        let asset = Address::from_slice(&[1u8; 20]).unwrap();
        
        let configs = vec![
            LayerConfig::new(
                FragmentLayer::L1Core,
                Address::from_slice(&[2u8; 20]).unwrap(),
                1000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
            LayerConfig::new(
                FragmentLayer::L3Derivative,
                Address::from_slice(&[3u8; 20]).unwrap(),
                2000,
                true,
                true,
                GNACSCode::new(AssetCategory::RealEstate, 0x01, Jurisdiction::US, ComplianceLevel::High, RiskLevel::Medium),
            ),
        ];
        
        manager.create_layered_fragmentation(asset.clone(), 1, configs).unwrap();
        
        let layers = manager.get_supported_layers(&asset, 1);
        assert_eq!(layers.len(), 2);
        assert!(layers.contains(&FragmentLayer::L1Core));
        assert!(layers.contains(&FragmentLayer::L3Derivative));
    }
}