use std::sync::Arc;

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

use crate::ClientEvent;

use super::Client;

#[derive(Clone)]
pub struct AppHandle {
    pub proxy: EventLoopProxy<ClientEvent>,
    pub window: Arc<Window>,
}

pub struct App {
    client: Option<Client>,
    proxy: EventLoopProxy<ClientEvent>,
}

impl App {
    pub fn run() {
        let event_loop = EventLoop::with_user_event().build().unwrap();
        let proxy = event_loop.create_proxy();
        event_loop
            .run_app(&mut App {
                client: Default::default(),
                proxy,
            })
            .unwrap();
    }
}

impl ApplicationHandler<ClientEvent> for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.client.is_none() {
            let client = Client::new(event_loop, self.proxy.clone());
            self.client = Some(client);
        }
    }

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

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

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

impl AppHandle {
    pub fn send(&self, event: ClientEvent) {
        self.proxy.send_event(event).unwrap_or_else(|_| panic!());
        self.window.request_redraw();
    }
}