use std::error::Error;

use engine::color::Color;
use engine::object::{Id as ObjectId, Object};
use engine::vector::Vec3;
use engine::vertex::Builder as VertexBuilder;
use engine::{Engine, 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 = Object::new(
        ObjectId::new(1),
        &[
            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(),
        ],
        None,
    )?;

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

    engine.add_object(triangle);

    let square = Object::new(
        ObjectId::new(2),
        &[
            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(),
        ],
        Some(&[0, 1, 3, 1, 2, 3]),
    )?;

    engine.add_object(square);

    engine.start(|engine| {
        let obj = engine.get_object_by_id_mut(ObjectId::new(1));
    })?;

    Ok(())
}