use anyhow::Result;

use ecs::*;
use engine::prelude::*;

struct CameraControlStart;
struct CameraControlEnd;
struct CameraControlMove {
    x: u32,
    y: u32,
}

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

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

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

    world_builder.events.register_event::<CameraControlStart>();
    world_builder.events.register_event::<CameraControlEnd>();
    world_builder.events.register_event::<CameraControlMove>();

    world_builder.events.add_reader(Game::enable_camera_control);
    world_builder
        .events
        .add_reader(Game::disable_camera_control);
    world_builder.events.add_reader(Game::update_mouse);

    let scene: &mut Scene = world_builder.resources.get_mut()?;
    let view = scene.view_mut();
    let camera_control = FreeCameraControl::new(view)?;
    world_builder.resources.insert(camera_control);

    world_builder.build().run()
}

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

    Game(Game),
}

impl GameState {
    fn update(commands: &mut Commands, game_state: &mut GameState) -> Result<bool> {
        match game_state {
            GameState::Startup => *game_state = GameState::Game(Game),
            GameState::Game(game) => game.update(commands)?,
        }

        Ok(true)
    }
}

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

        Ok(())
    }
}

struct Game;

impl Game {
    fn enable_camera_control(
        _: &CameraControlStart,
        _commands: &mut Commands,
        camera_control: &mut FreeCameraControl,
    ) -> Result<()> {
        camera_control.mouse_down();

        Ok(())
    }

    fn disable_camera_control(
        _: &CameraControlEnd,
        _commands: &mut Commands,
        camera_control: &mut FreeCameraControl,
    ) -> Result<()> {
        camera_control.mouse_release();

        Ok(())
    }

    fn update_mouse(
        camera_move: &CameraControlMove,
        _commands: &mut Commands,
        camera_control: &mut FreeCameraControl,
        scene: &mut Scene,
    ) -> Result<()> {
        camera_control.mouse_move(camera_move.x, camera_move.y, scene.view_mut())?;

        Ok(())
    }

    fn update(&mut self, _commands: &mut Commands) -> Result<()> {
        Ok(())
    }

    fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> {
        match event {
            EngineEvent::MouseButtonDown(MouseButton::Left) => {
                commands.write_event(CameraControlStart)
            }
            EngineEvent::MouseButtonUp(MouseButton::Left) => commands.write_event(CameraControlEnd),
            EngineEvent::MouseMotion(x, y) => commands.write_event(CameraControlMove { x, y }),

            _ => (),
        }

        Ok(())
    }
}