use std::error::Error;

use engine::color::Color;
use engine::object::{Builder as ObjectBuilder, Id as ObjectId};
use engine::vector::Vec3;
use engine::vertex::Builder as VertexBuilder;
use engine::{Engine, Key, WindowSize};
use tracing::Level;
use tracing_subscriber::FmtSubscriber;

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

const BLUE: Color<f32> = Color { red: 0.0, blue: 1.0, green: 0.0 };

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::new(&WINDOW_SIZE, "Yaaay lmao")?;

    let mut triangle = ObjectBuilder::new()
        .vertices([
            VertexBuilder::new()
                .pos(Vec3 { x: -0.5, y: -0.5, z: 0.0 })
                .color(Color { red: 1.0, green: 0.0, blue: 0.0 })
                .build()
                .unwrap(),
            VertexBuilder::new()
                .pos(Vec3 { x: 0.5, y: -0.5, z: 0.0 })
                .color(Color { red: 0.0, green: 1.0, blue: 0.0 })
                .build()
                .unwrap(),
            VertexBuilder::new()
                .pos(Vec3 { x: 0.0, y: 0.5, z: 0.0 })
                .color(Color { red: 0.0, green: 0.0, blue: 1.0 })
                .build()
                .unwrap(),
        ])
        .build(ObjectId::new(1))?;

    triangle.translate(Vec3 { x: 0.0, y: 0.4, z: 0.0 });

    engine.add_object(triangle);

    let square = ObjectBuilder::new()
        .vertices([
            VertexBuilder::new()
                .pos(Vec3 { x: 0.5, y: 0.5, z: 0.0 })
                .color(BLUE)
                .build()
                .unwrap(),
            VertexBuilder::new()
                .pos(Vec3 { x: 0.5, y: -0.5, z: 0.0 })
                .color(BLUE)
                .build()
                .unwrap(),
            VertexBuilder::new()
                .pos(Vec3 { x: -0.5, y: -0.5, z: 0.0 })
                .color(BLUE)
                .build()
                .unwrap(),
            VertexBuilder::new()
                .pos(Vec3 { x: -0.5, y: 0.5, z: 0.0 })
                .color(BLUE)
                .build()
                .unwrap(),
        ])
        .indices([0, 1, 3, 1, 2, 3])
        .build(ObjectId::new(2))?;

    engine.add_object(square);

    let cam_speed = 3.0;

    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_mut() +=
                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_mut() +=
                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_mut() +=
                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_mut() +=
                cam_right * cam_speed_dist_adj * delta_time.as_secs_f32();
        }
    })?;

    Ok(())
}