#include "VrConfig.h"
#include <iostream>
#include <vector>
#include <string>

using namespace tinyxml2;

CVrConfig::CVrConfig()
{
    // 构造函数
}

CVrConfig::~CVrConfig()
{
    // 析构函数
}

ConfigResult CVrConfig::LoadConfig(const std::string& filePath)
{
    ConfigResult result;
    
    // 使用tinyxml2库加载XML文件
    XMLDocument doc;
    XMLError err = doc.LoadFile(filePath.c_str());
    if (err != XML_SUCCESS)
    {
        std::cerr << "open config file failed: " << filePath << std::endl;
        return result;
    }

    // 获取根元素
    XMLElement* root = doc.RootElement();
    if (!root || std::string(root->Name()) != "VrConfig")
    {
        std::cerr << "config file format error: root element is not VrConfig" << std::endl;
        return result;
    }

    // 解析摄像头列表
    XMLElement* camerasElement = root->FirstChildElement("Cameras");
    if (camerasElement)
    {
        XMLElement* cameraElement = camerasElement->FirstChildElement("Camera");
        while (cameraElement)
        {
            DeviceInfo camera;
            if (cameraElement->Attribute("name"))
                camera.name = cameraElement->Attribute("name");
            
            if (cameraElement->Attribute("ip"))
                camera.ip = cameraElement->Attribute("ip");
            
            result.cameraList.push_back(camera);
            cameraElement = cameraElement->NextSiblingElement("Camera");
        }
    }

    // 解析设备列表
    XMLElement* devicesElement = root->FirstChildElement("Devices");
    if (devicesElement)
    {
        XMLElement* deviceElement = devicesElement->FirstChildElement("Device");
        while (deviceElement)
        {
            DeviceInfo device;
            if (deviceElement->Attribute("name"))
                device.name = deviceElement->Attribute("name");
            
            if (deviceElement->Attribute("ip"))
                device.ip = deviceElement->Attribute("ip");
            
            result.deviceList.push_back(device);
            deviceElement = deviceElement->NextSiblingElement("Device");
        }
    }

    // 解析算法参数
    XMLElement* algoParamsElement = root->FirstChildElement("AlgorithmParams");
    if (algoParamsElement)
    {
        // 解析编织袋参数
        XMLElement* bagParamElement = algoParamsElement->FirstChildElement("BagParam");
        if (bagParamElement)
        {
            if (bagParamElement->Attribute("bagL"))
                result.algorithmParams.bagParam.bagL = bagParamElement->DoubleAttribute("bagL");
            if (bagParamElement->Attribute("bagW"))
                result.algorithmParams.bagParam.bagW = bagParamElement->DoubleAttribute("bagW");
            if (bagParamElement->Attribute("bagH"))
                result.algorithmParams.bagParam.bagH = bagParamElement->DoubleAttribute("bagH");
        }
        
        // 解析滤波参数
        XMLElement* filterParamElement = algoParamsElement->FirstChildElement("FilterParam");
        if (filterParamElement)
        {
            if (filterParamElement->Attribute("continuityTh"))
                result.algorithmParams.filterParam.continuityTh = filterParamElement->DoubleAttribute("continuityTh");
            if (filterParamElement->Attribute("outlierTh"))
                result.algorithmParams.filterParam.outlierTh = filterParamElement->IntAttribute("outlierTh");
        }
        
        // 解析角点特征参数
        XMLElement* cornerParamElement = algoParamsElement->FirstChildElement("CornerParam");
        if (cornerParamElement)
        {
            if (cornerParamElement->Attribute("minEndingGap"))
                result.algorithmParams.cornerParam.minEndingGap = cornerParamElement->DoubleAttribute("minEndingGap");
            if (cornerParamElement->Attribute("scale"))
                result.algorithmParams.cornerParam.scale = cornerParamElement->DoubleAttribute("scale");
            if (cornerParamElement->Attribute("cornerTh"))
                result.algorithmParams.cornerParam.cornerTh = cornerParamElement->DoubleAttribute("cornerTh");
            if (cornerParamElement->Attribute("jumpCornerTh_1"))
                result.algorithmParams.cornerParam.jumpCornerTh_1 = cornerParamElement->DoubleAttribute("jumpCornerTh_1");
            if (cornerParamElement->Attribute("jumpCornerTh_2"))
                result.algorithmParams.cornerParam.jumpCornerTh_2 = cornerParamElement->DoubleAttribute("jumpCornerTh_2");
        }
        
        // 解析斜率参数
        XMLElement* slopeParamElement = algoParamsElement->FirstChildElement("SlopeParam");
        if (slopeParamElement)
        {
            if (slopeParamElement->Attribute("LSlopeZWin"))
                result.algorithmParams.slopeParam.LSlopeZWin = slopeParamElement->DoubleAttribute("LSlopeZWin");
            if (slopeParamElement->Attribute("validSlopeH"))
                result.algorithmParams.slopeParam.validSlopeH = slopeParamElement->DoubleAttribute("validSlopeH");
            if (slopeParamElement->Attribute("minLJumpH"))
                result.algorithmParams.slopeParam.minLJumpH = slopeParamElement->DoubleAttribute("minLJumpH");
            if (slopeParamElement->Attribute("minEndingGap"))
                result.algorithmParams.slopeParam.minEndingGap = slopeParamElement->DoubleAttribute("minEndingGap");
        }
        
        // 解析山谷参数
        XMLElement* valleyParamElement = algoParamsElement->FirstChildElement("ValleyParam");
        if (valleyParamElement)
        {
            if (valleyParamElement->Attribute("valleyMinH"))
                result.algorithmParams.valleyParam.valleyMinH = valleyParamElement->DoubleAttribute("valleyMinH");
            if (valleyParamElement->Attribute("valleyMaxW"))
                result.algorithmParams.valleyParam.valleyMaxW = valleyParamElement->DoubleAttribute("valleyMaxW");
        }
        
        // 解析增长参数
        XMLElement* growParamElement = algoParamsElement->FirstChildElement("GrowParam");
        if (growParamElement)
        {
            if (growParamElement->Attribute("maxLineSkipNum"))
                result.algorithmParams.growParam.maxLineSkipNum = growParamElement->IntAttribute("maxLineSkipNum");
            if (growParamElement->Attribute("yDeviation_max"))
                result.algorithmParams.growParam.yDeviation_max = growParamElement->DoubleAttribute("yDeviation_max");
            if (growParamElement->Attribute("maxSkipDistance"))
                result.algorithmParams.growParam.maxSkipDistance = growParamElement->DoubleAttribute("maxSkipDistance");
            if (growParamElement->Attribute("zDeviation_max"))
                result.algorithmParams.growParam.zDeviation_max = growParamElement->DoubleAttribute("zDeviation_max");
            if (growParamElement->Attribute("minLTypeTreeLen"))
                result.algorithmParams.growParam.minLTypeTreeLen = growParamElement->DoubleAttribute("minLTypeTreeLen");
            if (growParamElement->Attribute("minVTypeTreeLen"))
                result.algorithmParams.growParam.minVTypeTreeLen = growParamElement->DoubleAttribute("minVTypeTreeLen");
        }
        
        // 解析平面校准参数
        XMLElement* planeCalibParamElement = algoParamsElement->FirstChildElement("PlaneCalibParam");
        if (planeCalibParamElement)
        {
            if (planeCalibParamElement->Attribute("planeHeight"))
                result.algorithmParams.planeCalibParam.planeHeight = planeCalibParamElement->DoubleAttribute("planeHeight");
        }
    }

    return result;
}

bool CVrConfig::SaveConfig(const std::string& filePath, ConfigResult& configResult)
{
    // 创建XML文档
    XMLDocument doc;
    
    // 添加声明
    XMLDeclaration* declaration = doc.NewDeclaration("xml version=\"1.0\" encoding=\"UTF-8\"");
    doc.InsertFirstChild(declaration);

    // 创建根元素
    XMLElement* root = doc.NewElement("VrConfig");
    doc.InsertEndChild(root);

    // 添加摄像头列表
    XMLElement* camerasElement = doc.NewElement("Cameras");
    root->InsertEndChild(camerasElement);
    
    for (const auto& camera : configResult.cameraList)
    {
        XMLElement* cameraElement = doc.NewElement("Camera");
        cameraElement->SetAttribute("name", camera.name.c_str());
        cameraElement->SetAttribute("ip", camera.ip.c_str());
        camerasElement->InsertEndChild(cameraElement);
    }

    // 添加设备列表
    XMLElement* devicesElement = doc.NewElement("Devices");
    root->InsertEndChild(devicesElement);
    
    for (const auto& device : configResult.deviceList)
    {
        XMLElement* deviceElement = doc.NewElement("Device");
        deviceElement->SetAttribute("name", device.name.c_str());
        deviceElement->SetAttribute("ip", device.ip.c_str());
        devicesElement->InsertEndChild(deviceElement);
    }

    // 保存到文件
    XMLError err = doc.SaveFile(filePath.c_str());
    if (err != XML_SUCCESS)
    {
        std::cerr << "无法保存配置文件: " << filePath << std::endl;
        return false;
    }

    return true;
}


/**
 * @brief 创建实例
 * @return 实例
 */
bool IVrConfig::CreateInstance(IVrConfig** ppVrConfig)
{
    *ppVrConfig = new CVrConfig()   ;
    return *ppVrConfig != nullptr;
}