mod graphics;
mod state;
use std::time::Duration;

use state::State;
use graphics::Graphics;
use winit::{event::{Event, WindowEvent}, event_loop::EventLoop, window::Window};

struct App<'a> {
    // event_loop: EventLoop<()>,
    window: &'a Window,
    graphics: Option<Graphics<'a>>,
    state: State
}
impl<'a> App<'a> {
    fn run(&mut self, event_loop: EventLoop<()>) {
        dbg!("run");
        event_loop.run(move |event, target| {
            dbg!(&event);
            let _ = &self;
            // let _ = (&graphics, &window, &state);
            match event {
                Event::Resumed => {
                    std::thread::sleep(Duration::from_secs(10));
                    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();
                        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(target_os = "android")]
    let (event_loop, window) = {
        use winit::platform::android::EventLoopBuilderExtAndroid;
        let event_loop = winit::event_loop::EventLoopBuilder::new()
            .with_android_app(app)
            .build()
            .unwrap();
        let window = winit::window::WindowBuilder::new().build(&event_loop).unwrap();
        (event_loop, window)
    };
    #[cfg(not(any(target_family = "wasm", target_os = "android")))]
    let (event_loop, window) = {
        env_logger::init();

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

    App {
        window: &window,
        graphics: None,
        state: State::new()
    }.run(event_loop);
    // 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;

    android_logger::init_once(android_logger::Config::default());
    log::error!("testbbbbbbbbbbb");

    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);
}