use std::{path::Path, time::Duration};

use anyhow::Result;

use ecs::*;
use engine::prelude::{
    cgmath::{Deg, Matrix3, Vector3, vec3},
    *,
};
use skybox::SkyBox;

fn main() -> Result<()> {
    let mut world_builder = World::builder();

    Engine::new::<GameState>(EngineCreateInfo::default(), &mut world_builder)?;

    world_builder.add_system(GameState::update);
    world_builder.resources.insert(GameState::default());

    let dir = Path::new("C:/Users/M.Huebner/Downloads/skybox");
    // let dir = Path::new("/home/michaelh/Sync/skybox_labeled");
    SkyBox::new(
        &mut world_builder,
        [
            dir.join("left.png"),
            dir.join("right.png"),
            dir.join("front.png"),
            dir.join("back.png"),
            dir.join("top.png"),
            dir.join("bottom.png"),
        ]
        .into_iter(),
    )?;

    let view = world_builder.resources.get_mut::<Scene>().view_mut();
    let camera = view.camera_mut();

    camera.look_at(false);
    camera.set_center(vec3(0.0, 0.0, 0.0));
    camera.set_eye_dir(Vector3::unit_y());
    view.update_buffer()?;

    world_builder.build().run()
}

#[derive(Default)]
enum GameState {
    #[default]
    Startup,

    Game(Game),
}

impl GameState {
    fn update(world: &mut World) -> Result<bool> {
        let me = world.resources.get_mut_unchecked::<Self>();

        match me {
            GameState::Startup => *me = GameState::Game(Game { start: world.now() }),
            GameState::Game(game) => game.update(world)?,
        }

        Ok(true)
    }
}

impl EventConsumer for GameState {
    fn event(&mut self, world: &mut World, event: EngineEvent<'_>) -> Result<()> {
        match self {
            GameState::Startup => (),
            GameState::Game(game) => game.event(world, event)?,
        }

        Ok(())
    }
}

struct Game {
    start: Duration,
}

impl Game {
    fn update(&mut self, world: &mut World) -> Result<()> {
        let now = world.now();
        let view = world.resources.get_mut::<Scene>().view_mut();
        let camera = view.camera_mut();

        let diff = now.as_secs_f32() - self.start.as_secs_f32();
        camera.set_eye_dir(
            Matrix3::from_angle_z(Deg(diff * 36.0))
                * Matrix3::from_angle_x(Deg(diff.sin() * 30.0))
                * Vector3::unit_y(),
        );
        view.update_buffer()?;

        Ok(())
    }

    fn event(&mut self, _world: &mut World, _event: EngineEvent<'_>) -> Result<()> {
        Ok(())
    }
}