use std::sync::Arc;

use bevy_app::{App, PluginsState};
use bevy_ecs::world::World;
use winit::{
    application::ApplicationHandler, event::WindowEvent, event_loop::ActiveEventLoop,
    window::WindowId,
};

use super::{config::WindowConfig, raw_handle::WindowWrapper};

pub struct WindowState {
    app: App,
}

impl WindowState {
    pub fn new(app: App) -> Self {
        Self { app }
    }

    fn world(&self) -> &World {
        self.app.world()
    }
}

impl ApplicationHandler for WindowState {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window_config = self.world().get_resource::<WindowConfig>().unwrap();

        let window = event_loop.create_window(window_config.into()).unwrap();
        self.app
            .world_mut()
            .insert_resource(WindowWrapper(Arc::new(window)));
    }

    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: winit::event::StartCause) {
        if self.app.plugins_state() == PluginsState::Ready {
            self.app.finish();
            self.app.cleanup();
        }
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::CloseRequested => {
                log::debug!("The close button was pressed; stopping");
                event_loop.exit();
            }
            WindowEvent::RedrawRequested => {
                if self.app.plugins_state() == PluginsState::Cleaned {
                    self.app.update();
                }

                let window_wrapper = self.app.world().get_resource::<WindowWrapper>().unwrap();

                window_wrapper.0.request_redraw();
            }
            _ => {}
        }
    }

    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {}
}