#ifndef __NODES_AND_CONNECTORS__
#define __NODES_AND_CONNECTORS__

#include <vector>
#include <memory>
#include "imgui.h"
#include "imnodes.h"
#include "ID_Generator.hpp"
#include "DLT_Utilities.hpp"
#include "Json_Utilities.hpp"

// =====================================接口抽象======================================================

class Abs_Connector // 抽象接口类
{
public:
    typedef enum
    {
        CONNECTOR_TYPE_UNKNOWN,         // 未知连接点类型
        CONNECTOR_TYPE_OUTPUT,          // 输出
        CONNECTOR_TYPE_INPUT,           // 输入
        CONNECTOR_TYPE_INPUT_EXCLUSIVE, // 独占输入，新连接必须断开旧连接
    } Connector_Type_Enum;              // 接口类型枚举

    typedef struct
    {
        size_t package_count = 0;      // 包计数 (常规非0)
        size_t total_count = 0;        // 总计数 (常规非0，不定长包时为0)
        void *p_content_mem = nullptr; // 包存储
        size_t content_size = 0;       // 包大小
    } Package;                         // 接口包定义

protected:
    // ID 分配器
    Independent_ID_Generator *ID_Generator;

    int id;                   // ID
    Connector_Type_Enum type; // 类型标识
    const char *socket_str;   // 套接字字符串

    std::vector<Abs_Connector *> related_connector_list; // 关联列表
    Package pkg;                                         // 接口包（仅输出类节点持有）

public:
    // 显式禁用默认构造
    Abs_Connector() = delete;

    // 必要构造
    Abs_Connector(Independent_ID_Generator *ID_Generator, Connector_Type_Enum type, const char *socket_str);

    // 析构
    ~Abs_Connector();

    // 连接到目标连接点
    virtual bool Connect_To(Abs_Connector *target);

    // 断开所有连接
    virtual void Disconnect_All(void);

    // 与指定的接口断开连接
    virtual bool Disconnect_To(Abs_Connector *target);

    /**
     * 注册包
     * @param p_content         目标容物指针
     * @param content_size      容物大小
     * @param count             当前包位置
     * @param total_count       包流总长度
     */
    virtual bool Register_Package(const void *p_content, size_t content_size, size_t count, size_t total_count);

    // 获取包
    virtual const Package Get_Package(void);

    // 获取关联接口列表
    virtual std::vector<Abs_Connector *> Get_Related_List(void);

    // 获取ID
    virtual int Get_ID(void);

    // 获取接口类型
    virtual Connector_Type_Enum Get_Type(void);

    // 获取套接字字符串
    virtual const char *Get_Socket_Str(void);

    // 默认风格连接点绘制
    virtual void Show(void);
};

// =====================================节点抽象======================================================

class Abs_Node // 抽象节点类
{
public:
    typedef enum
    {
        NODE_TYPE_UNKNOWN,        // 未知节点类型
        NODE_TYPE_CONNECTOR_TEST, // 接口测试节点
        NODE_TYPE_MSG_LINE_INPUT, // 消息输入节点
        NODE_TYPE_FILTER,         // 筛选器节点
        NODE_TYPE_LOGIC_AND,      // 逻辑与门节点
        NODE_TYPE_LOGIC_OR,       // 逻辑或门节点
        NODE_TYPE_LOGIC_NOT,      // 逻辑非门节点
        NODE_TYPE_CSV_EXPORTER,   // CSV输出节点
    } Node_Type_Enum;             // 节点类型枚举

protected:
    // ID 分配器
    Independent_ID_Generator *Node_ID_Generator;      // 节点ID生成器
    Independent_ID_Generator *Connector_ID_Generator; // 连接点ID生成器

    int id;                  // ID
    Node_Type_Enum type;     // 类型
    ImVec2 initial_position; // 初始位置

    bool close_flag; // 关闭标志位

    // 接口列表
    std::vector<std::shared_ptr<Abs_Connector>> Connector_List;

public:
    // 显式禁用默认构造
    Abs_Node() = delete;

    // 必要构造
    Abs_Node(Independent_ID_Generator *Node_ID_Generator,
             Independent_ID_Generator *Connector_ID_Generator,
             Node_Type_Enum type,
             ImVec2 initial_position = ImVec2(0, 0));

    // 析构
    ~Abs_Node();

    // 绘制节点
    virtual void Show(void) = 0;

    // 执行处理流程
    virtual bool Execute_Process(void) = 0;

    // 获取ID
    virtual int Get_ID(void);

    // 获取节点类型
    virtual Node_Type_Enum Get_Type(void);

    // 获取关闭信号
    virtual bool Get_CloseFlag(void);

    // 获取节点配置参数
    virtual Json_Arry Get_Arguments(void);

    // 应用配置参数
    virtual bool Apply_Arguments(Json_Arry Arg_Arry);

    // 获取接口列表
    std::vector<std::shared_ptr<Abs_Connector>> &Get_Connector_List(void);
};

// ====================================接口类声明================================================

// Boolean 状态输入接口
class Boolean_InPut_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    Boolean_InPut_Connector() = delete;

    // 必要构造
    explicit Boolean_InPut_Connector(Independent_ID_Generator *ID_Generator, bool exclusive_flag = false) : Abs_Connector(ID_Generator, exclusive_flag ? CONNECTOR_TYPE_INPUT_EXCLUSIVE : CONNECTOR_TYPE_INPUT, "Boolean") {}
};

// Boolean 状态输出接口
class Boolean_OutPut_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    Boolean_OutPut_Connector() = delete;

    // 必要构造
    explicit Boolean_OutPut_Connector(Independent_ID_Generator *ID_Generator) : Abs_Connector(ID_Generator, CONNECTOR_TYPE_OUTPUT, "Boolean") {}
};

// DLT信息输入接口
class MSG_InPut_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    MSG_InPut_Connector() = delete;

    // 必要构造
    explicit MSG_InPut_Connector(Independent_ID_Generator *ID_Generator, bool exclusive_flag = false) : Abs_Connector(ID_Generator, exclusive_flag ? CONNECTOR_TYPE_INPUT_EXCLUSIVE : CONNECTOR_TYPE_INPUT, "DLT MSG") {}
};

// DLT信息输出接口
class MSG_OutPut_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    MSG_OutPut_Connector() = delete;

    // 必要构造
    explicit MSG_OutPut_Connector(Independent_ID_Generator *ID_Generator) : Abs_Connector(ID_Generator, CONNECTOR_TYPE_OUTPUT, "DLT MSG") {}
};

// CSV 列输入接口
class CSV_Column_Input_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    CSV_Column_Input_Connector() = delete;

    // 必要构造
    explicit CSV_Column_Input_Connector(Independent_ID_Generator *ID_Generator, bool exclusive_flag = false) : Abs_Connector(ID_Generator, exclusive_flag ? CONNECTOR_TYPE_INPUT_EXCLUSIVE : CONNECTOR_TYPE_INPUT, "CSV Column") {}
};

// CSV 列输出接口
class CSV_Column_Output_Connector : public Abs_Connector
{
public:
    // 显式禁用默认构造
    CSV_Column_Output_Connector() = delete;

    // 必要构造
    explicit CSV_Column_Output_Connector(Independent_ID_Generator *ID_Generator) : Abs_Connector(ID_Generator, CONNECTOR_TYPE_OUTPUT, "CSV Column") {}
};

// ====================================节点类声明================================================

// 接口测试节点
class Connector_Test_Node : public Abs_Node
{
private:
    float node_width = 0;

public:
    // 显式禁用默认构造
    Connector_Test_Node() = delete;

    // 必要构造
    Connector_Test_Node(Independent_ID_Generator *Node_ID_Generator,
                        Independent_ID_Generator *Connector_ID_Generator,
                        ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

// DLT信息输入类，起始点
class MSG_Input_Node : public Abs_Node
{
private:
    float node_width = 0;

    DLT_Log log;

    // 执行相关
    bool excute_flag = false;
    size_t private_excute_count = 0;
    size_t private_excute_end_count = 0;
    bool private_finish_flag = false;

public:
    // 只读引用
    const bool &finish_flag = this->private_finish_flag;
    const size_t &excute_count = this->private_excute_count;
    const size_t &excute_end_count = this->private_excute_end_count;

    // 显式禁用默认构造
    MSG_Input_Node() = delete;

    // 必要构造
    MSG_Input_Node(Independent_ID_Generator *Node_ID_Generator,
                   Independent_ID_Generator *Connector_ID_Generator,
                   ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

// 筛选器节点
class Filter_Node : public Abs_Node
{
private:
    float node_width = 0;

public:
    // 显式禁用默认构造
    Filter_Node() = delete;

    // 必要构造
    Filter_Node(Independent_ID_Generator *Node_ID_Generator,
                Independent_ID_Generator *Connector_ID_Generator,
                ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

// 逻辑与门
class Logic_AND_Node : public Abs_Node
{
private:
    float node_width = 0;

public:
    // 显式禁用默认构造
    Logic_AND_Node() = delete;

    // 必要构造
    Logic_AND_Node(Independent_ID_Generator *Node_ID_Generator,
                   Independent_ID_Generator *Connector_ID_Generator,
                   ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

// 逻辑与门
class Logic_OR_Node : public Abs_Node
{
private:
    float node_width = 0;

public:
    // 显式禁用默认构造
    Logic_OR_Node() = delete;

    // 必要构造
    Logic_OR_Node(Independent_ID_Generator *Node_ID_Generator,
                  Independent_ID_Generator *Connector_ID_Generator,
                  ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

// 逻辑与门
class Logic_NOT_Node : public Abs_Node
{
private:
    float node_width = 0;

public:
    // 显式禁用默认构造
    Logic_NOT_Node() = delete;

    // 必要构造
    Logic_NOT_Node(Independent_ID_Generator *Node_ID_Generator,
                   Independent_ID_Generator *Connector_ID_Generator,
                   ImVec2 initial_position = ImVec2(0, 0));

    // 绘制节点
    virtual void Show(void);

    // 执行处理流程
    virtual bool Execute_Process(void);
};

#endif