#include "hmi_editor_service.h"

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

#include <algorithm>
#include <cctype>
#include <cstddef>
#include <map>
#include <set>
#include <utility>

namespace {

void setError(std::string *error, const std::string &message)
{
    if (error != nullptr)
    {
        *error = message;
    }
}

HmiEditorResult failure(HmiEditorError error, const std::string &message)
{
    return {false, error, message, {}};
}

bool isBlank(const std::string &value)
{
    return value.empty()
        || std::all_of(
            value.cbegin(), value.cend(),
            [](unsigned char character) { return std::isspace(character) != 0; });
}

std::string makeUniquePageId(const Project &project)
{
    int suffix = 1;
    while (true)
    {
        const std::string candidate = "page-" + std::to_string(suffix);
        const bool found = std::any_of(
            project.hmiPages.cbegin(), project.hmiPages.cend(),
            [&candidate](const HmiPage &page) { return page.id == candidate; });
        if (!found)
        {
            return candidate;
        }
        ++suffix;
    }
}

} // namespace

HmiEditorService::HmiEditorService(ProjectService &project_service)
    : project_service_(project_service)
{
}

HmiEditorService::HistoryState HmiEditorService::captureState() const
{
    const Project &project = project_service_.project();
    return {project.hmiPages, project.initialHmiPageId};
}

void HmiEditorService::recordHistory(HistoryState before)
{
    const HistoryState after = captureState();
    history_.record(std::move(before), after, &HmiEditorService::statesEqual);
}

bool HmiEditorService::statesEqual(
    const HistoryState &left, const HistoryState &right)
{
    if (left.initial_page_id != right.initial_page_id
        || left.pages.size() != right.pages.size())
    {
        return false;
    }
    for (std::size_t index = 0; index < left.pages.size(); ++index)
    {
        if (!pagesEqual(left.pages[index], right.pages[index]))
        {
            return false;
        }
    }
    return true;
}

bool HmiEditorService::pagesEqual(
    const HmiPage &left, const HmiPage &right)
{
    if (left.id != right.id || left.name != right.name
        || left.width != right.width || left.height != right.height
        || left.controls.size() != right.controls.size())
    {
        return false;
    }
    for (std::size_t index = 0; index < left.controls.size(); ++index)
    {
        if (!controlsEqual(left.controls[index], right.controls[index]))
        {
            return false;
        }
    }
    return true;
}

bool HmiEditorService::controlsEqual(
    const HmiControl &left, const HmiControl &right)
{
    const bool progress_equal = left.progressBar.has_value()
        == right.progressBar.has_value()
        && (!left.progressBar.has_value()
            || (left.progressBar->minimumValue == right.progressBar->minimumValue
                && left.progressBar->maximumValue == right.progressBar->maximumValue
                && left.progressBar->showValue == right.progressBar->showValue));
    const bool page_jump_equal = left.pageJump.has_value() == right.pageJump.has_value()
        && (!left.pageJump.has_value()
            || left.pageJump->targetPageId == right.pageJump->targetPageId);
    return left.id == right.id
        && left.type == right.type
        && left.bounds.x == right.bounds.x
        && left.bounds.y == right.bounds.y
        && left.bounds.width == right.bounds.width
        && left.bounds.height == right.bounds.height
        && left.text == right.text
        && left.binding == right.binding
        && left.properties == right.properties
        && left.buttonOperation == right.buttonOperation
        && page_jump_equal
        && progress_equal;
}

HmiEditorResult HmiEditorService::historyFailure(const std::string &message)
{
    return {false, HmiEditorError::InvalidOperation, message, {}};
}

// 遍历工程所有 HmiPage，根据页面 ID 查找页面，找不到返回空指针  
const HmiPage *HmiEditorService::findPage(const std::string &page_id) const
{
    const Project &project = project_service_.project();
    const auto page = std::find_if(
        project.hmiPages.cbegin(),
        project.hmiPages.cend(),
        [&page_id](const HmiPage &candidate)
        {
            return candidate.id == page_id;
        });
    return page == project.hmiPages.cend() ? nullptr : &*page;
}

// 先找到页面 → 在页面内查找指定控件；页面不存在 / 控件不存在都返回 nullptr
const HmiControl *HmiEditorService::findControl(
    const std::string &page_id, const std::string &control_id) const
{
    const HmiPage *page = findPage(page_id);
    if (page == nullptr)
    {
        return nullptr;
    }
    const auto control = std::find_if(
        page->controls.cbegin(),
        page->controls.cend(),
        [&control_id](const HmiControl &candidate)
        {
            return candidate.id == control_id;
        });
    return control == page->controls.cend() ? nullptr : &*control;
}

// 获取第一个页面 ID；没有页面返回空字符串
std::string HmiEditorService::firstPageId() const
{
    const Project &project = project_service_.project();
    return project.hmiPages.empty() ? std::string{} : project.hmiPages.front().id;
}

// 保证工程至少存在一个 HMI 页面
HmiEditorResult HmiEditorService::ensureDefaultPage()
{
    if (!project_service_.project().hmiPages.empty())
    {
        if (project_service_.project().initialHmiPageId.empty())
        {
            Project &project = project_service_.editProject();
            project.initialHmiPageId = project.hmiPages.front().id;
        }
        return {true, HmiEditorError::None, {}, firstPageId()};
    }

    // 仅在首个控件操作前创建默认页面，空工程仍可正常保存
    HistoryState before = captureState();
    HmiPage page;
    page.id = "page-1";
    page.name = "主操作页面";

    Project &project = project_service_.editProject();
    project.hmiPages.push_back(std::move(page));
    project.initialHmiPageId = project.hmiPages.back().id;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, project.hmiPages.back().id};
}

HmiEditorResult HmiEditorService::addPage(const std::string &name)
{
    if (isBlank(name))
    {
        return failure(HmiEditorError::InvalidPage, "HMI 页面名称不能为空");
    }
    const Project &current = project_service_.project();
    if (current.hmiPages.size() >= ProjectLimits::kMaximumHmiPages)
    {
        return failure(HmiEditorError::InvalidPage, "单个工程最多包含 128 个 HMI 页面");
    }
    if (name.size() > ProjectLimits::kMaximumTextBytes)
    {
        return failure(HmiEditorError::InvalidPage, "HMI 页面名称不能超过 4096 个 UTF-8 字节");
    }
    const bool duplicate = std::any_of(
        current.hmiPages.cbegin(), current.hmiPages.cend(),
        [&name](const HmiPage &page) { return page.name == name; });
    if (duplicate)
    {
        return failure(HmiEditorError::DuplicateName, "HMI 页面名称必须唯一");
    }

    HmiPage page;
    page.id = makeUniquePageId(current);
    page.name = name;
    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    project.hmiPages.push_back(std::move(page));
    if (project.initialHmiPageId.empty())
    {
        project.initialHmiPageId = project.hmiPages.back().id;
    }
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, project.hmiPages.back().id};
}

HmiEditorResult HmiEditorService::resizePage(
    const std::string &page_id, int width, int height)
{
    const HmiPage *page = findPage(page_id);
    if (page == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (page->width == width && page->height == height)
    {
        return {true, HmiEditorError::None, {}, page_id};
    }

    // 先在副本上校验新页面边界，失败时不触碰当前工程
    HmiPage candidate = *page;
    candidate.width = width;
    candidate.height = height;
    std::string error;
    if (!candidate.validate(&error))
    {
        return failure(HmiEditorError::InvalidPage, error);
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto editable = std::find_if(
        project.hmiPages.begin(), project.hmiPages.end(),
        [&page_id](const HmiPage &item) { return item.id == page_id; });
    editable->width = width;
    editable->height = height;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, page_id};
}

HmiEditorResult HmiEditorService::renamePage(
    const std::string &page_id, const std::string &name)
{
    if (isBlank(name))
    {
        return failure(HmiEditorError::InvalidPage, "HMI 页面名称不能为空");
    }
    if (name.size() > ProjectLimits::kMaximumTextBytes)
    {
        return failure(HmiEditorError::InvalidPage, "HMI 页面名称不能超过 4096 个 UTF-8 字节");
    }
    const Project &current = project_service_.project();
    const auto existing = std::find_if(
        current.hmiPages.cbegin(), current.hmiPages.cend(),
        [&page_id](const HmiPage &page) { return page.id == page_id; });
    if (existing == current.hmiPages.cend())
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    const bool duplicate = std::any_of(
        current.hmiPages.cbegin(), current.hmiPages.cend(),
        [&page_id, &name](const HmiPage &page)
        {
            return page.id != page_id && page.name == name;
        });
    if (duplicate)
    {
        return failure(HmiEditorError::DuplicateName, "HMI 页面名称必须唯一");
    }
    if (existing->name == name)
    {
        return {true, HmiEditorError::None, {}, page_id};
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto page = std::find_if(
        project.hmiPages.begin(), project.hmiPages.end(),
        [&page_id](const HmiPage &candidate) { return candidate.id == page_id; });
    page->name = name;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, page_id};
}

HmiEditorResult HmiEditorService::removePage(const std::string &page_id)
{
    const Project &current = project_service_.project();
    const auto page = std::find_if(
        current.hmiPages.cbegin(), current.hmiPages.cend(),
        [&page_id](const HmiPage &candidate) { return candidate.id == page_id; });
    if (page == current.hmiPages.cend())
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (current.hmiPages.size() <= 1)
    {
        return failure(HmiEditorError::LastPageRequired, "工程至少需要保留一个 HMI 页面");
    }
    if (current.initialHmiPageId == page_id)
    {
        return failure(
            HmiEditorError::InitialPageCannotBeRemoved,
            "请先设置其他初始页面，再删除当前页面");
    }
    for (const HmiPage &source_page : current.hmiPages)
    {
        const auto reference = std::find_if(
            source_page.controls.cbegin(), source_page.controls.cend(),
            [&page_id](const HmiControl &control)
            {
                return control.type == HmiControlType::PageJump
                    && control.pageJump.has_value()
                    && control.pageJump->targetPageId == page_id;
            });
        if (reference != source_page.controls.cend())
        {
            return failure(
                HmiEditorError::PageReferenced,
                "页面仍被跳转控件 " + reference->id + " 引用");
        }
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    project.hmiPages.erase(
        std::remove_if(
            project.hmiPages.begin(), project.hmiPages.end(),
            [&page_id](const HmiPage &candidate) { return candidate.id == page_id; }),
        project.hmiPages.end());
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, page_id};
}

HmiEditorResult HmiEditorService::movePage(const std::string &page_id, int offset)
{
    if (offset != -1 && offset != 1)
    {
        return failure(HmiEditorError::InvalidOperation, "页面每次只能上移或下移一位");
    }
    const Project &current = project_service_.project();
    const auto page = std::find_if(
        current.hmiPages.cbegin(), current.hmiPages.cend(),
        [&page_id](const HmiPage &candidate) { return candidate.id == page_id; });
    if (page == current.hmiPages.cend())
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    const auto index = std::distance(current.hmiPages.cbegin(), page);
    const std::ptrdiff_t target_index = index + offset;
    if (target_index < 0
        || target_index >= static_cast<std::ptrdiff_t>(current.hmiPages.size()))
    {
        return failure(HmiEditorError::InvalidOperation, "HMI 页面已经位于目标边界");
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    std::iter_swap(
        project.hmiPages.begin() + index,
        project.hmiPages.begin() + target_index);
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, page_id};
}

HmiEditorResult HmiEditorService::setInitialPage(const std::string &page_id)
{
    if (findPage(page_id) == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (project_service_.project().initialHmiPageId == page_id)
    {
        return {true, HmiEditorError::None, {}, page_id};
    }
    HistoryState before = captureState();
    project_service_.editProject().initialHmiPageId = page_id;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, page_id};
}

HmiEditorResult HmiEditorService::addControl(
    const std::string &page_id, HmiControlType type)
{
    const HmiPage *page = findPage(page_id);
    if (page == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (page->controls.size() >= ProjectLimits::kMaximumHmiControlsPerPage)
    {
        return failure(HmiEditorError::InvalidControl, "单个 HMI 页面最多包含 512 个控件");
    }
    const HmiControlDescriptor *descriptor = findHmiControlDescriptor(type);
    if (descriptor == nullptr)
    {
        return failure(HmiEditorError::InvalidControl, "不支持的 HMI 控件类型");
    }

    // 新控件初始不绑定寄存器，避免自动分配地址造成误写风险
    HmiControl control = makeControl(*page, *descriptor);
    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto target_page = std::find_if(
        project.hmiPages.begin(),
        project.hmiPages.end(),
        [&page_id](const HmiPage &candidate)
    {
        return candidate.id == page_id;
        });
    target_page->controls.push_back(std::move(control));
    recordHistory(std::move(before));
    return {true,
            HmiEditorError::None,
            {},
            target_page->controls.back().id};
}

HmiEditorResult HmiEditorService::removeControl(
    const std::string &page_id, const std::string &control_id)
{
    return removeControls(page_id, {control_id});
}

HmiEditorResult HmiEditorService::removeControls(
    const std::string &page_id,
    const std::vector<std::string> &control_ids)
{
    if (findPage(page_id) == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (control_ids.empty())
    {
        return failure(HmiEditorError::InvalidOperation, "请先选择要删除的 HMI 控件");
    }
    std::set<std::string> selected_ids;
    for (const std::string &control_id : control_ids)
    {
        if (!selected_ids.insert(control_id).second)
        {
            return failure(HmiEditorError::InvalidOperation, "删除列表中存在重复控件");
        }
        if (findControl(page_id, control_id) == nullptr)
        {
            return failure(HmiEditorError::ControlNotFound, "未找到 HMI 控件");
        }
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto page = std::find_if(
        project.hmiPages.begin(),
        project.hmiPages.end(),
        [&page_id](const HmiPage &candidate)
        {
            return candidate.id == page_id;
        });
    page->controls.erase(
        std::remove_if(
            page->controls.begin(),
            page->controls.end(),
            [&selected_ids](const HmiControl &candidate)
            {
                return selected_ids.find(candidate.id) != selected_ids.end();
            }),
        page->controls.end());
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, control_ids.front()};
}

// 移动 / 缩放控件
HmiEditorResult HmiEditorService::moveControl(
    const std::string &page_id,
    const std::string &control_id,
    const HmiRect &bounds)
{
    const HmiPage *page = findPage(page_id);
    const HmiControl *control = findControl(page_id, control_id);
    if (page == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (control == nullptr)
    {
        return failure(HmiEditorError::ControlNotFound, "未找到 HMI 控件");
    }

    // 先校验候选位置，失败时不修改工程模型
    HmiControl candidate = *control;
    candidate.bounds = bounds;
    // 更新前保留原控件，只有全部编辑规则通过才覆盖原值
    std::string error;
    if (!validateEditableControl(*page, candidate, &error))
    {
        return failure(HmiEditorError::InvalidControl, error);
    }
    if (control->bounds.x == bounds.x
        && control->bounds.y == bounds.y
        && control->bounds.width == bounds.width
        && control->bounds.height == bounds.height)
    {
        return {true, HmiEditorError::None, {}, control_id};
    }

    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto target = std::find_if(
        project.hmiPages.begin(), project.hmiPages.end(),
        [&page_id](const HmiPage &item) { return item.id == page_id; });
    auto editable = std::find_if(
        target->controls.begin(), target->controls.end(),
        [&control_id](const HmiControl &item) { return item.id == control_id; });
    editable->bounds = bounds;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, control_id};
}

// 更新控件全部属性
HmiEditorResult HmiEditorService::updateControl(
    const std::string &page_id,
    const std::string &control_id,
    const HmiControl &control)
{
    const HmiPage *page = findPage(page_id);
    const HmiControl *existing = findControl(page_id, control_id);
    if (page == nullptr)
    {
        return failure(HmiEditorError::PageNotFound, "未找到 HMI 页面");
    }
    if (existing == nullptr)
    {
        return failure(HmiEditorError::ControlNotFound, "未找到 HMI 控件");
    }
    if (control.type != existing->type)
    {
        return failure(HmiEditorError::InvalidControl, "不能修改已创建 HMI 控件的类型");
    }

    std::string error;
    if (!validateEditableControl(*page, control, &error))
    {
        return failure(HmiEditorError::InvalidControl, error);
    }
    if (hasDuplicateControlId(*page, control_id, control.id))
    {
        return failure(HmiEditorError::DuplicateId, "同一 HMI 页面内的控件 ID 必须唯一");
    }

    if (controlsEqual(*existing, control))
    {
        return {true, HmiEditorError::None, {}, control.id};
    }
    HistoryState before = captureState();
    Project &project = project_service_.editProject();
    auto target = std::find_if(
        project.hmiPages.begin(), project.hmiPages.end(),
        [&page_id](const HmiPage &item) { return item.id == page_id; });
    auto editable = std::find_if(
        target->controls.begin(), target->controls.end(),
        [&control_id](const HmiControl &item) { return item.id == control_id; });
    *editable = control;
    recordHistory(std::move(before));
    return {true, HmiEditorError::None, {}, control.id};
}

bool HmiEditorService::canUndo() const
{
    return history_.canUndo();
}

bool HmiEditorService::canRedo() const
{
    return history_.canRedo();
}

HmiEditorResult HmiEditorService::undo()
{
    const std::optional<HistoryState> target = history_.undo(captureState());
    if (!target.has_value())
    {
        return historyFailure("没有可撤销的 HMI 编辑操作");
    }
    Project &project = project_service_.editProject();
    project.hmiPages = target->pages;
    project.initialHmiPageId = target->initial_page_id;
    return {true, HmiEditorError::None, {}, {}};
}

HmiEditorResult HmiEditorService::redo()
{
    const std::optional<HistoryState> target = history_.redo(captureState());
    if (!target.has_value())
    {
        return historyFailure("没有可重做的 HMI 编辑操作");
    }
    Project &project = project_service_.editProject();
    project.hmiPages = target->pages;
    project.initialHmiPageId = target->initial_page_id;
    return {true, HmiEditorError::None, {}, {}};
}

void HmiEditorService::clearHistory()
{
    history_.clear();
}

bool HmiEditorService::validateEditableControl(
    const HmiPage &page, const HmiControl &control, std::string *error) const
{
    if (!control.validate(error))
    {
        return false;
    }
    if (control.bounds.x < 0 || control.bounds.y < 0
        || control.bounds.width > page.width || control.bounds.height > page.height
        || control.bounds.x > page.width - control.bounds.width
        || control.bounds.y > page.height - control.bounds.height)
    {
        setError(error, "HMI 控件不能超出页面范围");
        return false;
    }
    if (control.type == HmiControlType::PageJump
        && !control.pageJump->targetPageId.empty()
        && findPage(control.pageJump->targetPageId) == nullptr)
    {
        setError(error, "页面跳转控件的目标页面不存在");
        return false;
    }
    return true;
}

bool HmiEditorService::hasDuplicateControlId(
    const HmiPage &page,
    const std::string &excluded_id,
    const std::string &candidate_id)
{
    return std::any_of(
        page.controls.cbegin(), page.controls.cend(),
        [&excluded_id, &candidate_id](const HmiControl &item)
        {
            return item.id != excluded_id && item.id == candidate_id;   // 如果这个控件不是正在编辑的原控件,并且它的 ID 等于准备使用的新 ID
        });
}

// 根据控件类型生成默认样式、文字、大小、初始坐标
HmiControl HmiEditorService::makeControl(
    const HmiPage &page, const HmiControlDescriptor &descriptor)
{
    HmiControl control;
    control.id = makeUniqueId(page, descriptor.idPrefix);
    control.type = descriptor.type;
    control.text = descriptor.defaultText;
    control.bounds.width = std::min(descriptor.defaultBounds.width, page.width);
    control.bounds.height = std::min(descriptor.defaultBounds.height, page.height);
    if (descriptor.type == HmiControlType::PageJump)
    {
        control.pageJump = HmiPageJumpConfig{};
    }
    if (descriptor.type == HmiControlType::ProgressBar)
    {
        control.progressBar = HmiProgressBarConfig{};
    }
    const int offset = static_cast<int>(page.controls.size()) * 16;
    control.bounds.x = std::min(20 + offset, page.width - control.bounds.width);
    control.bounds.y = std::min(20 + offset, page.height - control.bounds.height);
    return control;
}

// 生成页面内不重复控件 ID，前缀 + 自增数字
std::string HmiEditorService::makeUniqueId(
    const HmiPage &page, const std::string &prefix)
{
    // 同类控件从 1 递增命名，保证页面内标识稳定且唯一
    int suffix = 1;
    while (true)
    {
        const std::string candidate = prefix + '-' + std::to_string(suffix);
        const bool found = std::any_of(
            page.controls.cbegin(), page.controls.cend(),
            [&candidate](const HmiControl &item) { return item.id == candidate; });
        if (!found)
        {
            return candidate;
        }
        ++suffix;
    }
}