use std::time::Instant;

use collision::Collidable;
use level_one::LevelOne;
use nalgebra::{Matrix4, Perspective3, Vector3};
use player::Player;
use sdl2::{event::Event, keyboard::Scancode, video::GLProfile};

mod utils;
mod grid;
mod renderable;
mod shader;
mod camera;
mod consts;
mod level_one;
mod plane;
mod cube;
mod capsule;
mod skybox;
mod collision;
mod debug;
mod player;

use consts::*;
use camera::*;
use shader::Shader;
use grid::Grid;
use skybox::Skybox;
use debug::DebugRenderer;

fn main() {
    let sdl = sdl2::init().unwrap();
    let video = sdl.video().unwrap();

    let gl_attr = video.gl_attr();
    gl_attr.set_context_profile(GLProfile::Core);
    gl_attr.set_context_version(3, 3);

    let mut window = video.window(GAME_TITLE, SCREEN_WIDTH, SCREEN_HEIGHT)
        .opengl()
        .build()
        .unwrap();

    let _ctx = window.gl_create_context().unwrap();
    gl::load_with(|s| video.gl_get_proc_address(s) as *const _);

    unsafe {
        gl::Viewport(0, 0, SCREEN_WIDTH as i32, SCREEN_HEIGHT as i32);
        gl::Enable(gl::DEPTH_TEST);
    }

    let mouse = sdl.mouse();
    window.set_grab(true);
    mouse.set_relative_mouse_mode(true);
    mouse.show_cursor(false);

    let mut light_angle: f32 = 0.0;         // Azimuthal angle around Y
    let light_elevation: f32 = 45.0f32.to_radians(); // Fixed elevation above horizon
    let light_speed: f32 = 0.2;            // Revolutions per second (~0.2 rad/s)

    let debug_renderer = DebugRenderer::new();

    let mut mouse_locked = true;
    let mut first_mouse = true;

    let skybox_shader = Shader::new("src/shaders/skybox_vertex.glsl", "src/shaders/skybox_fragment.glsl");
    let skybox = Skybox::new(SKYBOX_FACES);

    let shader = Shader::new("src/shaders/vertex.glsl", "src/shaders/fragment.glsl");

    let mut event_pump = sdl.event_pump().unwrap();
    //let mut last_mouse_pos = (SCREEN_WIDTH as f32 / 2.0, SCREEN_HEIGHT as f32 / 2.0);

    let mut last_frame = Instant::now();

    let grid = Grid::new(10000.0, 1.0);

    // INITIALIZE LEVEL ONE
    let level_one = LevelOne::new();
    let spawn = level_one.spawn_position();

    let eye_height = 5.8;
    let mut camera = Camera::new(Vector3::new(spawn.x, spawn.y + eye_height, spawn.z));

    // INITIALIZE PLAYER
    let mut player = Player::new(spawn, eye_height);

    let start_time = Instant::now();

    // let mut player = Player::new(Vector3::new(-37.28033, 1.0, -37.28033));
    //let mut player = Player::new(Vector3::new(1.0, 1.0, -1.0));

    let mut world_colliders: Vec<&dyn Collidable> =
    level_one.walls.iter().map(|w| w as &dyn Collidable).collect();
    world_colliders.push(&level_one.ground);

    // MAIN GAME LOOP GOES THROUGH HERE
    'main: loop {
        let current_frame = Instant::now();
        let delta_time = current_frame.duration_since(last_frame).as_secs_f32();
        last_frame = current_frame;

        light_angle += light_speed * delta_time;
        if light_angle > std::f32::consts::TAU {
            light_angle -= std::f32::consts::TAU;
        }

        let elapsed = start_time.elapsed().as_secs_f32();

        // spherical → cartesian
        let lx = light_angle.cos() * light_elevation.cos();
        let ly = light_elevation.sin();
        let lz = light_angle.sin() * light_elevation.cos();
        let light_dir = Vector3::new(lx, ly, lz);

        if mouse_locked {
            mouse.warp_mouse_in_window(&window, SCREEN_WIDTH as i32 / 2, SCREEN_HEIGHT as i32 / 2);
        }

        for event in event_pump.poll_iter() {
            //println!("{:?}", event);
            match event {
                Event::Quit { .. } => break 'main,
                Event::KeyDown { scancode: Some(Scancode::Escape), .. } => {
                    window.set_grab(false);
                    if mouse_locked {
                        mouse.set_relative_mouse_mode(false);
                        mouse.show_cursor(true);
                        mouse_locked = false;
                    }
                }
                Event::KeyDown { scancode: Some(Scancode::Left), .. } => {
                    light_angle -= light_speed * delta_time;
                }
                Event::KeyDown { scancode: Some(Scancode::Right), .. } => {
                    light_angle += light_speed * delta_time;
                }
                Event::MouseButtonDown { .. } if !mouse_locked => {
                    mouse.set_relative_mouse_mode(true);
                    mouse.show_cursor(false);
                    mouse_locked = true;
                    //mouse.warp_mouse_in_window(&window, (SCREEN_WIDTH / 2) as i32, (SCREEN_HEIGHT / 2) as i32);
                    // first_mouse = true;
                }
                Event::MouseMotion { xrel, yrel, x, y, .. } => {
                    if first_mouse {
                        //last_mouse_pos = (x as f32, y as f32);
                        first_mouse = false;
                    } else {
                        camera.process_mouse_movement(xrel as f32, yrel as f32, true);
                    }
                }
                _ => {}
            }
        }

        let keys = event_pump.keyboard_state();
        //camera.process_keyboard(&keys, delta_time);

        // Add Player Update here
        player.update(delta_time, &keys, &mut camera, &world_colliders);

        unsafe {
            gl::ClearColor(0.1, 0.1, 0.1, 1.0);
            gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
        }

        // first_mouse = true;
        shader.use_program();
        skybox_shader.use_program();
        skybox_shader.set_int("skybox", 0);

        let projection = Perspective3::new(SCREEN_WIDTH as f32 / SCREEN_HEIGHT as f32, 45.0f32.to_radians(), 0.1, 100.0);
        let view = camera.get_view_matrix();
        let model = Matrix4::<f32>::identity();

        shader.set_mat4("model", &model);
        shader.set_mat4("view", &view);
        shader.set_mat4("projection", projection.as_matrix());
        shader.set_vec3("lightDir", &light_dir);
        shader.set_vec3("fogColor", &Vector3::new(0.6, 0.7, 0.8));   // pale blue mist
        shader.set_float("fogDensity", 0.02);                       // base density
        shader.set_float("fogTime", elapsed);                       // drives the animation

        grid.draw(&shader, &camera, projection.as_matrix());
        level_one.draw_ground(&shader, &camera, projection.as_matrix());
        level_one.draw_walls(&shader, &camera, projection.as_matrix());

        player.draw(&shader, &camera, &projection.as_matrix());

        skybox.draw(&skybox_shader, &camera, projection.as_matrix());

        debug_renderer.draw_collider(
            &camera.get_view_matrix(),
            &projection.as_matrix(),
            &level_one.ground.collider(),
        );
        for wall in &level_one.walls {
            debug_renderer.draw_collider(
                &camera.get_view_matrix(),
                &projection.as_matrix(),
                &wall.collider(),
            );
        }

        window.gl_swap_window();

        std::thread::sleep(std::time::Duration::from_millis(1));
    }
}