use super::Tool;
use crate::button::Button;
use crate::config::{RoomToolKeybindings, ToolKeybindings};
use crate::dimension_indicator::DimensionIndicator;
use crate::grid::{snap_to_grid, SNAP_SIZE};
use crate::map_data::MapData;
use crate::math::{Rect, Vec2};
use crate::transform::Transform;
use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
use raylib::ffi::Color;
use raylib::RaylibHandle;

pub struct RoomTool {
    keybindings: RoomToolKeybindings,
    /// The rectangle that is currently being drawn by the user. Once it is finished, it will be
    /// pushed into the room_rects.
    unfinished_rect: Option<(Vec2<f32>, Vec2<f32>)>,
    dimension_indicator: DimensionIndicator,
}

impl RoomTool {
    /// Create a new room tool where no rooms have been drawn yet.
    pub fn new(keybindings: RoomToolKeybindings) -> Self {
        Self {
            keybindings,
            unfinished_rect: None,
            dimension_indicator: DimensionIndicator::new(),
        }
    }
}

impl Tool for RoomTool {
    fn active_update(&mut self, map_data: &mut MapData, rl: &RaylibHandle, transform: &Transform) {
        let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position().into());
        // Update the currently drawn rectangle, if it exists, and also its dimension indicator.
        if let Some((ref pos1, ref mut pos2)) = &mut self.unfinished_rect {
            *pos2 = snap_to_grid(mouse_pos_m, SNAP_SIZE);

            self.dimension_indicator.update_dimensions(&[*pos1, *pos2]);
        }

        // Start or finish drawing the currently unfinished rectangle
        if self.keybindings.finish_draw.is_pressed(rl) && self.unfinished_rect.is_some() {
            let (pos1, pos2) = self.unfinished_rect.take().unwrap();
            map_data.rooms_mut().push(Rect::bounding_rect(pos1, pos2));
        } else if self.keybindings.start_draw.is_pressed(rl) {
            let snapped_mouse_pos = snap_to_grid(mouse_pos_m, SNAP_SIZE);
            self.unfinished_rect = Some((snapped_mouse_pos, snapped_mouse_pos))
        }

        if self.keybindings.abort_draw.is_pressed(rl) {
            self.unfinished_rect = None;
        }
    }

    fn draw(&self, map_data: &MapData, rld: &mut RaylibDrawHandle, transform: &Transform) {
        // Draw all finished rectangles.
        for &rect in map_data.rooms() {
            rld.draw_rectangle_rec(
                transform.rect_m_to_px(rect),
                Color {
                    r: 180,
                    g: 180,
                    b: 180,
                    a: 255,
                },
            );
        }

        // Do the same for the unfinished rectangle
        if let Some((pos1, pos2)) = self.unfinished_rect {
            rld.draw_rectangle_rec(
                transform.rect_m_to_px(Rect::bounding_rect(pos1, pos2)),
                Color {
                    r: 150,
                    g: 200,
                    b: 150,
                    a: 255,
                },
            );

            self.dimension_indicator.draw(rld, transform);
        }
    }

    fn activation_key(&self) -> Button {
        self.keybindings.activation_key()
    }
}