mod graphics;
mod state;

use std::sync::Arc;

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

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();
        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);
            },
            e => {
                if let Some(g) = &mut self.graphics {
                    g.window_event(&e, &self.window.as_ref().unwrap());
                }
                self.state.window_event(&e, &self.window.as_ref().unwrap());
            }
        }
    }
    fn device_event(
            &mut self,
            event_loop: &winit::event_loop::ActiveEventLoop,
            device_id: winit::event::DeviceId,
            event: winit::event::DeviceEvent,
    ) {
        self.state.device_event(&event);    
    }
    fn about_to_wait(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
        if let Some(window) = self.window.as_ref() {
            window.request_redraw();
        }
    }
}

// impl<'a> App<'a> {
//     fn run(&mut self, event_loop: EventLoop<()>) {
//         dbg!("run");
//         event_loop.run_app(move |event, target| {
//             // dbg!(&event);
//             let _ = &self;
//             // let _ = (&graphics, &window, &state);
//             match event {
//                 Event::Resumed => {
//                     // std::thread::sleep(Duration::from_secs(5));
//                     self.graphics = Some(pollster::block_on(Graphics::init(&self)));
//                 },
//                 Event::WindowEvent {
//                     event: WindowEvent::CloseRequested,
//                     ..
//                 } => target.exit(),
//                 Event::WindowEvent {
//                     event: WindowEvent::RedrawRequested,
//                     ..
//                 } => {
//                     if let Some(g) = &mut self.graphics {
//                         self.state.update_if_needed();
//                         self.state.render(self.window.inner_size());
//                         g.update(&self.state);
//                         g.render(&self.state);
//                     }
//                 }
//                 e => {
//                     if let Some(g) = &mut self.graphics {
//                         g.event(&e, &self.window);
//                     }
//                     self.state.event(&e, &self.window);
//                 }
//             }
//         }).unwrap();
//     }
// }

#[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();
    // static mut graphics: Option<Graphics> = None;

    // event_loop.run(move |event, target| {
    //     // let _ = (&graphics, &window, &state);
    //     match event {
    //         Event::Resumed => {
    //             graphics = Some(pollster::block_on(Graphics::init(&window, &mut state)));
    //         },
    //         Event::WindowEvent {
    //             event: WindowEvent::CloseRequested,
    //             ..
    //         } => target.exit(),
    //         Event::WindowEvent {
    //             event: WindowEvent::RedrawRequested,
    //             ..
    //         } => {
    //             if let Some(g) = &mut graphics {
    //                 g.update(&state);
    //                 g.render(&state);
    //             }
    //         }
    //         _ => {}
    //     }
        
    // }).unwrap();

    // #[cfg(not(target_arch = "wasm32"))]
    // {
    //     let state = State::new();
    //     pollster::block_on(Graphics::init(&window, state)).run(event_loop);
    // }
    // #[cfg(target_arch = "wasm32")]
    // {
    //     use winit::platform::web::WindowExtWebSys;
    //     web_sys::window()
    //         .unwrap()
    //         .document()
    //         .unwrap()
    //         .body()
    //         .unwrap()
    //         .append_child(&window.canvas().unwrap())
    //         .unwrap();
    //     wasm_bindgen_futures::spawn_local(async move {
    //         Graphics::init(&window, State::new()).await.run(event_loop);
    //     });
    // }
}

#[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());
    log::error!("testbbbbbbbbbbb");
    println!("coucou");

    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();
    let window = winit::window::WindowBuilder::new().build(&event_loop).unwrap();

    App {
        window: &window,
        graphics: None,
        state: State::new()
    }.run(event_loop);
    // main();
    // use std::thread;
    // use std::time::Duration;

    // use winit::platform::android::EventLoopBuilderExtAndroid;
    // use winit::event_loop::EventLoopBuilder;
    // use winit::window::WindowBuilder;

    // let event_loop = EventLoopBuilder::new()
    //     .with_android_app(app)
    //     .build()
    //     .expect("Can’t build event loop");

    // let mut window_builder = WindowBuilder::new();
    // let window = window_builder.build(&event_loop)
    //     .expect("Can't create window!");

    // thread::sleep(Duration::from_secs(2));

    // let state = State::new();
    // pollster::block_on(Graphics::init(&window, state)).run(event_loop);
}