DYTSrouce/src/workspace/WorkSpaceXMLWrite.cpp

#include "workspace/WorkSpaceXMLWrite.h"

#include "workspace/WorkSpace.h"
#include "entities/EntitiesManager.h"
#include "entities/Entity.h"
#include "workspace/Timestep.h"
#include "workspace/LampStatus.h"

#include "common/SpdLogger.h"
#include "utils/StringUtils.h"

#include "workspace/WorkSpaceManager.h"
#include "workspace/FileEntry.h"

#include <QFileInfo>

WorkSpaceXMLWrite::WorkSpaceXMLWrite(WorkSpace* workspace, QObject* parent) noexcept
    : QObject(parent)
    , workSpace_(workspace) {}

bool WorkSpaceXMLWrite::Save(const QString& path) {
    LOG_INFO("save path: {}", path.toLocal8Bit().constData());
    if (nullptr == workSpace_) {
        LOG_WARN("worksapce is nullptr");
        return false;
    }
    tinyxml2::XMLDocument doc;

    doc.LinkEndChild(doc.NewDeclaration("xml version=\"1.0\" encoding=\"UTF-8\""));

    tinyxml2::XMLElement* scene = doc.NewElement("scene");
    if (!SaveScene(scene)) {
        return false;
    }

    doc.LinkEndChild(scene);

    SaveChart(scene, &doc);
    SaveTimeStep(scene);
	SaveLamp(scene);
    SaveCommond(scene);
    SaveFiles(scene, &doc);

    tinyxml2::XMLElement* entitiesXml = scene->InsertNewChildElement("entities");
    std::vector<Entity*>& entities = workSpace_->GetEntities();
    for (auto entity : entities) {
        entity->UnSerialize(entitiesXml);
    }

    tinyxml2::XMLError xmlError = doc.SaveFile(path.toLocal8Bit().constData(), false);
    if (tinyxml2::XML_SUCCESS != xmlError) {
        LOG_WARN("worksapce is nullptr");
        return false;
    }
    return true;
}

bool WorkSpaceXMLWrite::SaveScene(tinyxml2::XMLElement* scene) {
    const QString name = workSpace_->GetName();
    scene->SetAttribute("name", name.toStdString().c_str());
    scene->SetAttribute("describe", workSpace_->GetDescribe().toStdString().c_str());
    scene->SetAttribute("uuid", workSpace_->GetUUid().toStdString().c_str());
    scene->SetAttribute("viewpoint", StringUtils::ViewpointToString(workSpace_->GetHomeViewpoint()).c_str());
    scene->SetAttribute("commondPath", "");
    
    return true;
}

bool WorkSpaceXMLWrite::SaveTimeStep(tinyxml2::XMLElement* scene) {
    Timestep* timestep = workSpace_->GetTimestep();
    if (nullptr == timestep) {
        return false;
    }
    tinyxml2::XMLElement* timestepXml = scene->InsertNewChildElement("timestep");
    timestepXml->SetAttribute("path", timestep->GetPath().toStdString().c_str());
    return true;
}

bool WorkSpaceXMLWrite::SaveLamp(tinyxml2::XMLElement* scene) {
    tinyxml2::XMLElement* lamp = scene->InsertNewChildElement("lamp");
    const QString lampPath = workSpace_->GetLampStatus()->GetPath();
    if (!lampPath.isEmpty()) {
        lamp->SetAttribute("path", lampPath.toStdString().c_str());
    }
    return true;
}

bool WorkSpaceXMLWrite::SaveCommond(tinyxml2::XMLElement* scene) {
    const QString commondPath = workSpace_->GetCommondFilePath();
    if (!commondPath.isEmpty()) {
        tinyxml2::XMLElement* commond = scene->InsertNewChildElement("commond");
        // Extract just the filename from the full path for storage
        QFileInfo fileInfo(commondPath);
        commond->SetAttribute("path", fileInfo.fileName().toStdString().c_str());
    }
    return true;
}

bool WorkSpaceXMLWrite::SaveEntities(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) {
    tinyxml2::XMLElement* entitics = doc->NewElement("entities");
    scene->LinkEndChild(entitics);
    return true;
}

bool WorkSpaceXMLWrite::SaveChart(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc)
{
    tinyxml2::XMLElement* charts= doc->NewElement("charts");
    scene->LinkEndChild(charts);

    {
        tinyxml2::XMLElement* chart = doc->NewElement("Wave");
        charts->LinkEndChild(chart);

        chart->SetAttribute("file", workSpace_->GetWavePath().toLocal8Bit().constData());
    }

    {
        tinyxml2::XMLElement* chart = doc->NewElement("Report");
        charts->LinkEndChild(chart);

        chart->SetAttribute("Report", workSpace_->GetReportPath().toLocal8Bit().constData());
    }

    {
        tinyxml2::XMLElement* chart = doc->NewElement("RD");
        charts->LinkEndChild(chart);

        chart->SetAttribute("RD", workSpace_->GetRDPath().toLocal8Bit().constData());
    }

    {
        tinyxml2::XMLElement* chart = doc->NewElement("SimMatlab");
        charts->LinkEndChild(chart);

        chart->SetAttribute("SimMatlab", workSpace_->GetSimMatlabName().toLocal8Bit().constData());
    }
    
    return true;
}

bool WorkSpaceXMLWrite::SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) {
    // Persist multi-file entries per type as counts
    tinyxml2::XMLElement* files = doc->NewElement("files");
    scene->LinkEndChild(files);

    for (const auto& kv : workSpace_->files_) {
        const FileEntryType type = kv.first;
        const auto& vec = kv.second;
        tinyxml2::XMLElement* typeElem = doc->NewElement("type");
        typeElem->SetAttribute("name", FileEntryTypeToString(type));
        typeElem->SetAttribute("count", static_cast<int>(vec.size()));
        files->LinkEndChild(typeElem);
    }
    return true;
}