#include "alarm_editor_service.h"

#include "project_service.h"
#include "domain/project_limits.h"

#include <algorithm>

namespace {

// 创建统一的报警编辑失败结果
AlarmEditorResult failure(AlarmEditorError error, const std::string &message)
{
    return {false, error, message, {}};
}

} // namespace

// 保存工程服务引用，后续编辑都通过该服务修改当前工程
AlarmEditorService::AlarmEditorService(ProjectService &project_service)
    : project_service_(project_service)
{
}

// 返回当前工程持有的报警定义列表
const std::vector<AlarmDefinition> &AlarmEditorService::definitions() const
{
    return project_service_.project().alarmDefinitions;
}

// 按稳定 ID 查找报警定义，找不到时返回空指针
const AlarmDefinition *AlarmEditorService::findDefinition(
    const std::string &id) const
{
    const auto &definitions = project_service_.project().alarmDefinitions;
    const auto definition = std::find_if(
        definitions.cbegin(), definitions.cend(),
        [&id](const AlarmDefinition &candidate) { return candidate.id == id; });
    return definition == definitions.cend() ? nullptr : &*definition;
}

// 校验数量和定义内容后添加一条带唯一 ID 的报警定义
AlarmEditorResult AlarmEditorService::addDefinition(
    const AlarmDefinition &definition)
{
    const std::size_t maximum =
        project_service_.projectLimits().maximumAlarmDefinitions;
    if (definitions().size() >= maximum)
    {
        return failure(
            AlarmEditorError::InvalidDefinition,
            "当前配置最多允许 " + std::to_string(maximum) + " 条报警定义");
    }
    AlarmDefinition candidate = definition;
    candidate.id = makeUniqueId();
    std::string error;
    if (!candidate.validate(&error))
    {
        return failure(AlarmEditorError::InvalidDefinition, error);
    }
    project_service_.editProject().alarmDefinitions.push_back(candidate);
    return {true, AlarmEditorError::None, {}, candidate.id};
}

// 校验候选定义后整体替换指定 ID 的报警定义
AlarmEditorResult AlarmEditorService::updateDefinition(
    const std::string &id, const AlarmDefinition &definition)
{
    if (findDefinition(id) == nullptr)
    {
        return failure(AlarmEditorError::NotFound, "未找到报警定义");
    }
    AlarmDefinition candidate = definition;
    candidate.id = id;
    std::string error;
    if (!candidate.validate(&error))
    {
        return failure(AlarmEditorError::InvalidDefinition, error);
    }

    Project &project = project_service_.editProject();
    auto editable = std::find_if(
        project.alarmDefinitions.begin(), project.alarmDefinitions.end(),
        [&id](const AlarmDefinition &item) { return item.id == id; });
    *editable = std::move(candidate);
    return {true, AlarmEditorError::None, {}, id};
}

// 删除指定 ID 的报警定义
AlarmEditorResult AlarmEditorService::removeDefinition(const std::string &id)
{
    if (findDefinition(id) == nullptr)
    {
        return failure(AlarmEditorError::NotFound, "未找到报警定义");
    }
    Project &project = project_service_.editProject();
    // remove_if 先把目标项移到逻辑末尾，再由 erase 真正缩短容器
    project.alarmDefinitions.erase(
        std::remove_if(
            project.alarmDefinitions.begin(), project.alarmDefinitions.end(),
            [&id](const AlarmDefinition &definition)
            {
                return definition.id == id;
            }),
        project.alarmDefinitions.end());
    return {true, AlarmEditorError::None, {}, id};
}

// 从 alarm-1 开始递增查找当前工程内可用的 ID
std::string AlarmEditorService::makeUniqueId() const
{
    int suffix = 1;
    while (true)
    {
        const std::string candidate = "alarm-" + std::to_string(suffix);
        if (findDefinition(candidate) == nullptr)
        {
            return candidate;
        }
        ++suffix;
    }
}