#include "stdafx.h"
#include <sstream>
#include <fstream>
#include <iostream>
#include "AxisManager.h"
#include "ToolUnits.h"

// ¹¹Ô캯Êý
AxisManager::AxisManager() {
    m_directory = CToolUnits::getCurrentExePath() + _T("\\PLCs");
    if (!CToolUnits::isDirectory(m_directory)) {
        CToolUnits::createDir(m_directory.c_str());
    }
}

// ¼ÓÔØÖáÐÅÏ¢
bool AxisManager::LoadAxes(pugi::xml_node axesNode) {
    m_axes.clear();
    for (auto axisNode : axesNode.children("Axis")) {
        AxisInfo axisInfo;
        axisInfo.id = axisNode.attribute("id").as_int();
        axisInfo.number = axisNode.attribute("number").value();
        axisInfo.description = axisNode.attribute("description").value();
        axisInfo.startAddress = axisNode.attribute("start_address").value();

        // ¼ÓÔØ ValueRange Öµ
        axisInfo.jogDistance = ValueRange(
            axisNode.child("jog_distance").attribute("min").as_double(),
            axisNode.child("jog_distance").attribute("max").as_double(),
            axisNode.child("jog_distance").attribute("current").as_double()
        );
        axisInfo.manualSpeed = ValueRange(
            axisNode.child("manual_speed").attribute("min").as_double(),
            axisNode.child("manual_speed").attribute("max").as_double(),
            axisNode.child("manual_speed").attribute("current").as_double()
        );
        axisInfo.autoSpeed = ValueRange(
            axisNode.child("auto_speed").attribute("min").as_double(),
            axisNode.child("auto_speed").attribute("max").as_double(),
            axisNode.child("auto_speed").attribute("current").as_double()
        );
        axisInfo.accelerationTime = ValueRange(
            axisNode.child("acceleration_time").attribute("min").as_double(),
            axisNode.child("acceleration_time").attribute("max").as_double(),
            axisNode.child("acceleration_time").attribute("current").as_double()
        );
        axisInfo.decelerationTime = ValueRange(
            axisNode.child("deceleration_time").attribute("min").as_double(),
            axisNode.child("deceleration_time").attribute("max").as_double(),
            axisNode.child("deceleration_time").attribute("current").as_double()
        );

        // ¼ÓÔØ PositionRange Öµ
        axisInfo.positioningPointCount = axisNode.child("Positions").attribute("positioningPointCount").as_int();
        for (auto positionNode : axisNode.child("Positions").children("Position")) {
            bool isEnable = positionNode.attribute("isEnable").as_bool();
            std::string description = positionNode.attribute("description").value();
            ValueRange positionRange(
                positionNode.attribute("min").as_double(),
                positionNode.attribute("max").as_double(),
                positionNode.attribute("current").as_double()
            );

            axisInfo.positions.emplace_back(PositionRange(isEnable, description, positionRange));
        }

        m_axes[axisInfo.id] = axisInfo;
    }

    return true;
}

// ±£´æÖáÐÅÏ¢
void AxisManager::SaveAxes(pugi::xml_node& axesNode) {
    for (const auto& axisEntry : m_axes) {
        const AxisInfo& axisInfo = axisEntry.second;

        auto axisNode = axesNode.append_child("Axis");
        axisNode.append_attribute("id") = axisInfo.id;
        axisNode.append_attribute("number") = axisInfo.number.c_str();
        axisNode.append_attribute("description") = axisInfo.description.c_str();
        axisNode.append_attribute("start_address") = axisInfo.startAddress.c_str();

        // ±£´æ ValueRange Öµ
        auto jog_distance = axisNode.append_child("jog_distance");
        jog_distance.append_attribute("min") = axisInfo.jogDistance.minValue;
        jog_distance.append_attribute("max") = axisInfo.jogDistance.maxValue;
        jog_distance.append_attribute("current") = axisInfo.jogDistance.currentValue;

        auto manual_speed = axisNode.append_child("manual_speed");
        manual_speed.append_attribute("min") = axisInfo.manualSpeed.minValue;
        manual_speed.append_attribute("max") = axisInfo.manualSpeed.maxValue;
        manual_speed.append_attribute("current") = axisInfo.manualSpeed.currentValue;

        auto auto_speed = axisNode.append_child("auto_speed");
        auto_speed.append_attribute("min") = axisInfo.autoSpeed.minValue;
        auto_speed.append_attribute("max") = axisInfo.autoSpeed.maxValue;
        auto_speed.append_attribute("current") = axisInfo.autoSpeed.currentValue;

        auto acceleration_time = axisNode.append_child("acceleration_time");
        acceleration_time.append_attribute("min") = axisInfo.accelerationTime.minValue;
        acceleration_time.append_attribute("max") = axisInfo.accelerationTime.maxValue;
        acceleration_time.append_attribute("current") = axisInfo.accelerationTime.currentValue;

        auto deceleration_time = axisNode.append_child("deceleration_time");
        deceleration_time.append_attribute("min") = axisInfo.decelerationTime.minValue;
        deceleration_time.append_attribute("max") = axisInfo.decelerationTime.maxValue;
        deceleration_time.append_attribute("current") = axisInfo.decelerationTime.currentValue;

        // ±£´æ PositionRange Öµ
        auto positionsNode = axisNode.append_child("Positions");
        positionsNode.append_attribute("positioningPointCount") = axisInfo.positioningPointCount;
        for (const auto& position : axisInfo.positions) {
            auto positionNode = positionsNode.append_child("Position");
            positionNode.append_attribute("isEnable") = position.isEnable;
            positionNode.append_attribute("description") = position.description.c_str();
            positionNode.append_attribute("min") = position.range.minValue;
            positionNode.append_attribute("max") = position.range.maxValue;
            positionNode.append_attribute("current") = position.range.currentValue;
        }
    }
}

// ¼ÓÔØÅä·½£¨Èç¹ûÎļþ²»´æÔÚ£¬¼ÓÔØĬÈÏÊý¾Ý£©
bool AxisManager::LoadAxis(const std::string& strName) {
    std::string filePath = m_directory + "\\" + strName + "\\" + "AxesConfiguration.xml";
    pugi::xml_document doc;

    if (!doc.load_file(filePath.c_str())) {
        std::cerr << "Recipe file not found: " << filePath << ". Loading default recipe." << std::endl;
        return false;
    }

    auto rootNode = doc.child("root");
    LoadAxes(rootNode);

    return true;
}

// ±£´æÅä·½
bool AxisManager::SaveAxis(const std::string& strName) {
    // Éú³ÉÎļþ·¾¶
    std::string filePath = m_directory + "\\" + strName + "\\" + "AxesConfiguration.xml";

    // ´´½¨ XML Îĵµ¶ÔÏó
    pugi::xml_document doc;

    // Èç¹ûÖáÊý¾ÝΪ¿Õ£¬Éú³ÉĬÈÏÅä·½
    if (m_axes.empty()) {
        GenerateDefaultData();
    }

    // Ìí¼ÓÖáÐÅÏ¢
    auto rootNode = doc.append_child("root");
    SaveAxes(rootNode);

    // ±£´æ XML Îļþ
    return doc.save_file(filePath.c_str());
}

// Éú³ÉĬÈÏÅä·½
void AxisManager::GenerateDefaultData() {
    m_axes.clear();
    for (int axisId = 1; axisId <= 12; ++axisId) {
        AxisInfo axisInfo;
        axisInfo.id = axisId;
        axisInfo.positioningPointCount = 25;
        axisInfo.number = "M100-M" + std::to_string(axisId);
        axisInfo.description = "Default_Axis" + std::to_string(axisId);
        axisInfo.startAddress = "ZR" + std::to_string(10000 + (axisId - 1) * 300);

        // ÉèÖÃĬÈ쵀 ValueRange
        axisInfo.jogDistance = ValueRange(0.0, 0.1, 0.0);
        axisInfo.manualSpeed = ValueRange(0.001, 100.0, 10.0);
        axisInfo.autoSpeed = ValueRange(0.001, 100.0, 10.0);
        axisInfo.accelerationTime = ValueRange(0.001, 10.0, 0.3);
        axisInfo.decelerationTime = ValueRange(0.001, 10.0, 0.3);

        // Ìí¼Ó¶¨Î»µã²¢ÉèÖÃĬÈϵÄ×îСֵºÍ×î´óÖµ
        for (int posId = 0; posId < axisInfo.positioningPointCount; ++posId) {
            axisInfo.positions.emplace_back(PositionRange(TRUE, "Position " + std::to_string(posId + 1), ValueRange(0, 100, 0)));
        }

        m_axes[axisId] = axisInfo;
    }
}

// »ñÈ¡ËùÓÐÖáÐÅÏ¢
const std::map<int, AxisInfo>& AxisManager::GetAxes() const {
    return m_axes;
}

// »ñÈ¡µ¥¸öÖáÐÅÏ¢
AxisInfo AxisManager::GetAxis(int axisId) const {
    auto it = m_axes.find(axisId);
    if (it != m_axes.end()) {
        return it->second;  // Èç¹ûÕÒµ½ÁËÖᣬ·µ»ØÆäÏêϸÐÅÏ¢
    }

    // Èç¹ûûÓÐÕÒµ½¸ÃÖᣬ·µ»ØÒ»¸öĬÈϵÄÎÞЧ AxisInfo
    return AxisInfo{ -1, 0, /*0.0, 0.0,*/ "", "", "", ValueRange(), ValueRange(), ValueRange(), ValueRange(), ValueRange(), {} };
}

// ¸üÐÂÖáÐÅÏ¢
bool AxisManager::UpdateAxis(const AxisInfo& axisInfo) {
    if (m_axes.find(axisInfo.id) == m_axes.end()) {
        return false; // Öá²»´æÔÚ
    }
    m_axes[axisInfo.id] = axisInfo;
    return true;
}

// Ìí¼ÓеÄÖáÐÅÏ¢
bool AxisManager::AddAxis(const AxisInfo& axisInfo) {
    if (m_axes.find(axisInfo.id) != m_axes.end()) {
        return false; // ÖáÒÑ´æÔÚ
    }
    m_axes[axisInfo.id] = axisInfo;
    return true;
}

// ɾ³ýÖáÐÅÏ¢
bool AxisManager::DeleteAxis(int axisId) {
    return m_axes.erase(axisId) > 0;
}

// »ñÈ¡ËùÓÐÖá±àºÅ
std::vector<int> AxisManager::GetAllAxisID() const {
    std::vector<int> axisNumbers;
    for (const auto& axis : m_axes) {
        int axisId = axis.first;
        axisNumbers.push_back(axisId);
    }

    return axisNumbers;
}

// »ñÈ¡Ö¸¶¨Ò³µÄ¶¨Î»µã
std::vector<PositionRange> AxisManager::GetPositions(int axisId, int pageNumber, int pageSize) const {
    std::vector<PositionRange> result;

    // ¼ì²éÖáÊÇ·ñ´æÔÚ
    auto it = m_axes.find(axisId);
    if (it == m_axes.end()) {
        return result; // Èç¹ûÖá ID ²»´æÔÚ£¬·µ»Ø¿Õ½á¹û
    }

    // »ñÈ¡Ö¸¶¨ÖáµÄËùÓж¨Î»µã
    const auto& positions = it->second.positions;

    // È·¶¨·ÖÒ³·¶Î§
    int startIndex = (pageNumber - 1) * pageSize;
    int endIndex = startIndex + pageSize;

    // ±éÀú¶¨Î»µã£¬°´·ÖÒ³ÌáÈ¡Êý¾Ý
    int index = 0;
    for (const auto& pos : positions) {
        const PositionRange& position = pos;  // ¶¨Î»µã°üº¬ÃèÊö¡¢Î»Öá¢×îСֵ¡¢×î´óÖµºÍµ±Ç°Öµ

        if (index >= startIndex && index < endIndex) {
            result.push_back(position);  // Ìí¼ÓÍêÕûµÄ PositionRange ¶ÔÏó
        }

        ++index;
        if (index >= endIndex) {
            break; // ´ïµ½·ÖÒ³½áÊøµã
        }
    }

    return result;
}

// »ñÈ¡Ö¸¶¨ÖáµÄ¶¨Î»µã
PositionRange AxisManager::GetPositionByIndex(int axisId, int pageNumber, int pageSize, int currentIndex) const {
    // ¼ì²éÖáÊÇ·ñ´æÔÚ
    auto it = m_axes.find(axisId);
    if (it == m_axes.end()) {
        return PositionRange();  // Öá²»´æÔÚ£¬·µ»ØĬÈϹ¹ÔìµÄ PositionRange£¨ÎÞЧµÄ¶¨Î»µã£©
    }

    // »ñÈ¡Ö¸¶¨ÖáµÄËùÓж¨Î»µã
    const auto& positions = it->second.positions;

    // È·¶¨·ÖÒ³·¶Î§
    int startIndex = (pageNumber - 1) * pageSize;
    int endIndex = startIndex + pageSize;

    // Èç¹û currentIndex ³¬¹ýÁ˵±Ç°Ò³µÄ·¶Î§£¬·µ»ØÎÞЧµÄ PositionRange
    if (currentIndex < 0 || currentIndex >= pageSize || currentIndex + startIndex >= positions.size()) {
        return PositionRange();  // ·µ»ØÎÞЧµÄ¶¨Î»µã
    }

    // ·µ»ØÖ¸¶¨¶¨Î»µã£¨¿¼ÂÇ·ÖÒ³£©
    return positions[startIndex + currentIndex];
}