#include "Selection_Rectangle_Overlay.h"
#include "Plottable_Real_Time_Data.h"
#include "../render/Blend2D_Cache.h"
#include <algorithm>
#include <cmath>
#include <sstream>
namespace renderive {
namespace detail {
namespace {
struct Selection_Interaction_Base {};
struct Selection_Interaction {
    bool selecting{};
    PointF selection_start{};
    PointF selection_current{};
};
using Selection_Interaction_State = Double_State_Strategy<Selection_Interaction_Base, Selection_Interaction>;
RectF axis_content_rect(const Axis_Transform& horizontal, const Axis_Transform& vertical) {
    const double x1 = horizontal.coord_to_pixel(horizontal.coordinate_range.origin);
    const double x2 = horizontal.coord_to_pixel(horizontal.coordinate_range.target);
    const double y1 = vertical.coord_to_pixel(vertical.coordinate_range.origin);
    const double y2 = vertical.coord_to_pixel(vertical.coordinate_range.target);
    return {std::min(x1, x2), std::min(y1, y2), std::abs(x2 - x1), std::abs(y2 - y1)};
}
}
struct Selection_Rectangle_Overlay_Control::Impl {
    Impl(Selection_Rectangle_Overlay_Control& owner, std::shared_ptr<Abs_Axis> horizontal, std::shared_ptr<Abs_Axis> vertical)
        : horizontal_axis(std::move(horizontal)), vertical_axis(std::move(vertical)), regions(owner) {}
    std::shared_ptr<Abs_Axis> horizontal_axis;
    std::shared_ptr<Abs_Axis> vertical_axis;
    Plottable_History_Real_Time_Data<RectF, std::vector<RectF>> regions;
    Selection_Interaction_State interaction;
};
Selection_Rectangle_Overlay_Control::Selection_Rectangle_Overlay_Control(Plot_Core& plot, const Selection_Rectangle_Overlay_Properties& properties, std::shared_ptr<Abs_Axis> horizontal_axis, std::shared_ptr<Abs_Axis> vertical_axis)
    : Plottable_State(plot, properties), impl_(std::make_unique<Impl>(*this, std::move(horizontal_axis), std::move(vertical_axis))) {}
Selection_Rectangle_Overlay_Control::~Selection_Rectangle_Overlay_Control() = default;
std::vector<RectF> Selection_Rectangle_Overlay_Control::selected_regions() const {
    return impl_->regions.snapshot();
}
void Selection_Rectangle_Overlay_Control::clear_selected_regions() {
    impl_->regions.clear();
    impl_->interaction.update([](Selection_Interaction& interaction) {
        interaction.selecting = false;
    });
    changed();
}
void Selection_Rectangle_Overlay_Control::handle_event(const Event& event) {
    const RectF content = axis_content_rect(impl_->horizontal_axis->transform(), impl_->vertical_axis->transform());
    if(event.type == Event_Type::Pointer_Press) {
        const auto& pointer = static_cast<const Pointer_Event&>(event);
        if(pointer.button != Mouse_Button::Left || !content.contains(pointer.position))
            return;
        impl_->interaction.update([&](Selection_Interaction& interaction) {
            interaction.selecting = true;
            interaction.selection_start = interaction.selection_current = pointer.position;
        });
        event.accept();
        changed();
        return;
    }
    if(event.type == Event_Type::Pointer_Move) {
        const auto& pointer = static_cast<const Pointer_Event&>(event);
        bool selecting{};
        impl_->interaction.update([&](Selection_Interaction& interaction) {
            selecting = interaction.selecting;
            if(selecting)
                interaction.selection_current = pointer.position;
        });
        if(!selecting)
            return;
        event.accept();
        changed();
        return;
    }
    if(event.type != Event_Type::Pointer_Release)
        return;
    const auto& pointer = static_cast<const Pointer_Event&>(event);
    PointF start;
    bool selecting{};
    impl_->interaction.update([&](Selection_Interaction& interaction) {
        selecting = interaction.selecting;
        if(!selecting)
            return;
        interaction.selecting = false;
        start = interaction.selection_start;
        interaction.selection_current = pointer.position;
    });
    if(!selecting)
        return;
    const Axis_Transform horizontal = impl_->horizontal_axis->transform();
    const Axis_Transform vertical = impl_->vertical_axis->transform();
    const RectF region{horizontal.pixel_to_coord(start.x), vertical.pixel_to_coord(start.y),
                       horizontal.pixel_to_coord(pointer.position.x) - horizontal.pixel_to_coord(start.x),
                       vertical.pixel_to_coord(pointer.position.y) - vertical.pixel_to_coord(start.y)};
    if(std::abs(region.width) > 1e-9 && std::abs(region.height) > 1e-9)
        impl_->regions.update(region.normalized());
    event.accept();
    changed();
}
void Selection_Rectangle_Overlay_Control::publish() {
    publish_properties();
    impl_->interaction.publish();
}
void Selection_Rectangle_Overlay_Control::paint(Painter& painter, const Render_State_View& view) {
    const auto& state = render_properties(view);
    const auto& interaction = view.get(impl_->interaction);
    const auto horizontal = impl_->horizontal_axis->transform(view);
    const auto vertical = impl_->vertical_axis->transform(view);
    for(const RectF& region : view.get(impl_->regions)) {
        RectF pixels{horizontal.coord_to_pixel(region.x), vertical.coord_to_pixel(region.y), horizontal.coord_to_pixel(region.right()) - horizontal.coord_to_pixel(region.x), vertical.coord_to_pixel(region.bottom()) - vertical.coord_to_pixel(region.y)};
        painter.rect(pixels, state.selection_border_pen, state.selection_brush);
        std::ostringstream text;
        text << region.width << " x " << region.height;
        const RectF normalized = pixels.normalized();
        painter.text({normalized.x + 3.0, normalized.y + 3.0}, text.str(), state.label_font, state.label_pen);
    }
    if(interaction.selecting)
        painter.rect({interaction.selection_start.x, interaction.selection_start.y, interaction.selection_current.x - interaction.selection_start.x, interaction.selection_current.y - interaction.selection_start.y}, state.selection_border_pen, state.selection_brush);
}
}
}