///! NAC层间路由器
///!
///! 管理L0-L1-L2-L3层间的通信和路由
///!
///! **NAC四层架构**：
///! - L0: 基础层（DAG + CBPP共识 + OPN）
///! - L1: 协议层（NVM + ACC + GNACS + 碎片化）
///! - L2: 宪法层（宪法收据 + CEE + 合规验证）
///! - L3: 应用层（业务应用 + UI + API）

use crate::primitives::{Address, Hash};
use std::collections::{HashMap, VecDeque};
use serde::{Deserialize, Serialize};

/// NAC层级
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
/// Layer
pub enum Layer {
    /// L0: 基础层
    L0,
    /// L1: 协议层
    L1,
    /// L2: 宪法层
    L2,
    /// L3: 应用层
    L3,
}

impl Layer {
    /// 获取层级编号
    pub fn level(&self) -> u8 {
        match self {
            Layer::L0 => 0,
            Layer::L1 => 1,
            Layer::L2 => 2,
            Layer::L3 => 3,
        }
    }
    
    /// 从层级编号创建
    pub fn from_level(level: u8) -> Option<Self> {
        match level {
            0 => Some(Layer::L0),
            1 => Some(Layer::L1),
            2 => Some(Layer::L2),
            3 => Some(Layer::L3),
            _ => None,
        }
    }
    
    /// 是否可以直接通信
    pub fn can_communicate_with(&self, other: &Layer) -> bool {
        // 相邻层可以直接通信
        let diff = (self.level() as i8 - other.level() as i8).abs();
        diff <= 1
    }
}

/// 层间消息类型
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
/// LayerMessageType
pub enum LayerMessageType {
    /// 请求
    Request,
    /// 响应
    Response,
    /// 通知
    Notification,
    /// 事件
    Event,
}

/// 层间消息
#[derive(Debug, Clone, Serialize, Deserialize)]
/// LayerMessage
pub struct LayerMessage {
    /// 消息ID
    pub message_id: Hash,
    /// 消息类型
    pub message_type: LayerMessageType,
    /// 源层
    pub source_layer: Layer,
    /// 目标层
    pub target_layer: Layer,
    /// 发送者地址
    pub sender: Address,
    /// 接收者地址（None表示广播）
    pub receiver: Option<Address>,
    /// 消息负载
    pub payload: Vec<u8>,
    /// 时间戳
    pub timestamp: u64,
    /// 优先级（0-255，数字越大优先级越高）
    pub priority: u8,
    /// 路由路径（经过的层）
    pub route_path: Vec<Layer>,
}

impl LayerMessage {
    /// 创建新的层间消息
    pub fn new(
        message_type: LayerMessageType,
        source_layer: Layer,
        target_layer: Layer,
        sender: Address,
        receiver: Option<Address>,
        payload: Vec<u8>,
        timestamp: u64,
        priority: u8,
    ) -> Self {
        // 计算消息ID
        let mut data = Vec::new();
        data.push(source_layer.level());
        data.push(target_layer.level());
        data.extend_from_slice(sender.as_bytes());
        if let Some(ref r) = receiver {
            data.extend_from_slice(r.as_bytes());
        }
        data.extend_from_slice(&payload);
        data.extend_from_slice(&timestamp.to_le_bytes());
        
        let message_id = Hash::sha3_384(&data);
        
        Self {
            message_id,
            message_type,
            source_layer,
            target_layer,
            sender,
            receiver,
            payload,
            timestamp,
            priority,
            route_path: vec![source_layer],
        }
    }
    
    /// 添加路由路径
    pub fn add_to_route(&mut self, layer: Layer) {
        self.route_path.push(layer);
    }
    
    /// 是否到达目标层
    pub fn has_reached_target(&self) -> bool {
        self.route_path.last() == Some(&self.target_layer)
    }
}

/// 层间路由表
struct RoutingTable {
    /// 路由规则（source_layer, target_layer） => next_layer
    routes: HashMap<(Layer, Layer), Layer>,
}

impl RoutingTable {
    /// 创建新的路由表
    fn new() -> Self {
        let mut routes = HashMap::new();
        
        // 初始化默认路由规则
        // L0 <-> L1 直接通信
        routes.insert((Layer::L0, Layer::L1), Layer::L1);
        routes.insert((Layer::L1, Layer::L0), Layer::L0);
        
        // L1 <-> L2 直接通信
        routes.insert((Layer::L1, Layer::L2), Layer::L2);
        routes.insert((Layer::L2, Layer::L1), Layer::L1);
        
        // L2 <-> L3 直接通信
        routes.insert((Layer::L2, Layer::L3), Layer::L3);
        routes.insert((Layer::L3, Layer::L2), Layer::L2);
        
        // L0 -> L2 经过 L1
        routes.insert((Layer::L0, Layer::L2), Layer::L1);
        
        // L0 -> L3 经过 L1
        routes.insert((Layer::L0, Layer::L3), Layer::L1);
        
        // L1 -> L3 经过 L2
        routes.insert((Layer::L1, Layer::L3), Layer::L2);
        
        // L3 -> L1 经过 L2
        routes.insert((Layer::L3, Layer::L1), Layer::L2);
        
        // L3 -> L0 经过 L2
        routes.insert((Layer::L3, Layer::L0), Layer::L2);
        
        // L2 -> L0 经过 L1
        routes.insert((Layer::L2, Layer::L0), Layer::L1);
        
        Self { routes }
    }
    
    /// 获取下一跳层级
    fn get_next_hop(&self, current_layer: Layer, target_layer: Layer) -> Option<Layer> {
        if current_layer == target_layer {
            return Some(target_layer);
        }
        
        self.routes.get(&(current_layer, target_layer)).copied()
    }
}

/// 层间消息队列
struct LayerMessageQueue {
    /// 消息队列（按优先级排序）
    queue: VecDeque<LayerMessage>,
}

impl LayerMessageQueue {
    /// 创建新的消息队列
    fn new() -> Self {
        Self {
            queue: VecDeque::new(),
        }
    }
    
    /// 添加消息
    fn enqueue(&mut self, message: LayerMessage) {
        // 按优先级插入（优先级高的在前）
        let pos = self.queue
            .iter()
            .position(|m| m.priority < message.priority)
            .unwrap_or(self.queue.len());
        
        self.queue.insert(pos, message);
    }
    
    /// 取出消息
    fn dequeue(&mut self) -> Option<LayerMessage> {
        self.queue.pop_front()
    }
    
    /// 获取队列长度
    fn len(&self) -> usize {
        self.queue.len()
    }
    
    /// 是否为空
    #[allow(dead_code)]
    fn is_empty(&self) -> bool {
        self.queue.is_empty()
    }
}

/// 层间路由器
pub struct LayerRouter {
    /// 当前层级
    current_layer: Layer,
    /// 路由表
    routing_table: RoutingTable,
    /// 待发送消息队列
    outbound_queue: LayerMessageQueue,
    /// 已接收消息队列
    inbound_queue: LayerMessageQueue,
    /// 消息处理器（message_type => handler_id）
    message_handlers: HashMap<LayerMessageType, Vec<String>>,
    /// 统计信息
    stats: RouterStats,
}

impl LayerRouter {
    /// 创建新的层间路由器
    pub fn new(current_layer: Layer) -> Self {
        Self {
            current_layer,
            routing_table: RoutingTable::new(),
            outbound_queue: LayerMessageQueue::new(),
            inbound_queue: LayerMessageQueue::new(),
            message_handlers: HashMap::new(),
            stats: RouterStats::default(),
        }
    }
    
    /// 发送消息
    pub fn send_message(
        &mut self,
        message_type: LayerMessageType,
        target_layer: Layer,
        sender: Address,
        receiver: Option<Address>,
        payload: Vec<u8>,
        timestamp: u64,
        priority: u8,
    ) -> Result<Hash, String> {
        // 创建消息
        let message = LayerMessage::new(
            message_type,
            self.current_layer,
            target_layer,
            sender,
            receiver,
            payload,
            timestamp,
            priority,
        );
        
        let message_id = message.message_id.clone();
        
        // 加入发送队列
        self.outbound_queue.enqueue(message);
        self.stats.messages_sent += 1;
        
        Ok(message_id)
    }
    
    /// 接收消息
    pub fn receive_message(&mut self, mut message: LayerMessage) -> Result<(), String> {
        // 验证消息是否应该到达当前层
        let next_hop = self.routing_table
            .get_next_hop(
                *message.route_path.last().unwrap(),
                message.target_layer,
            )
            .ok_or("No route found")?;
        
        if next_hop != self.current_layer {
            return Err(format!(
                "Message should be routed to {:?}, not {:?}",
                next_hop, self.current_layer
            ));
        }
        
        // 添加到路由路径
        message.add_to_route(self.current_layer);
        
        // 如果到达目标层，加入接收队列
        if message.has_reached_target() {
            self.inbound_queue.enqueue(message);
            self.stats.messages_received += 1;
        } else {
            // 否则继续转发
            self.outbound_queue.enqueue(message);
            self.stats.messages_forwarded += 1;
        }
        
        Ok(())
    }
    
    /// 处理待发送消息
    pub fn process_outbound_messages(&mut self) -> Vec<LayerMessage> {
        let mut processed = Vec::new();
        
        while let Some(message) = self.outbound_queue.dequeue() {
            processed.push(message);
        }
        
        processed
    }
    
    /// 处理已接收消息
    pub fn process_inbound_messages(&mut self) -> Vec<LayerMessage> {
        let mut processed = Vec::new();
        
        while let Some(message) = self.inbound_queue.dequeue() {
            processed.push(message);
        }
        
        processed
    }
    
    /// 注册消息处理器
    pub fn register_handler(&mut self, message_type: LayerMessageType, handler_id: String) {
        self.message_handlers
            .entry(message_type)
            .or_insert_with(Vec::new)
            .push(handler_id);
    }
    
    /// 获取消息处理器
    pub fn get_handlers(&self, message_type: &LayerMessageType) -> Option<&Vec<String>> {
        self.message_handlers.get(message_type)
    }
    
    /// 获取统计信息
    pub fn get_stats(&self) -> &RouterStats {
        &self.stats
    }
    
    /// 获取待发送消息数量
    pub fn outbound_count(&self) -> usize {
        self.outbound_queue.len()
    }
    
    /// 获取已接收消息数量
    pub fn inbound_count(&self) -> usize {
        self.inbound_queue.len()
    }
}

/// 路由器统计信息
#[derive(Debug, Clone, Default)]
/// RouterStats
pub struct RouterStats {
    /// 已发送消息数
    pub messages_sent: u64,
    /// 已接收消息数
    pub messages_received: u64,
    /// 已转发消息数
    pub messages_forwarded: u64,
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_layer_level() {
        assert_eq!(Layer::L0.level(), 0);
        assert_eq!(Layer::L1.level(), 1);
        assert_eq!(Layer::L2.level(), 2);
        assert_eq!(Layer::L3.level(), 3);
    }
    
    #[test]
    fn test_layer_from_level() {
        assert_eq!(Layer::from_level(0), Some(Layer::L0));
        assert_eq!(Layer::from_level(1), Some(Layer::L1));
        assert_eq!(Layer::from_level(2), Some(Layer::L2));
        assert_eq!(Layer::from_level(3), Some(Layer::L3));
        assert_eq!(Layer::from_level(4), None);
    }
    
    #[test]
    fn test_layer_communication() {
        // 相邻层可以直接通信
        assert!(Layer::L0.can_communicate_with(&Layer::L1));
        assert!(Layer::L1.can_communicate_with(&Layer::L0));
        assert!(Layer::L1.can_communicate_with(&Layer::L2));
        assert!(Layer::L2.can_communicate_with(&Layer::L3));
        
        // 非相邻层不能直接通信
        assert!(!Layer::L0.can_communicate_with(&Layer::L2));
        assert!(!Layer::L0.can_communicate_with(&Layer::L3));
        assert!(!Layer::L1.can_communicate_with(&Layer::L3));
    }
    
    #[test]
    fn test_layer_message_creation() {
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        let receiver = Address::from_slice(&[2u8; 32]).unwrap();
        
        let message = LayerMessage::new(
            LayerMessageType::Request,
            Layer::L1,
            Layer::L2,
            sender,
            Some(receiver),
            vec![1, 2, 3],
            1000,
            10,
        );
        
        assert_eq!(message.source_layer, Layer::L1);
        assert_eq!(message.target_layer, Layer::L2);
        assert_eq!(message.priority, 10);
        assert_eq!(message.route_path, vec![Layer::L1]);
        assert!(!message.has_reached_target());
    }
    
    #[test]
    fn test_routing_table() {
        let table = RoutingTable::new();
        
        // 直接通信
        assert_eq!(table.get_next_hop(Layer::L0, Layer::L1), Some(Layer::L1));
        assert_eq!(table.get_next_hop(Layer::L1, Layer::L2), Some(Layer::L2));
        
        // 间接通信（L0 -> L2 经过 L1）
        assert_eq!(table.get_next_hop(Layer::L0, Layer::L2), Some(Layer::L1));
        
        // 间接通信（L0 -> L3 经过 L1）
        assert_eq!(table.get_next_hop(Layer::L0, Layer::L3), Some(Layer::L1));
    }
    
    #[test]
    fn test_message_queue() {
        let mut queue = LayerMessageQueue::new();
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        
        // 添加低优先级消息
        let message1 = LayerMessage::new(
            LayerMessageType::Request,
            Layer::L1,
            Layer::L2,
            sender.clone(),
            None,
            vec![1],
            1000,
            5, // 低优先级
        );
        queue.enqueue(message1);
        
        // 添加高优先级消息
        let message2 = LayerMessage::new(
            LayerMessageType::Request,
            Layer::L1,
            Layer::L2,
            sender,
            None,
            vec![2],
            1001,
            10, // 高优先级
        );
        queue.enqueue(message2.clone());
        
        // 高优先级消息应该先出队
        let dequeued = queue.dequeue().unwrap();
        assert_eq!(dequeued.message_id, message2.message_id);
    }
    
    #[test]
    fn test_layer_router_send() {
        let mut router = LayerRouter::new(Layer::L1);
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        let receiver = Address::from_slice(&[2u8; 32]).unwrap();
        
        let result = router.send_message(
            LayerMessageType::Request,
            Layer::L2,
            sender,
            Some(receiver),
            vec![1, 2, 3],
            1000,
            10,
        );
        
        assert!(result.is_ok());
        assert_eq!(router.outbound_count(), 1);
        assert_eq!(router.get_stats().messages_sent, 1);
    }
    
    #[test]
    fn test_layer_router_receive() {
        let mut router = LayerRouter::new(Layer::L2);
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        let receiver = Address::from_slice(&[2u8; 32]).unwrap();
        
        // 创建从L1发往L2的消息
        let message = LayerMessage::new(
            LayerMessageType::Request,
            Layer::L1,
            Layer::L2,
            sender,
            Some(receiver),
            vec![1, 2, 3],
            1000,
            10,
        );
        
        let result = router.receive_message(message);
        assert!(result.is_ok());
        assert_eq!(router.inbound_count(), 1);
        assert_eq!(router.get_stats().messages_received, 1);
    }
    
    #[test]
    fn test_layer_router_forward() {
        let mut router = LayerRouter::new(Layer::L1);
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        let receiver = Address::from_slice(&[2u8; 32]).unwrap();
        
        // 创建从L0发往L2的消息（需要经过L1转发）
        let message = LayerMessage::new(
            LayerMessageType::Request,
            Layer::L0,
            Layer::L2,
            sender,
            Some(receiver),
            vec![1, 2, 3],
            1000,
            10,
        );
        
        let result = router.receive_message(message);
        assert!(result.is_ok());
        assert_eq!(router.outbound_count(), 1); // 转发到发送队列
        assert_eq!(router.get_stats().messages_forwarded, 1);
    }
    
    #[test]
    fn test_message_handler_registration() {
        let mut router = LayerRouter::new(Layer::L1);
        
        router.register_handler(LayerMessageType::Request, "handler1".to_string());
        router.register_handler(LayerMessageType::Request, "handler2".to_string());
        
        let handlers = router.get_handlers(&LayerMessageType::Request).unwrap();
        assert_eq!(handlers.len(), 2);
        assert!(handlers.contains(&"handler1".to_string()));
        assert!(handlers.contains(&"handler2".to_string()));
    }
    
    #[test]
    fn test_process_messages() {
        let mut router = LayerRouter::new(Layer::L1);
        let sender = Address::from_slice(&[1u8; 32]).unwrap();
        let receiver = Address::from_slice(&[2u8; 32]).unwrap();
        
        // 发送2条消息
        router.send_message(
            LayerMessageType::Request,
            Layer::L2,
            sender.clone(),
            Some(receiver.clone()),
            vec![1],
            1000,
            10,
        ).unwrap();
        
        router.send_message(
            LayerMessageType::Request,
            Layer::L2,
            sender,
            Some(receiver),
            vec![2],
            1001,
            5,
        ).unwrap();
        
        // 处理待发送消息
        let processed = router.process_outbound_messages();
        assert_eq!(processed.len(), 2);
        assert_eq!(router.outbound_count(), 0);
    }
}