infinipaint/src/DrawingProgram/Tools/EraserTool.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 "EraserTool.hpp"
#include "../DrawingProgram.hpp"
#include "../../MainProgram.hpp"
#include "../../DrawData.hpp"
#include <include/core/SkBlendMode.h>
#include <include/core/SkPathBuilder.h>
#include "../../CanvasComponents/BrushComponentCode.hpp"
#include "../EditCanvasComponentWorldUndoAction.hpp"
#include <include/pathops/SkPathOps.h>

#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/RadioButtonHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp"

EraserTool::EraserTool(DrawingProgram& initDrawP):
    DrawingProgramToolBase(initDrawP)
{}

DrawingProgramToolType EraserTool::get_type() {
    return DrawingProgramToolType::ERASER;
}

void EraserTool::gui_toolbox(Toolbar& t) {
    using namespace GUIStuff;
    using namespace ElementHelpers;

    auto& gui = drawP.world.main.g.gui;
    gui.new_id("eraser tool", [&] {
        text_label_centered(gui, "Eraser");
        drawP.world.main.toolConfig.relative_width_gui(drawP, "Size");
        text_label(gui, "Erase from:");
        radio_button_selector(gui, "layer selector", &drawP.controls.layerSelector, {
            {"Layer being edited", DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED},
            {"All visible layers", DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS}
        });
        checkbox_boolean_field(gui, "erase details", "Erase details", &drawP.world.main.toolConfig.eraser.eraseDetail);
    });
}

void EraserTool::gui_phone_toolbox(PhoneDrawingProgramScreen& t) {
    using namespace GUIStuff;
    using namespace ElementHelpers;

    auto& gui = drawP.world.main.g.gui;

    gui.new_id("eraser tool", [&] {
        drawP.world.main.toolConfig.relative_width_gui(drawP, "Size");
        text_label(gui, "Erase from:");
        radio_button_selector(gui, "layer selector", &drawP.controls.layerSelector, {
            {"Layer being edited", DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED},
            {"All visible layers", DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS}
        });
        checkbox_boolean_field(gui, "erase details", "Erase details", &drawP.world.main.toolConfig.eraser.eraseDetail);
    });
}

void EraserTool::right_click_popup_gui(Toolbar& t, Vector2f popupPos) {
    t.paint_popup(popupPos);
}

void EraserTool::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {
    if(button.button == InputManager::MouseButton::LEFT) {
        if(button.down && !isErasing && !drawP.world.main.g.gui.cursor_obstructed()) {
            auto relativeWidthResult = drawP.world.main.toolConfig.get_relative_width_stroke_size(drawP, drawP.world.drawData.cam.c.inverseScale);
            if(!relativeWidthResult.first.has_value()) {
                drawP.world.main.toolConfig.print_relative_width_fail_message(relativeWidthResult.second);
                return;
            }

            BrushComponentCode::mouse_button(drawP, genData, drawP.world.drawData.cam.c, button, relativeWidthResult.first.value());
            isErasing = true;
        }
        else if(!button.down && isErasing) {
            // If not real time eraser, we can benefit from simplifying the path
            std::optional<SkPath> simplified = Simplify(erasePath);
            if(simplified.has_value())
                erasePath = simplified.value();
            erase_on_path();
            reset_erasing_stroke();
            commit_erase();
            isErasing = false;
        }
    }
}

void EraserTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
    if(isErasing) {
        auto& toolConfig = drawP.world.main.toolConfig;
        BrushComponentCode::mouse_motion(drawP, genData, motion.pos, toolConfig.get_relative_width_stroke_size(drawP, genData.coords.inverseScale).first.value());
    }
}

void EraserTool::input_pen_axis_callback(const InputManager::PenAxisCallbackArgs& axis) {
    if(axis.axis == SDL_PEN_AXIS_PRESSURE && drawP.world.main.conf.tabletOptions.pressureAffectsBrushWidth) {
        genData.penWidth = axis.value;
        if(genData.penWidth != 0.0f && isErasing) {
            auto& toolConfig = drawP.world.main.toolConfig;
            float width = toolConfig.get_relative_width_stroke_size(drawP, genData.coords.inverseScale).first.value();
            BrushComponentCode::pen_pressure(drawP, genData, width);
        }
    }
}

void EraserTool::erase_on_path() {
    auto cCWorldBounds = genData.coords.collider_to_world<SCollision::AABB<WorldScalar>, SCollision::AABB<float>>(erasePath.getBounds());
    drawP.drawCache.traverse_bvh_run_function(cCWorldBounds, [&](const auto& bvhNode) {
        if(bvhNode &&
           erasePath.contains(convert_vec2<SkPoint>(genData.coords.to_space(bvhNode->bounds.min))) &&
           erasePath.contains(convert_vec2<SkPoint>(genData.coords.to_space(bvhNode->bounds.max))) &&
           erasePath.contains(convert_vec2<SkPoint>(genData.coords.to_space(bvhNode->bounds.top_right()))) &&
           erasePath.contains(convert_vec2<SkPoint>(genData.coords.to_space(bvhNode->bounds.bottom_left())))) {
            drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds);
            drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) {
                drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto c) {
                    if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
                        auto it = updatedComponents.find(c);
                        if(it != updatedComponents.end()) {
                            c->obj->get_comp().set_data_from(*(it->second));
                            updatedComponents.erase(it);
                        }
                        erasedComponents.emplace(c);
                        return true;
                    }
                    return false;
                });
                return true;
            });
            return false;
        }
        drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto c) {
            if(drawP.world.main.toolConfig.eraser.eraseDetail) {
                if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
                    auto dataCopy = c->obj->get_comp().get_data_copy();
                    CanvasComponentEraseDetailResult result = c->obj->collides_with_erase_detail(genData.coords, erasePath);
                    switch(result) {
                        case CanvasComponentEraseDetailResult::NO_CHANGE:
                            return false;
                        case CanvasComponentEraseDetailResult::CHANGED: {
                            if(!updatedComponents.contains(c))
                                updatedComponents.emplace(c, std::move(dataCopy));
                            // NOTE: commit_update is what should be run here, but invalidate_cache is being run instead. This is for a few reasons:
                            // - Mesh initialize_draw_data does nothing, so commit_update isnt necessary
                            // - worldAABB only shrinks, which means that invalidate_cache_at_optional_aabb will invalidate a "good enough" space even if worldAABB isn't updated (which commit_update does)
                            // - commit_update can't be run inside a traverse_bvh_run_function call (causes segfault and other issues). If that were necessary, we would have to defer that call for after the traversal is done
                            // - commit_update will be run at switch_tool time instead
                            drawP.drawCache.invalidate_cache_at_optional_aabb(c->obj->get_world_bounds());
                            return false;
                        }
                        case CanvasComponentEraseDetailResult::REMOVED:
                            auto it = updatedComponents.find(c);
                            if(it != updatedComponents.end()) {
                                c->obj->get_comp().set_data_from(*(it->second));
                                updatedComponents.erase(it);
                            }
                            else
                                c->obj->get_comp().set_data_from(*dataCopy);
                            erasedComponents.emplace(c);
                            drawP.drawCache.invalidate_cache_at_optional_aabb(c->obj->get_world_bounds());
                            return true;
                    }
                }
            }
            else {
                if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(genData.coords, erasePath)) {
                    erasedComponents.emplace(c);
                    drawP.drawCache.invalidate_cache_at_optional_aabb(c->obj->get_world_bounds());
                    return true;
                }
            }
            return false;
        });
        return true;
    });
}

void EraserTool::reset_erasing_stroke() {
    if(!genData.brushPoints.empty()) {
        auto lastBrushPoint = genData.brushPoints.back();
        genData.brushPoints.clear();
        genData.brushPoints.emplace_back(lastBrushPoint);
        genData.prevPointUnaltered = genData.coords.get_mouse_pos(drawP.world);
        genData.addedTemporaryPoint = false;
    }
}

void EraserTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
    erasedComponents.erase(erasedComp);
    updatedComponents.erase(erasedComp);
}

void EraserTool::commit_erase() {
    bool placedNewObject = false;
    std::unordered_map<DrawingProgramLayerListItem*, std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>> newObjectsToPlace;
    std::erase_if(updatedComponents, [&] (auto& p) {
        auto& [comp, oldData] = p;
        std::vector<CanvasComponentContainer*> splitComps = comp->obj->get_comp().attempt_split(drawP);
        if(!splitComps.empty()) {
            for(CanvasComponentContainer* c : splitComps)
                newObjectsToPlace[comp->obj->parentLayer].emplace_back(std::next(comp->obj->objInfo), c);
            placedNewObject = true;
            erasedComponents.emplace(comp);
            comp->obj->get_comp().set_data_from(*oldData);
            return true;
        }
        return false;
    });
    bool firstPlacement = true;
    for(auto& [layer, compMap] : newObjectsToPlace) {
        drawP.layerMan.add_many_components_to_layer(layer, compMap, firstPlacement);
        firstPlacement = false;
    }
    bool objectsToErase = !erasedComponents.empty();
    if(objectsToErase)
        drawP.layerMan.erase_component_container(erasedComponents, !placedNewObject);
    bool first = !objectsToErase && !placedNewObject;
    for(auto& [comp, oldData] : updatedComponents) {
        comp->obj->commit_update_dont_invalidate_cache(drawP);
        comp->obj->send_comp_update(drawP, true);
        if(first) {
            first = false;
            drawP.world.undo.push(std::make_unique<EditCanvasComponentWorldUndoAction>(std::move(oldData), drawP.world.undo.get_undoid_from_netid(comp->obj.get_net_id())));
        }
        else
            drawP.world.undo.push_on_last(std::make_unique<EditCanvasComponentWorldUndoAction>(std::move(oldData), drawP.world.undo.get_undoid_from_netid(comp->obj.get_net_id())));
    }
    erasedComponents.clear();
    updatedComponents.clear();
}

void EraserTool::switch_tool(DrawingProgramToolType newTool) {
    commit_erase();
}

void EraserTool::commit_data() {
    if(isErasing) {
        erasePath = BrushComponentCode::brush_stroke_to_skpath(genData.brushPoints, drawP.world.main.toolConfig.brush.hasRoundCaps);
        if(drawP.world.main.conf.realTimeEraser) {
            erase_on_path();
            reset_erasing_stroke();
        }
    }
    else {
        auto relativeWidthResult = drawP.world.main.toolConfig.get_relative_width_stroke_size(drawP, drawP.world.drawData.cam.c.inverseScale);
        if(!relativeWidthResult.first.has_value()) {
            erasePath = SkPath();
            return;
        }
        float width = relativeWidthResult.first.value() * 0.5f;
        erasePath = SkPath::Circle(drawP.world.main.input.mouse.pos.x(), drawP.world.main.input.mouse.pos.y(), width);
    }
}

void EraserTool::tool_update() {
    if(!drawP.world.main.g.gui.cursor_obstructed())
        drawP.world.main.input.hideCursor = true;

    using namespace BrushComponentCode;

    commit_data();
}

bool EraserTool::prevent_undo_or_redo() {
    return drawP.controls.leftClickHeld;
}

void EraserTool::draw(SkCanvas* canvas, const DrawData& drawData) {
    if(!drawP.world.main.input.isTouchDevice && (!drawData.main->g.gui.cursor_obstructed() || isErasing) && !erasePath.isEmpty()) {
        if(isErasing) {
            CanvasComponentContainer::TransformData drawTransform = CanvasComponentContainer::calculate_draw_transform(drawData.cam.c, genData.coords);
            canvas->save();
            CanvasComponentContainer::canvas_do_transform(canvas, drawTransform);
        }
        SkPaint linePaint;
        linePaint.setAntiAlias(drawData.skiaAA);
        linePaint.setColor4f({0.0f, 0.0f, 0.0f, 0.4f});
        linePaint.setStyle(SkPaint::kFill_Style);
        canvas->drawPath(erasePath, linePaint);

        linePaint.setColor4f({1.0f, 1.0f, 1.0f, 0.4f});
        canvas->drawPath(erasePath, linePaint);
        if(isErasing)
            canvas->restore();
    }
}