#ifndef MULTI_AGENT_SYSTEM_APP_HPP
#define MULTI_AGENT_SYSTEM_APP_HPP

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <memory>
#include <chrono>
#include <functional>

namespace multi_agent {

// 智能体状态枚举
enum class AgentStatus {
    IDLE,           // 空闲
    BUSY,           // 忙碌
    OFFLINE,        // 离线
    ERROR           // 错误
};

// 任务执行状态枚举
enum class ExecutionStatus {
    PENDING,        // 等待中
    RUNNING,        // 执行中
    COMPLETED,      // 已完成
    FAILED,         // 失败
    CANCELLED       // 已取消
};

// 智能体元数据结构
struct AgentMetadata {
    std::string id;                // 智能体唯一标识
    std::string name;              // 智能体名称
    std::string version;           // 版本号
    std::string service_url;       // 服务地址
    std::vector<std::string> capabilities;  // 能力标签
    std::string input_schema;      // 输入JSON Schema
    std::string output_schema;     // 输出JSON Schema
    AgentStatus status;            // 当前状态
    std::chrono::system_clock::time_point last_heartbeat;  // 最后心跳时间
};

// 智能体类
class Agent {
public:
    Agent(const AgentMetadata& metadata);
    virtual ~Agent() = default;
    
    // 执行任务
    virtual std::string execute(const std::string& input_data);
    
    // 获取元数据
    const AgentMetadata& get_metadata() const { return metadata_; }
    
    // 更新状态
    void set_status(AgentStatus status) { metadata_.status = status; }
    
    // 更新心跳时间
    void update_heartbeat();

private:
    AgentMetadata metadata_;
};

// 执行流节点
class ExecutionNode {
public:
    ExecutionNode(const std::string& id, const std::string& agent_id);
    
    std::string get_id() const { return id_; }
    std::string get_agent_id() const { return agent_id_; }
    ExecutionStatus get_status() const { return status_; }
    
    void set_input_data(const std::string& data) { input_data_ = data; }
    void set_output_data(const std::string& data) { output_data_ = data; }
    
    void set_status(ExecutionStatus status) { status_ = status; }
    
    // 添加依赖节点
    void add_dependency(const std::string& node_id);
    const std::vector<std::string>& get_dependencies() const { return dependencies_; }
    
    // 执行节点任务
    bool execute(const std::map<std::string, std::shared_ptr<Agent>>& agents);

private:
    std::string id_;
    std::string agent_id_;
    std::string input_data_;
    std::string output_data_;
    ExecutionStatus status_;
    std::vector<std::string> dependencies_;
    std::chrono::system_clock::time_point start_time_;
    std::chrono::system_clock::time_point end_time_;
};

// 执行上下文
class ExecutionContext {
public:
    ExecutionContext();
    
    // 全局上下文操作
    void set_global_value(const std::string& key, const std::string& value);
    std::string get_global_value(const std::string& key) const;
    
    // 节点上下文操作
    void set_node_output(const std::string& node_id, const std::string& output);
    std::string get_node_output(const std::string& node_id) const;
    
    // 上下文快照
    std::string serialize() const;
    void deserialize(const std::string& snapshot);
    
    // 清空上下文
    void clear();

private:
    std::map<std::string, std::string> global_context_;
    std::map<std::string, std::string> node_outputs_;
};

// 执行流引擎
class FlowEngine {
public:
    FlowEngine();
    
    // 智能体管理
    void register_agent(const AgentMetadata& metadata);
    void unregister_agent(const std::string& agent_id);
    std::shared_ptr<Agent> get_agent(const std::string& agent_id);
    
    // 执行流管理
    void add_node(const std::shared_ptr<ExecutionNode>& node);
    void remove_node(const std::string& node_id);
    
    // 执行流执行
    bool execute_sequential();
    bool execute_parallel();
    
    // 获取执行状态
    std::map<std::string, ExecutionStatus> get_execution_status() const;
    
    // 清空引擎
    void clear();

private:
    std::map<std::string, std::shared_ptr<Agent>> agents_;
    std::map<std::string, std::shared_ptr<ExecutionNode>> nodes_;
    std::shared_ptr<ExecutionContext> context_;
    
    // 拓扑排序（用于依赖分析）
    std::vector<std::string> topological_sort() const;
    
    // 检查是否有环
    bool has_cycle() const;
    bool dfs_cycle_detection(const std::string& node_id, 
                            std::map<std::string, bool>& visited,
                            std::map<std::string, bool>& rec_stack) const;
};

// 应用程序类
class MultiAgentSystem {
public:
    MultiAgentSystem();
    
    // 初始化系统
    bool initialize();
    
    // 演示功能
    void demo_basic_flow();
    void demo_parallel_execution();
    
    // 运行系统
    void run();

private:
    std::unique_ptr<FlowEngine> flow_engine_;
};

} // namespace multi_agent

#endif // MULTI_AGENT_SYSTEM_APP_HPP