infinipaint/src/DrawingProgram/Layers/DrawingProgramLayerListItem.cpp

/*  
 * InfiniPaint
 * Copyright (C) 2025-2026 Yousef Khadadeh
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "DrawingProgramLayerListItem.hpp"
#include "DrawingProgramLayerFolder.hpp"
#include <cereal/types/string.hpp>
#include "DrawingProgramLayer.hpp"
#include "../../World.hpp"
#include "../../MainProgram.hpp"
#include "SerializedBlendMode.hpp"

using namespace NetworkingObjects;

void DrawingProgramLayerListItemUndoData::scale_up(const WorldScalar& scaleUpAmount) {
    if(folderData) {
        for(auto& l : folderData.value())
            l.scale_up(scaleUpAmount);
    }
    else {
        for(auto& c : layerData.value())
            c.copyData->scale_up(scaleUpAmount);
    }
}

DrawingProgramLayerListItem::DrawingProgramLayerListItem() {}

DrawingProgramLayerListItem::DrawingProgramLayerListItem(NetworkingObjects::NetObjManager& netObjMan, const std::string& initName, bool isFolder) {
    if(isFolder) {
        folderData = std::make_unique<DrawingProgramLayerFolder>();
        folderData->folderList = netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>>();
    }
    else {
        layerData = std::make_unique<DrawingProgramLayer>();
        layerData->components = netObjMan.make_obj<CanvasComponentContainer::NetList>();
    }
    nameData = netObjMan.make_obj<NameData>();
    nameData->name = initName;
    displayData = netObjMan.make_obj<DisplayData>();
}

DrawingProgramLayerListItem::DrawingProgramLayerListItem(World& w, const DrawingProgramLayerListItemUndoData& initData) {
    if(initData.folderData) {
        auto& initFolderList = initData.folderData.value();
        folderData = std::make_unique<DrawingProgramLayerFolder>();
        folderData->folderList = w.netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>>();
        w.undo.register_new_netid_to_existing_undoid(initData.containerUndoID, folderData->folderList.get_net_id());
        for(auto& initFolder : initFolderList) {
            auto it = folderData->folderList->emplace_back_direct(folderData->folderList, w, initFolder);
            w.undo.register_new_netid_to_existing_undoid(initFolder.undoID, it->obj.get_net_id());
        }
    }
    else {
        auto& initComponentList = initData.layerData.value();
        layerData = std::make_unique<DrawingProgramLayer>();
        layerData->components = w.netObjMan.make_obj<CanvasComponentContainer::NetList>();
        w.undo.register_new_netid_to_existing_undoid(initData.containerUndoID, layerData->components.get_net_id());
        for(auto& initComponent : initComponentList) {
            auto it = layerData->components->emplace_back_direct(layerData->components, w.netObjMan, *initComponent.copyData);
            w.undo.register_new_netid_to_existing_undoid(initComponent.undoID, it->obj.get_net_id());
        }
    }
    nameData = w.netObjMan.make_obj<NameData>();
    nameData->name = initData.metaInfo.name;
    displayData = w.netObjMan.make_obj<DisplayData>();
    displayData->alpha = initData.metaInfo.alpha;
    displayData->blendMode = initData.metaInfo.blendMode;
    displayData->playerLocked = initData.metaInfo.playerLocked;
    displayData->fogLayer = initData.metaInfo.fogLayer;
}

DrawingProgramLayerListItemUndoData DrawingProgramLayerListItem::get_undo_data(WorldUndoManager& u) const {
    DrawingProgramLayerListItemUndoData toRet;
    toRet.metaInfo.name = nameData->name;
    toRet.metaInfo.blendMode = displayData->blendMode;
    toRet.metaInfo.alpha = displayData->alpha;
    toRet.metaInfo.playerLocked = displayData->playerLocked;
    toRet.metaInfo.fogLayer = displayData->fogLayer;
    if(folderData) {
        toRet.containerUndoID = u.get_undoid_from_netid(folderData->folderList.get_net_id());
        toRet.folderData = std::vector<DrawingProgramLayerListItemUndoData>();
        auto& folderListToRet = toRet.folderData.value();
        for(auto& f : *folderData->folderList) {
            folderListToRet.emplace_back(f.obj->get_undo_data(u));
            folderListToRet.back().undoID = u.get_undoid_from_netid(f.obj.get_net_id());
        }
    }
    else {
        toRet.containerUndoID = u.get_undoid_from_netid(layerData->components.get_net_id());
        toRet.layerData = std::vector<DrawingProgramComponentUndoData>();
        auto& layerListToRet = toRet.layerData.value();
        for(auto& c : *layerData->components)
            layerListToRet.emplace_back(u.get_undoid_from_netid(c.obj.get_net_id()), c.obj->get_data_copy());
    }
    return toRet;
}

void DrawingProgramLayerListItem::reassign_netobj_ids_call() {
    if(folderData)
        folderData->folderList.reassign_ids();
    else
        layerData->components.reassign_ids();
    nameData.reassign_ids();
    displayData.reassign_ids();
}

void DrawingProgramLayerListItem::set_to_erase() {
    if(folderData)
        folderData->set_to_erase();
    else
        layerData->set_to_erase();
}

void DrawingProgramLayerListItem::set_component_list_callbacks(DrawingProgramLayerManager &layerMan) {
    if(folderData)
        folderData->set_component_list_callbacks(layerMan);
    else
        layerData->set_component_list_callbacks(*this, layerMan);
}

void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
    if(folderData)
        folderData->get_flattened_component_list(objList);
    else
        layerData->get_flattened_component_list(objList);
}

void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList) {
    if(folderData) {
        for(auto& c : *folderData->folderList)
            c.obj->get_flattened_layer_list(objList);
    }
    else
        objList.emplace_back(this);
}

uint32_t DrawingProgramLayerListItem::get_component_count() const {
    if(folderData) {
        uint32_t toRet = 0;
        for(auto& c : *folderData->folderList)
            toRet += c.obj->get_component_count();
        return toRet;
    }
    else
        return layerData->components->size();
}

void DrawingProgramLayerListItem::scale_up(const WorldScalar& scaleUpAmount) {
    if(folderData)
        folderData->scale_up(scaleUpAmount);
    else
        layerData->scale_up(scaleUpAmount);
}

bool DrawingProgramLayerListItem::is_folder() const {
    return folderData != nullptr;
}

DrawingProgramLayerFolder& DrawingProgramLayerListItem::get_folder() const {
    return *folderData;
}

DrawingProgramLayer& DrawingProgramLayerListItem::get_layer() const {
    return *layerData;
}

void DrawingProgramLayerListItem::load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version, DrawingProgramLayerManager& layerMan) {
    nameData = layerMan.drawP.world.netObjMan.make_obj<NameData>();
    a(*nameData);

    displayData = layerMan.drawP.world.netObjMan.make_obj<DisplayData>();
    if(version >= VersionNumber(0, 8, 0)) {
        a(*displayData);
        // Normalize cereal bools (non-0/1 bytes must not stick as "true" forever).
        displayData->visible = displayData->visible ? true : false;
        displayData->playerLocked = displayData->playerLocked ? true : false;
        displayData->fogLayer = displayData->fogLayer ? true : false;
    }
    else {
        a(displayData->alpha, displayData->visible, displayData->blendMode);
        displayData->visible = displayData->visible ? true : false;
        displayData->playerLocked = false;
        displayData->fogLayer = false;
    }

    bool isFolder;
    a(isFolder);
    if(isFolder) {
        displayData->fogLayer = false;
        folderData = std::make_unique<DrawingProgramLayerFolder>();
        folderData->load_file(a, version, layerMan);
    }
    else {
        layerData = std::make_unique<DrawingProgramLayer>();
        layerData->load_file(a, version, layerMan);
    }
}

void DrawingProgramLayerListItem::save_file(cereal::PortableBinaryOutputArchive& a) const {
    a(*nameData);
    a(*displayData);
    a(static_cast<bool>(folderData));
    if(folderData)
        folderData->save_file(a);
    else
        layerData->save_file(a);
}

void DrawingProgramLayerListItem::get_used_resources(std::unordered_set<NetworkingObjects::NetObjID>& resourceSet) const {
    if(folderData)
        folderData->get_used_resources(resourceSet);
    else
        layerData->get_used_resources(resourceSet);
}

void DrawingProgramLayerListItem::draw(SkCanvas* canvas, const DrawData& drawData) const {
    if(displayData->visible) {
        if(!drawData.isSVGRender) {
            SkPaint layerPaint;
            layerPaint.setAlphaf(displayData->alpha);
            layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(displayData->blendMode));
            canvas->saveLayer(nullptr, &layerPaint);
        }

        if(folderData)
            folderData->draw(canvas, drawData);
        else
            layerData->draw(canvas, drawData);

        if(!drawData.isSVGRender)
            canvas->restore();
    }
}

void DrawingProgramLayerListItem::set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const {
    if(nameData && nameData->name != newName) {
        nameData->name = newName;
        delayedNetObjMan.send_update_to_all<NameData>(nameData, false);
    }
}

const std::string& DrawingProgramLayerListItem::get_name() const {
    return nameData->name;
}

void DrawingProgramLayerListItem::set_alpha(DrawingProgramLayerManager& layerMan, float newAlpha) const {
    if(displayData && displayData->alpha != newAlpha) {
        displayData->alpha = newAlpha;
        layerMan.drawP.drawCache.clear_own_cached_surfaces();
        layerMan.drawP.world.delayedUpdateObjectManager.send_update_to_all<DisplayData>(displayData, false);
    }
}

float DrawingProgramLayerListItem::get_alpha() const {
    return displayData->alpha;
}

void DrawingProgramLayerListItem::set_visible(DrawingProgramLayerManager& layerMan, bool newVisible) const {
    if(displayData && displayData->visible != newVisible) {
        displayData->visible = newVisible;
        layerMan.drawP.drawCache.clear_own_cached_surfaces();
        layerMan.drawP.world.delayedUpdateObjectManager.send_update_to_all<DisplayData>(displayData, false);
    }
}

bool DrawingProgramLayerListItem::get_visible() const {
    return displayData->visible;
}

void DrawingProgramLayerListItem::set_blend_mode(DrawingProgramLayerManager& layerMan, SerializedBlendMode newBlendMode) const {
    if(displayData && displayData->blendMode != newBlendMode) {
        displayData->blendMode = newBlendMode;
        layerMan.drawP.drawCache.clear_own_cached_surfaces();
        layerMan.drawP.world.delayedUpdateObjectManager.send_update_to_all<DisplayData>(displayData, false);
    }
}

SerializedBlendMode DrawingProgramLayerListItem::get_blend_mode() const {
    return displayData->blendMode;
}

void DrawingProgramLayerListItem::set_player_locked(DrawingProgramLayerManager& layerMan, bool locked) const {
    if(!displayData)
        return;
    bool newLocked = locked || displayData->fogLayer;
    if(displayData->playerLocked != newLocked) {
        displayData->playerLocked = newLocked;
        layerMan.drawP.drawCache.clear_own_cached_surfaces();
        layerMan.drawP.world.delayedUpdateObjectManager.send_update_to_all<DisplayData>(displayData, false);
        layerMan.refresh_fog_client_projection();
    }
}

bool DrawingProgramLayerListItem::get_player_locked() const {
    return displayData && displayData->playerLocked;
}

void DrawingProgramLayerListItem::set_fog_layer(DrawingProgramLayerManager& layerMan, bool fog) const {
    if(!displayData || displayData->fogLayer == fog || is_folder())
        return;
    displayData->fogLayer = fog;
    if(fog)
        displayData->playerLocked = true;
    layerMan.drawP.drawCache.clear_own_cached_surfaces();
    layerMan.drawP.world.delayedUpdateObjectManager.send_update_to_all<DisplayData>(displayData, false);
    layerMan.refresh_fog_client_projection();
}

bool DrawingProgramLayerListItem::is_fog_layer() const {
    return displayData && displayData->fogLayer;
}

bool DrawingProgramLayerListItem::is_player_edit_blocked() const {
    return is_fog_layer() || get_player_locked();
}

void DrawingProgramLayerListItem::set_metainfo(DrawingProgramLayerManager& layerMan, const DrawingProgramLayerListItemMetaInfo& metaInfo) {
    set_blend_mode(layerMan, metaInfo.blendMode);
    set_alpha(layerMan, metaInfo.alpha);
    set_name(layerMan.drawP.world.delayedUpdateObjectManager, metaInfo.name);
    set_fog_layer(layerMan, metaInfo.fogLayer);
    set_player_locked(layerMan, metaInfo.playerLocked || metaInfo.fogLayer);
}

DrawingProgramLayerListItemMetaInfo DrawingProgramLayerListItem::get_metainfo() const {
    return DrawingProgramLayerListItemMetaInfo{
        .name = get_name(),
        .alpha = get_alpha(),
        .blendMode = get_blend_mode(),
        .playerLocked = get_player_locked(),
        .fogLayer = is_fog_layer()
    };
}

void DrawingProgramLayerListItem::write_stripped_constructor(cereal::PortableBinaryOutputArchive& a, const std::unordered_set<NetworkingObjects::NetObjID>& hiddenComponentIds) const {
    a(static_cast<bool>(folderData));
    if(folderData) {
        a(folderData->folderList.get_net_id());
        a(static_cast<uint32_t>(folderData->folderList->size()));
        for(auto& child : *folderData->folderList) {
            a(child.obj.get_net_id());
            child.obj->write_stripped_constructor(a, hiddenComponentIds);
        }
    }
    else {
        std::vector<NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer>> keep;
        for(auto& c : *layerData->components) {
            if(!hiddenComponentIds.contains(c.obj.get_net_id()))
                keep.emplace_back(c.obj);
        }
        a(layerData->components.get_net_id());
        a(static_cast<uint32_t>(keep.size()));
        for(auto& c : keep)
            c.write_create_message(a);
    }
    nameData.write_create_message(a);
    displayData.write_create_message(a);
}

void DrawingProgramLayerListItem::erase_invalid_components() {
    if(folderData)
        folderData->erase_invalid_components();
    else
        layerData->erase_invalid_components();
}

void DrawingProgramLayerListItem::register_class(World& w) {
    w.netObjMan.register_class<DrawingProgramLayerListItem, DrawingProgramLayerListItem, DrawingProgramLayerListItem, DrawingProgramLayerListItem>({
        .writeConstructorFuncClient = write_constructor_func,
        .readConstructorFuncClient = read_constructor_func,
        .readUpdateFuncClient = nullptr,
        .writeConstructorFuncServer = write_constructor_func,
        .readConstructorFuncServer = read_constructor_func,
        .readUpdateFuncServer = nullptr,
    });
    w.delayedUpdateObjectManager.register_class<NameData>(w.netObjMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<NameData>{
        .postUpdateFunc = [&](NameData& o) {
            w.set_to_layout_gui_if_focus();
        }
    });
    w.delayedUpdateObjectManager.register_class<DisplayData>(w.netObjMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<DisplayData>{
        .postUpdateFunc = [&](DisplayData& o) {
            (void)o;
            w.drawProg.drawCache.clear_own_cached_surfaces();
            w.drawProg.layerMan.ensure_editing_layer_is_editable();
            w.set_to_layout_gui_if_focus();
        }
    });
}

void DrawingProgramLayerListItem::write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryOutputArchive& a) {
    a(o->is_folder());
    if(o->is_folder())
        o->folderData->folderList.write_create_message(a);
    else
        o->layerData->components.write_create_message(a);
    o->nameData.write_create_message(a);
    o->displayData.write_create_message(a);
}

void DrawingProgramLayerListItem::read_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c) {
    bool isFolder;
    a(isFolder);
    if(isFolder) {
        o->folderData = std::make_unique<DrawingProgramLayerFolder>();
        o->folderData->folderList = o.get_obj_man()->read_create_message<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>>(a, c);
    }
    else {
        o->layerData = std::make_unique<DrawingProgramLayer>();
        o->layerData->components = o.get_obj_man()->read_create_message<CanvasComponentContainer::NetList>(a, c);
    }
    o->nameData = o.get_obj_man()->read_create_message<NameData>(a, c);
    o->displayData = o.get_obj_man()->read_create_message<DisplayData>(a, c);
}