use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct FlowContext {
    #[serde(default)]
    pub data: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ExecutionMode {
    #[serde(rename = "sync")] Sync,
    #[serde(rename = "async")] AsyncFireAndForget,
    #[serde(rename = "queued")] AsyncQueued,
    #[serde(rename = "bounded")] AsyncBounded,
}

impl Default for ExecutionMode { fn default() -> Self { ExecutionMode::Sync } }

// 新增：流式事件（用于 SSE）
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")] // 带判别字段，便于前端识别事件类型
pub enum StreamEvent {
    #[serde(rename = "node")]
    Node { node_id: String, logs: Vec<String>, ctx: serde_json::Value },
    #[serde(rename = "done")]
    Done { ok: bool, ctx: serde_json::Value, logs: Vec<String> },
    #[serde(rename = "error")]
    Error { message: String },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriveOptions {
    #[serde(default)]
    pub max_steps: usize,
    #[serde(default)]
    pub execution_mode: ExecutionMode,
    // 新增：事件通道（仅运行时使用，不做序列化/反序列化）
    #[serde(default, skip_serializing, skip_deserializing)]
    pub event_tx: Option<tokio::sync::mpsc::Sender<StreamEvent>>,
    // 新增：异步分组追踪器（仅运行时使用，不做序列化/反序列化）
    #[serde(default, skip_serializing, skip_deserializing)]
    pub async_groups: Option<std::sync::Arc<tokio::sync::Mutex<std::collections::HashMap<String, Vec<tokio::task::JoinHandle<()>>>>>>,
    #[serde(default, skip_serializing, skip_deserializing)]
    pub group_semaphores: Option<std::sync::Arc<tokio::sync::Mutex<std::collections::HashMap<String, std::sync::Arc<tokio::sync::Semaphore>>>>>,
    #[serde(default)]
    pub bounded_limit: Option<usize>,
}

impl Default for DriveOptions {
    fn default() -> Self { Self { max_steps: 10_000, execution_mode: ExecutionMode::Sync, event_tx: None, async_groups: None, group_semaphores: None, bounded_limit: None } }
}