use winit::{
    event::{Event, WindowEvent, KeyboardInput, ElementState, VirtualKeyCode, MouseButton},
    window::Window
};
use std::sync::Arc;

mod camera_controller; use camera_controller::CameraController;
mod world_gen; use world_gen::WorldGen;
use crate::renderer::Renderer;
//use crate::renderer::BrickData;

pub struct App {
    pub window: Window,
    pub renderer: Renderer,
    world_gen: WorldGen,
    camera_controller: CameraController,
}

impl App {
    pub fn new(window: Window) -> Self {
        let mut renderer = futures::executor::block_on(Renderer::new(&window));
        let camera_controller = CameraController::new();
        let mut world_gen = WorldGen::new();


        // let start = std::time::Instant::now();
        // for x in 0..128 {
        //     for z in 0..128 {
        //         // Dirt
        //         for y in 0..31 {
        //             renderer.set_voxel(x, y, z, 1);
        //         }
        //         // Grass
        //         renderer.set_voxel(x, 31, z, 2);
        //     }
        // }
        // println!("Generated in {}ms", start.elapsed().as_millis());


        let start = std::time::Instant::now();
        for bx in 0..4 {
            for bz in 0..4 {

                let brick_id = renderer.brick_get_id(bx, 0, bz);
                renderer.brick_mark_changed(brick_id);
                for x in 0..32 {
                    for z in 0..32 {
                        // Dirt
                        for y in 0..31 {
                            renderer.brick_set_voxel(brick_id, x, y, z, 1);
                        }
                        // Grass
                        renderer.brick_set_voxel(brick_id, x, 31, z, 2);
                    }
                }
                
            }
        }
        println!("Generated in {}ms", start.elapsed().as_millis());



        Self { window, renderer, camera_controller, world_gen }
    }

    pub fn input(&mut self, event: Arc<Event<()>>) {

        match event.as_ref() {
            Event::WindowEvent { ref event, .. } => {
                match event {
                    // Escape key
                    WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. }, .. } => {
                        self.window.set_cursor_grab(false).unwrap();
                        self.window.set_cursor_visible(true);
                        self.camera_controller.set_enabled(false);
                    }
                    // Window clicked
                    WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
                        self.window.set_cursor_grab(true).unwrap();
                        self.window.set_cursor_visible(false);
                        self.camera_controller.set_enabled(true);
                    }
                    // Window resized
                    WindowEvent::Resized(physical_size) => {
                        self.renderer.resize(Some(*physical_size));
                    }
                    WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                        self.renderer.resize(Some(**new_inner_size));
                    }
                    _ => ()
                }
            }
            _ => ()
        }

        // Update camera controller
        self.camera_controller.handle_input(event.as_ref());
    }

    pub fn update(&mut self, delta: f32) {
        self.camera_controller.update_camera(&mut self.renderer.camera, delta);
    }
}