use crate::config::Config;
use crate::map_data::MapData;
use crate::tool::*;
use crate::transform::Transform;
use raylib::core::drawing::RaylibDrawHandle;
use raylib::ffi::KeyboardKey;
use raylib::{RaylibHandle, RaylibThread};

pub struct Editor {
    map_data: MapData,
    tools: Vec<Box<dyn Tool>>,
    active: usize,
}

impl Editor {
    pub fn new(rl: &mut RaylibHandle, rlt: &RaylibThread, config: Config) -> 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(config.room_keybindings)));
        assert_eq!(ToolType::WallTool as u8, 1);
        tools.push(Box::new(WallTool::new(config.wall_keybindings)));
        assert_eq!(ToolType::IconTool as u8, 2);
        tools.push(Box::new(IconTool::new(rl, rlt, config.icon_keybindings)));
        assert_eq!(ToolType::DeletionTool as u8, 3);
        tools.push(Box::new(DeletionTool::new(config.deletion_keybindings)));

        assert_eq!(ToolType::NumTools as usize, tools.len());

        Self {
            map_data: MapData::new(),
            tools,
            active: 0,
        }
    }

    pub fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {
        // Handle keybindings for tool change
        for (i, tool) in self.tools.iter().enumerate() {
            if tool.activation_key().is_pressed(rl) {
                self.active = i;
                break;
            }
        }

        // Handle saving and loading the editor contents to the swap file
        if rl.is_key_pressed(KeyboardKey::KEY_S) {
            self.map_data
                .write_file("swap.ron")
                .expect("Unable to write buffer file");
        } else if rl.is_key_pressed(KeyboardKey::KEY_L) {
            self.map_data
                .load_file("swap.ron")
                .expect("Unable to read buffer file");
        }

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

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

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

    pub fn map_data(&self) -> &MapData {
        &self.map_data
    }
}