pub mod room_tool;
pub use room_tool::RoomTool;

pub mod wall_tool;
pub use wall_tool::WallTool;

use crate::transform::Transform;
use raylib::core::drawing::RaylibDrawHandle;
use raylib::ffi::KeyboardKey;
use raylib::RaylibHandle;

#[derive(Debug)]
#[repr(u8)]
pub enum ToolType {
    RoomTool,
    WallTool,
    NumTools,
}

pub trait Tool {
    fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {}
    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform);

    fn draw(&self, _rld: &mut RaylibDrawHandle, _transform: &Transform) {}
}

pub struct ToolShed {
    tools: Vec<Box<dyn Tool>>,
    active: usize,
}

impl ToolShed {
    pub fn new() -> Self {
        let mut tools: Vec<Box<dyn Tool>> = Vec::with_capacity(ToolType::NumTools as usize);
        assert_eq!(ToolType::RoomTool as u8, 0);
        tools.push(Box::new(RoomTool::new()));
        assert_eq!(ToolType::WallTool as u8, 1);
        tools.push(Box::new(WallTool::new()));

        Self { tools, active: 0 }
    }

    pub fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {
        // Handle keybindings for tool change
        self.active = if rl.is_key_pressed(KeyboardKey::KEY_R) {
            ToolType::RoomTool as usize
        } else if rl.is_key_pressed(KeyboardKey::KEY_W) {
            ToolType::WallTool as usize
        } else {
            self.active
        };

        for tool in &mut self.tools {
            tool.update(rl, transform);
        }

        self.tools[self.active].active_update(rl, transform);
    }

    pub fn draw_tools(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
        for tool in &self.tools {
            tool.draw(rld, transform);
        }
    }
}