mofa-kernel 0.1.1

use crate::agent::AgentState;
use serde::{Deserialize, Serialize};

// 流类型枚举
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub enum StreamType {
    MessageStream, // 消息流 - 异步消息传递
    DataStream,    // 数据流 - 连续数据传递
    EventStream,   // 事件流 - 离散事件传递
    CommandStream, // 命令流 - 控制命令传递
}

// 智能体通信消息协议
#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum AgentMessage {
    TaskRequest {
        task_id: String,
        content: String,
    },
    TaskResponse {
        task_id: String,
        result: String,
        status: TaskStatus,
    },
    StateSync {
        agent_id: String,
        state: AgentState,
    },
    Event(AgentEvent),

    // 流相关消息
    StreamMessage {
        stream_id: String,
        message: Vec<u8>,
        sequence: u64,
    }, // 流消息

    StreamControl {
        stream_id: String,
        command: StreamControlCommand,
        metadata: std::collections::HashMap<String, String>,
    }, // 流控制消息
}

// 任务状态枚举
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub enum TaskStatus {
    Success,
    Failed,
    Pending,
}

// Agent 可感知的事件类型
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AgentEvent {
    TaskReceived(TaskRequest), // 任务事件
    TaskPreempted(String),     // 任务被抢占事件（参数：被抢占的任务ID）
    Shutdown,                  // 框架关闭事件
    Custom(String, Vec<u8>),   // 自定义事件

    // 流相关事件
    StreamMessage {
        stream_id: String,
        message: Vec<u8>,
        sequence: u64,
    }, // 流消息事件

    StreamCreated {
        stream_id: String,
        stream_type: StreamType,
        metadata: std::collections::HashMap<String, String>,
    }, // 流创建事件

    StreamClosed {
        stream_id: String,
        reason: String,
    }, // 流关闭事件

    StreamSubscription {
        stream_id: String,
        subscriber_id: String,
    }, // 流订阅事件

    StreamUnsubscription {
        stream_id: String,
        subscriber_id: String,
    }, // 流取消订阅事件
}

// 扩展 TaskRequest，增加优先级和调度元数据
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct TaskRequest {
    pub task_id: String,
    pub content: String,
    pub priority: TaskPriority,
    pub deadline: Option<std::time::Duration>, // 任务截止时间
    pub metadata: std::collections::HashMap<String, String>,
}

// 任务优先级与调度元数据
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
pub enum TaskPriority {
    Critical = 0,
    Highest = 1,
    High = 2,
    Medium = 3,
    Normal = 4,
    Low = 5,
}

// 实现 PartialOrd 用于优先级排序（Urgent > High > Medium > Low）
impl PartialOrd for TaskPriority {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for TaskPriority {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        match (self, other) {
            (TaskPriority::Critical, _) => std::cmp::Ordering::Greater,
            (_, TaskPriority::Critical) => std::cmp::Ordering::Less,
            (TaskPriority::High, TaskPriority::Medium | TaskPriority::Low) => {
                std::cmp::Ordering::Greater
            }
            (TaskPriority::Medium, TaskPriority::Low) => std::cmp::Ordering::Greater,
            (TaskPriority::Low, TaskPriority::Medium | TaskPriority::High) => {
                std::cmp::Ordering::Less
            }
            (TaskPriority::Medium, TaskPriority::High) => std::cmp::Ordering::Less,
            (a, b) if a == b => std::cmp::Ordering::Equal,
            _ => unreachable!("All cases should be covered"),
        }
    }
}

// 流控制命令
#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum StreamControlCommand {
    Create(StreamType), // 创建流
    Close(String),      // 关闭流（原因）
    Subscribe,          // 订阅流
    Unsubscribe,        // 取消订阅
    Pause,              // 暂停流
    Resume,             // 恢复流
    Seek(u64),          // 跳转到指定序列位置（仅适用于可重放流）
}

// 调度状态，用于跟踪任务抢占情况
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SchedulingStatus {
    Pending,
    Running,
    Preempted, // 被高优先级任务抢占
    Completed,
    Failed,
}