mod graphics;
mod state;

use std::{fmt::Debug, sync::Arc};

use log::debug;
use state::State;
use graphics::Graphics;
use winit::{application::ApplicationHandler, dpi::PhysicalSize, event::{Event, WindowEvent}, event_loop::EventLoop, window::{Window, WindowAttributes}};

pub fn dbg<V: Debug>(v: V) -> V {
    debug!(target: "app", "{:?}", v);
    v
}

struct App<'a> {
    // event_loop: EventLoop<()>,
    window: Option<Arc<Window>>,
    graphics: Option<Graphics<'a>>,
    state: State
}
impl App<'_> {
    fn new() -> Self {
        Self {
            window: None,
            graphics: None,
            state: State::new()
        }
    }
}

impl ApplicationHandler for App<'_> {
    fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
        #[cfg(not(any(target_family = "wasm", target_os = "android")))]
        let window = event_loop.create_window(
                WindowAttributes::default()
                    .with_inner_size(PhysicalSize::new(1080*2/5, 2000*2/5))
            ).unwrap();
        #[cfg(target_os = "android")]
        let window = event_loop.create_window(
                WindowAttributes::default()
                    // .with_inner_size(PhysicalSize::new(1080*2/5, 2000*2/5))
            ).unwrap();
        self.window = Some(Arc::new(window));
        self.graphics = Some(pollster::block_on(Graphics::init(&self.state, self.window.clone().unwrap())));
    }
    fn window_event(
            &mut self,
            event_loop: &winit::event_loop::ActiveEventLoop,
            window_id: winit::window::WindowId,
            event: WindowEvent,
    ) {
        match &event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
                if let Some(g) = &mut self.graphics {
                    self.state.update_if_needed();
                    self.state.render(self.window.as_ref().unwrap().inner_size());
                    g.update(&self.state);
                    g.render(&self.state);
                }
            },
            WindowEvent::MouseWheel { delta, .. } => {
                dbg!(delta);
            },
            _ => {}
        }
        self.graphics.as_mut().unwrap().window_event(&event, &self.window.as_ref().unwrap());
        self.state.window_event(&event, &self.window.as_ref().unwrap());
    }
    fn about_to_wait(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
        if let Some(window) = self.window.as_ref() {
            window.request_redraw();
        }
    }
}

#[cfg(not(target_os = "android"))]
pub fn main() {
    // #[cfg(target_family = "wasm")]
    // let (event_loop, window) = {
    //     use winit::platform::web::WindowExtWebSys;
    //     std::panic::set_hook(Box::new(console_error_panic_hook::hook));
    //     console_log::init().expect("could not initialize logger");

    //     let event_loop = winit::event_loop::EventLoop::new().unwrap();
    //     let window = winit::window::WindowBuilder::new().build(&event_loop).unwrap();

    //     web_sys::window()
    //         .unwrap()
    //         .document()
    //         .unwrap()
    //         .body()
    //         .unwrap()
    //         .append_child(&window.canvas().unwrap())
    //         .unwrap();
    //     (event_loop, window)
    // };
    #[cfg(not(target_family = "wasm"))]
    let event_loop = {
        env_logger::init();

        winit::event_loop::EventLoop::new().unwrap()
    };

    event_loop.run_app(&mut App::new()).unwrap();
}

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app: winit::platform::android::activity::AndroidApp) {
    use winit::platform::android::{EventLoopBuilderExtAndroid, activity::WindowManagerFlags};

    android_logger::init_once(
        android_logger::Config::default()
            .with_max_level(log::LevelFilter::Debug)
            .with_filter(android_logger::FilterBuilder::new().parse("app").build())
    );

    app.set_window_flags(WindowManagerFlags::KEEP_SCREEN_ON | WindowManagerFlags::FULLSCREEN, WindowManagerFlags::empty());

    let event_loop = winit::event_loop::EventLoopBuilder::new()
        .with_android_app(app)
        .build()
        .unwrap();

    event_loop.run_app(&mut App::new()).unwrap();
}