use crate::state::State;
use log::{info, warn};
use std::net::TcpStream;
use winit::{
    application::ApplicationHandler,
    event::WindowEvent,
    event_loop::ActiveEventLoop,
    window::{Window, WindowAttributes, WindowId},
};

pub struct WindowState {
    init: Option<TcpStream>,
    window: Option<(Window, State<'static>)>,
}
impl WindowState {
    pub fn new(init: TcpStream) -> Self {
        Self {
            window: None,
            init: Some(init),
        }
    }
}
impl ApplicationHandler for WindowState {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        info!("app resumed");
        let win = event_loop
            .create_window(WindowAttributes::default().with_maximized(true))
            .unwrap();
        let sta = State::new(self.init.take().unwrap(), unsafe {
            std::mem::transmute::<&Window, &'static Window>(&win)
        })
        .unwrap();
        self.window = Some((win, sta))
    }
    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        _window_id: WindowId,
        event: WindowEvent,
    ) {
        if let Some((win, sta)) = &mut self.window {
            match event {
                WindowEvent::Resized(size) => {
                    sta.renderer.resize(size.width, size.height);
                }
                WindowEvent::RedrawRequested => {
                    sta.draw();
                    win.request_redraw();
                }
                WindowEvent::CloseRequested => {
                    event_loop.exit();
                }
                _ => (),
            }
        }
    }
    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
        if let Some((_win, sta)) = &mut self.window {
            if let Err(e) = sta.update() {
                warn!("update failed: {e:#}")
            }
        }
    }
}

impl Drop for WindowState {
    fn drop(&mut self) {
        if let Some((win, sta)) = self.window.take() {
            drop(sta);
            drop(win)
        }
    }
}