use winit::{
    application::ApplicationHandler,
    event::WindowEvent,
    event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
    window::WindowId,
};

pub trait UiState {
    type Event: 'static;
    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self;
    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
    fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
    fn exit(&mut self);
}

pub struct UiApp<State: UiState> {
    state: Option<State>,
    proxy: EventLoopProxy<State::Event>,
}

impl<State: UiState> UiApp<State> {
    pub fn run() {
        let event_loop = EventLoop::with_user_event().build().unwrap();
        let proxy = event_loop.create_proxy();
        event_loop
            .run_app(&mut UiApp::<State> { state: None, proxy })
            .unwrap();
    }
}

impl<State: UiState> ApplicationHandler<State::Event> for UiApp<State> {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.state.is_none() {
            let state = State::new(event_loop, self.proxy.clone());
            self.state = Some(state);
        }
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        let state = self.state.as_mut().unwrap();
        state.window_event(event, event_loop);
    }

    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: State::Event) {
        let state = self.state.as_mut().unwrap();
        state.event(event, event_loop);
    }

    fn exiting(&mut self, _: &ActiveEventLoop) {
        let state = self.state.as_mut().unwrap();
        state.exit();
    }
}