use crate::colors;
use crate::components;
use crate::gamestate;
use crate::resources;
use crate::sprites;
use crate::states;
use crate::svg_loader;

pub struct LevelLoadingState {
    node_world: legion::World,
    resources: legion::Resources,
    node_schedule: legion::Schedule,
}

impl LevelLoadingState {
    pub fn new() -> LevelLoadingState {
        let mut resources = legion::Resources::default();
        resources.insert(resources::Clock::new());
        resources.insert(resources::Rendering::new("game-canvas").unwrap());

        let mut node_world = legion::World::default();
        node_world.push((
            components::TheSun,
            components::Position::new(1920.0 / 2.0, 1080.0 / 2.0),
        ));

        let node_schedule = legion::Schedule::builder()
            .add_thread_local(components::draw_thesun_system())
            .build();

        LevelLoadingState {
            node_world,
            resources,
            node_schedule,
        }
    }
}

impl gamestate::State for LevelLoadingState {
    fn init(&mut self, init: gamestate::StateInitializer) -> gamestate::Transition {
        let mut rendering = resources::Rendering::new("game-canvas").unwrap();
        let handle = init.get_handle();
        wasm_bindgen_futures::spawn_local(async move {
            let level = svg_loader::SvgLevel::load_from_svg_file("resources/testlevel.svg")
                .await
                .unwrap();

            sprites::Sprite::Player
                .load_and_register(&mut rendering)
                .await;

            handle.do_transition(gamestate::Transition::replace(states::InGameState::new(
                level, rendering,
            )));
        });
        gamestate::Transition::Loop
    }

    fn update(&mut self) -> gamestate::Transition {
        {
            let rendering = self.resources.get_mut::<resources::Rendering>().unwrap();
            rendering.set_fill_style(&colors::BACKGROUND);
            rendering.fill_rect(0.0, 0.0, 1920.0, 1080.0);
        }

        self.node_schedule
            .execute(&mut self.node_world, &mut self.resources);

        gamestate::Transition::Loop
    }
}