use std::error::Error;
use std::path::Path;

use engine::camera::Camera;
use engine::lighting::LightSourceBuilder;
use engine::material::Builder as MaterialBuilder;
use engine::object::Id as ObjectId;
use engine::texture::{Id as TextureId, Texture};
use engine::vector::{Vec2, Vec3};
use engine::{Engine, Key, WindowSettingsBuilder, WindowSize};
use tracing::Level;
use tracing_subscriber::FmtSubscriber;

use crate::cube::{create_cube, Corner as CubeCorner};

mod cube;

const WINDOW_SIZE: WindowSize = WindowSize { width: 500, height: 600 };

fn main() -> Result<(), Box<dyn Error>>
{
    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::TRACE)
        .finish();

    tracing::subscriber::set_global_default(subscriber)?;

    let mut engine = Engine::<LookAtCamera>::new(
        &WindowSettingsBuilder::new().build(WINDOW_SIZE, "Yaaay lmao"),
        LookAtCamera::new(),
    )?;

    let texture = Texture::open(Path::new("vent.png"))?;

    let mut textured_cube = create_cube(|vertex_builder, _, corner| {
        vertex_builder.texture_coords(match corner {
            CubeCorner::TopRight => Vec2 { x: 1.0, y: 1.0 },
            CubeCorner::TopLeft => Vec2 { x: 0.0, y: 1.0 },
            CubeCorner::BottomRight => Vec2 { x: 1.0, y: 0.0 },
            CubeCorner::BottomLeft => Vec2 { x: 0.0, y: 0.0 },
        })
    })
    .texture(TextureId::new(0), texture)
    .material(
        MaterialBuilder::new()
            .ambient_map(TextureId::new(0))
            .diffuse_map(TextureId::new(0))
            .specular_map(TextureId::new(0))
            .build(),
    )
    .build(ObjectId::new(4))?;

    textured_cube.translate(Vec3 { x: 1.6, y: 0.0, z: 0.0 });

    engine.add_object(textured_cube);

    let light_source = LightSourceBuilder::new()
        .position(Vec3 { x: 1.2, y: 1.0, z: 1.5 })
        .build();

    engine.set_light_source(light_source);

    let cam_speed = 3.0;

    let light_source_speed = 1.2;

    engine.start(|engine| {
        let delta_time = *engine.delta_time();

        if engine.is_key_pressed(Key::W).unwrap() {
            let cam_target_direction = engine.camera().target_direction().clone();

            engine.camera_mut().position +=
                cam_target_direction * cam_speed * delta_time.as_secs_f32();
        }
        if engine.is_key_pressed(Key::S).unwrap() {
            let rev_cam_target_direction = -engine.camera().target_direction().clone();

            engine.camera_mut().position +=
                rev_cam_target_direction * cam_speed * delta_time.as_secs_f32();
        }
        if engine.is_key_pressed(Key::A).unwrap() {
            let cam_left = engine.camera().left().clone();

            // Camera speed adjusted to be same no matter how far the distance is to the
            // camera target
            let cam_speed_dist_adj = cam_speed
                * (engine.camera().position() - engine.camera().target()).length();

            engine.camera_mut().position +=
                cam_left * cam_speed_dist_adj * delta_time.as_secs_f32();
        }
        if engine.is_key_pressed(Key::D).unwrap() {
            let cam_right = engine.camera().right().clone();

            // Camera speed adjusted to be same no matter how far the distance is to the
            // camera target
            let cam_speed_dist_adj = cam_speed
                * (engine.camera().position() - engine.camera().target()).length();

            engine.camera_mut().position +=
                cam_right * cam_speed_dist_adj * delta_time.as_secs_f32();
        }
        if engine.is_key_pressed(Key::K).unwrap() {
            let cam_up = engine.camera().up().clone();

            // Camera speed adjusted to be same no matter how far the distance is to the
            // camera target
            let cam_speed_dist_adj = cam_speed
                * (engine.camera().position() - engine.camera().target()).length();

            engine.camera_mut().position +=
                cam_up * cam_speed_dist_adj * delta_time.as_secs_f32();
        }
        if engine.is_key_pressed(Key::J).unwrap() {
            let cam_up = engine.camera().down().clone();

            // Camera speed adjusted to be same no matter how far the distance is to the
            // camera target
            let cam_speed_dist_adj = cam_speed
                * (engine.camera().position() - engine.camera().target()).length();

            engine.camera_mut().position +=
                cam_up * cam_speed_dist_adj * delta_time.as_secs_f32();
        }

        if engine.is_key_pressed(Key::O).unwrap() {
            let light_source = engine.light_source_mut().unwrap();

            let front_right = Vec3 { x: 1.0, y: 0.0, z: 1.0 };

            light_source
                .translate(front_right * light_source_speed * delta_time.as_secs_f32());
        }

        if engine.is_key_pressed(Key::L).unwrap() {
            let light_source = engine.light_source_mut().unwrap();

            let back_left = Vec3 { x: -1.0, y: 0.0, z: -1.0 };

            light_source
                .translate(back_left * light_source_speed * delta_time.as_secs_f32());
        }
    })?;

    Ok(())
}

#[derive(Debug)]
pub struct LookAtCamera
{
    position: Vec3<f32>,
    target: Vec3<f32>,
}

impl LookAtCamera
{
    fn new() -> Self
    {
        let position = Vec3 { x: 0.0, y: 0.0, z: 3.0 };

        Self { position, target: Vec3::default() }
    }

    fn target_direction(&self) -> Vec3<f32>
    {
        -(&self.position - &self.target).normalize()
    }

    fn right(&self) -> Vec3<f32>
    {
        let rev_target_direction = (&self.position - &self.target).normalize();

        Vec3::UP.cross(&rev_target_direction).normalize()
    }

    fn left(&self) -> Vec3<f32>
    {
        -self.right()
    }

    fn up(&self) -> Vec3<f32>
    {
        let rev_target_direction = (&self.position - &self.target).normalize();

        rev_target_direction.cross(&self.right())
    }

    fn down(&self) -> Vec3<f32>
    {
        -self.up()
    }
}

impl Camera for LookAtCamera
{
    fn position(&self) -> Vec3<f32>
    {
        self.position.clone()
    }

    fn target(&self) -> Vec3<f32>
    {
        self.target.clone()
    }
}