#include "workspace/WorkSpace.h"

#include <QUUID>

#include "workspace/WorkSpaceXMLParse.h"
#include "workspace/WorkSpaceXMLWrite.h"

#include "workspace/WorkSpaceItem.h"
#include "workspace/Timestep.h"
#include "workspace/LampStatus.h"

#include "xml/tinyxml2.h"
#include "common/SpdLogger.h"
#include "entities/Entity.h"
//#include "workspace/WorkSpaceItemGroup.h"
//#include "workspace/WorkSpaceRiverGroup.h"
//#include "workspace/WorkSpaceRiverNetGroup.h"

Q_DECLARE_METATYPE(WorkSpace*)

WorkSpace::WorkSpace(QObject* parent) noexcept
    : QObject(parent) {
    uuid_ = QUuid::createUuid().toString();
}

WorkSpace::WorkSpace(const QString& path, QObject* parent)
    : QObject(parent)
    , path_(path){
    uuid_ = QUuid::createUuid().toString();
}


void WorkSpace::AddEntity(Entity* entity) {
    if (nullptr == entity) {
        LOG_WARN("entity is nullptr");
        return;
    }
    LOG_INFO("add entity: {}", entity->GetName().toLocal8Bit().constData());
    entities_.push_back(entity);
    entity->SetWorkspace(this);

    emit EntityAdded(entity);
}

void WorkSpace::RemoveEntity(Entity* entity) {
    auto itor = std::find_if(entities_.begin(), entities_.end(),
        [this, entity](const auto* item) { return item == entity; });
    if (itor != entities_.end()) {
        emit EntityRemoved(entity);
        entities_.erase(itor);
    }
}

bool WorkSpace::SetTimestep(Timestep* timestep) {
    if (!timestep) {
        return false;
    }

    if (nullptr != timestep_ && timestep_ != timestep) {
        timestep_->deleteLater();
    }

    timestep_ = timestep;
    emit TimestepChanged(timestep_);
    return true;
}

bool WorkSpace::SetTimestepPath(const QString& path) {
    Timestep* timestep = Timestep::Load(path, this);

    return SetTimestep(timestep);
}

bool WorkSpace::SetLampStatus(class LampStatus* lampStatus) {
    if (!lampStatus) {
        return false;
    }

    if (nullptr != lampStatus_ && lampStatus_ != lampStatus) {
        lampStatus_->deleteLater();
    }

    lampStatus_ = lampStatus;
    emit LampStatusChanged(lampStatus_);
    return true;
}

bool WorkSpace::SetLampPath(const QString& path) {
    LampStatus* timestep = LampStatus::Load(path, this);

    return SetLampStatus(timestep);
}

bool WorkSpace::Save(const QString& path) {
    path_ = path;
    return Save();
}

bool WorkSpace::Save() {
    WorkSpaceXMLWrite xmlWrite(this);
    return xmlWrite.Save(path_);
}

bool WorkSpace::Load(const QString& dyt) {
    if (leaded_) {
        LOG_INFO("dyt {} loaded", dyt.toStdString());
        return true;
    }
    WorkSpaceXMLParse parse(this);
    bool success = parse.Load(dyt);
    if (success) {
        path_ = dyt;
    }
    leaded_ = success;
    return success;
}

void WorkSpace::Unlaod() {
    if (!leaded_) {
        LOG_INFO("dyt {} unloaded", name_.toStdString());
        return;
    }
    while (!entities_.empty()) {
        auto entity = entities_.front();
        entity->Destory();
    }
    leaded_ = false;
}

void WorkSpace::Begin() {
    for (auto item : entities_) {
        item->Begin();
    }
}

void WorkSpace::OnFrame(double dt) {
    if (nullptr != lampStatus_) {
        double current = timestep_->GetCurrent();
        lampStatus_->OnFrame(current);
    }

    for (auto item : entities_) {
        item->Update(dt);
    }
}

void WorkSpace::End() {
    for (auto item : entities_) {
        item->End();
    }
}

void WorkSpace::OnLoaded() {
    if (nullptr != lampStatus_) {
        emit LampStatusChanged(lampStatus_);
    }
    if (nullptr != timestep_) {
        emit TimestepChanged(timestep_);
    }
}