#pragma once

#include "register_address.h"

#include <cstdint>
#include <optional>
#include <string>
#include <variant>
#include <vector>

enum class ContactMode
{
    NormallyOpen,
    NormallyClosed
};

enum class CoilMode
{
    Normal,
    Set,
    Reset
};

enum class ComparisonOperator
{
    Equal,
    NotEqual,
    LessThan,
    LessThanOrEqual,
    GreaterThan,
    GreaterThanOrEqual
};

struct ContactNodeConfig
{
    RegisterAddress address{RegisterArea::M, 0};
    ContactMode mode = ContactMode::NormallyOpen;
};

struct CoilNodeConfig
{
    RegisterAddress address{RegisterArea::M, 0};
    CoilMode mode = CoilMode::Normal;
};

struct CompareNodeConfig
{
    RegisterAddress address{RegisterArea::D, 0};
    ComparisonOperator comparison = ComparisonOperator::Equal;
    std::int16_t value = 0;
};

using LogicNodeConfig = std::variant<ContactNodeConfig, CoilNodeConfig, CompareNodeConfig>;

struct LogicNode
{
    std::string id;
    LogicNodeConfig config;
    bool configured = true;

    bool validate(std::string *error = nullptr) const;
    bool isConfigured() const;
    bool isCondition() const;
    bool isOutput() const;
};

enum class ConditionExpressionKind
{
    Node,
    Series,
    Parallel
};

// 结构化表达式只允许合法的串并联拓扑，不保存可产生悬空线或环路的像素连接
struct ConditionExpression
{
    std::string id;
    ConditionExpressionKind kind = ConditionExpressionKind::Node;
    std::optional<LogicNode> node;
    std::vector<ConditionExpression> children;

    static ConditionExpression fromNode(LogicNode node);
    bool validate(std::string *error = nullptr) const;
    bool validateForRunning(std::string *error = nullptr) const;
};

// 删除后折叠单子项容器并合并相邻同类容器，保持表达式的规范形态
void normalizeConditionExpression(std::optional<ConditionExpression> *expression);
const LogicNode *findConditionNode(
    const ConditionExpression &expression, const std::string &node_id);
LogicNode *findConditionNode(
    ConditionExpression &expression, const std::string &node_id);
const ConditionExpression *findConditionExpression(
    const ConditionExpression &expression, const std::string &expression_id);
ConditionExpression *findConditionExpression(
    ConditionExpression &expression, const std::string &expression_id);
void collectConditionNodes(
    const ConditionExpression &expression, std::vector<const LogicNode *> *nodes);
void collectConditionExpressionIds(
    const ConditionExpression &expression, std::vector<std::string> *ids);

// 一个网络包含一棵结构化条件表达式，输出线圈固定在最右侧
struct LadderRung
{
    std::string id;
    std::string name;
    std::optional<ConditionExpression> condition;
    std::optional<LogicNode> output;

    bool validate(std::string *error = nullptr) const;
    bool validateStructure(std::string *error = nullptr) const;
    bool validateForRunning(std::string *error = nullptr) const;
};

struct ControlLogic
{
    std::string id;
    std::string name;
    std::vector<LadderRung> rungs;
    bool enabled = true;

    bool validate(std::string *error = nullptr) const;
    bool validateStructure(std::string *error = nullptr) const;
    bool validateForRunning(std::string *error = nullptr) const;
};