mod camera_controller;
mod player;
pub mod world;
use std::time::Instant;
use crate::renderer::content_view::ContentView;
use cgmath::{SquareMatrix, Point3, InnerSpace};
use winit::event::Event;
use crate::renderer::{camera::CameraTransform};
use player::Player;
use world::World;


pub enum GameState {
    Paused,
    Running
}

pub struct Game {
    player: Player,
    world: World
}

impl Game {
    pub fn new(content: &mut dyn ContentView) -> Self {
        let mut app = Self { 
            player: Player::new(),
            world: World::new("default".to_string())
        };

        // Try to load world from file
        let timer = Instant::now();
        if app.world.load() {
            for (pos, block) in app.world.all_blocks() {
                content.write(&pos, block);
            }
            println!("Loaded in {}", timer.elapsed().as_secs_f32());
        }
        // Generate new world
        else {
            let timer = Instant::now();
            for x in 0..32 {
                for z in 0..32 {
                    let pos = &Point3{x,y:0,z};
                    let block = app.world.gen_block(pos);
                    content.write(pos, block);
                }
            }
            println!("Generated in {}", timer.elapsed().as_secs_f32());
            
            let timer = Instant::now();
            app.world.save();
            println!("Saved in {}", timer.elapsed().as_secs_f32());
        }
        

        println!("App initialized");
        app
    }

    pub fn input(&mut self, event: &Event<()>) {
        // Update camera controller
        self.player.camera_controller.handle_input(event);
    }

    pub fn update_state(&mut self, requested_state: GameState) -> GameState {
        match requested_state {
            GameState::Paused => {
                self.player.camera_controller.set_enabled(false);
            }
            GameState::Running => {
                self.player.camera_controller.set_enabled(true);
            }
        };

        // Currently we are not preventing any state changes, just return requested state
        requested_state
    }

    pub fn update_camera(&mut self, delta: f32, camera_transform: &mut dyn CameraTransform) {
        self.player.camera_controller.update(delta, camera_transform);
    }
}