use crate::colliders;
use crate::colors;
use crate::entities;
use crate::gamestate;
use crate::resources;
use crate::svg_loader;
use crate::systems;
use crate::utils;

pub struct InGameState {
    gui_svg: web_sys::SvgElement,
    world: legion::World,
    resources: legion::Resources,
    schedule: legion::Schedule,
}

impl InGameState {
    pub fn new(level: svg_loader::SvgLevel) -> InGameState {
        let mut rendering = resources::Rendering::new("game-canvas").unwrap();
        let foreground = rendering.register_image(level.foreground_image.clone());
        let background = rendering.register_image(level.background_image.clone());

        let mut resources = legion::Resources::default();
        let mut world = legion::World::default();

        resources.insert(resources::Clock::new());
        resources.insert(rendering);
        resources.insert(resources::Camera::new(1920.0, 1080.0));
        resources.insert(colliders::CollisionWorld::new());

        let player = entities::create_player(&mut world);
        resources.insert(resources::Player(player));

        level.apply_colliders(&mut world);

        let schedule = legion::Schedule::builder()
            .add_system(colliders::synchronize_collisision_world_system())
            .flush()
            .add_system(colliders::update_collision_world_system())
            .flush()
            .add_thread_local(systems::move_camera_to_player_system())
            .flush()
            .add_thread_local(systems::camera_system())
            .flush()
            .add_thread_local(systems::draw_level_layer_system(background))
            .add_thread_local(systems::draw_tmp_player_system())
            .add_thread_local(systems::draw_level_layer_system(foreground))
            .build();

        InGameState {
            gui_svg: utils::get_element_by_id("ingame-ui").unwrap(),
            world,
            resources,
            schedule,
        }
    }
}

impl gamestate::State for InGameState {
    fn init(&mut self, mut init: gamestate::StateInitializer) -> gamestate::Transition {
        self.gui_svg
            .style()
            .set_property("display", "block")
            .unwrap();

        init.register_keyevents();
        gamestate::Transition::Loop
    }

    fn deinit(&mut self) {
        self.resources
            .get::<resources::Rendering>()
            .unwrap()
            .set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
        self.gui_svg
            .style()
            .set_property("display", "none")
            .unwrap();
    }

    fn event(&mut self, event: gamestate::Event) -> gamestate::Transition {
        let mut cam = self.resources.get_mut::<resources::Camera>().unwrap();
        match event {
            gamestate::Event::KeyDown("w") => cam.position.y -= 50.0,
            gamestate::Event::KeyDown("a") => cam.position.x -= 50.0,
            gamestate::Event::KeyDown("s") => cam.position.y += 50.0,
            gamestate::Event::KeyDown("d") => cam.position.x += 50.0,
            _ => (),
        }
        gamestate::Transition::Keep
    }

    fn update(&mut self) -> gamestate::Transition {
        {
            let rendering = self.resources.get::<resources::Rendering>().unwrap();
            rendering.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
            rendering.set_fill_style(&colors::BACKGROUND);
            rendering.fill_rect(0.0, 0.0, 1920.0, 1080.0);
        }
        self.schedule.execute(&mut self.world, &mut self.resources);
        gamestate::Transition::Loop
    }
}