#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};

use pollster::FutureExt;

mod canvas;
pub use canvas::Canvas;
pub use canvas::Application;
pub mod io;
pub mod shape;
pub mod sprite;
pub mod texture;
pub mod utils;
mod renderer;

use utils::Size;

pub fn run_canvas<S, A>(title: &'static str, size: Size, _: A) -> !
where
    S: 'static + Sized,
    A: 'static + Application<S>,
{
    use winit::{
        event_loop::EventLoop,
        window::WindowBuilder,
    };
    // construct window
    let event_loop = EventLoop::new();
    let window = WindowBuilder::new()
        .with_inner_size(size)
        .with_resizable(false)
        .with_title(title)
        .with_visible(false) //keep window invisible until we are ready to write to it
        .build(&event_loop)
        .expect("Failed to create window");

    // construct canvas
    let size = window.inner_size();
    let mut canvas = Canvas::create(&window, size.into()).block_on().unwrap();

    // init application
    let mut state = A::init(&mut canvas).unwrap();
    canvas.update();
    window.set_visible(true);

    // let event loop highjack thread
    event_loop.run(move |event, _, control_flow| {
        use winit::{
            event_loop::ControlFlow,
            event::{Event, WindowEvent},
        };

        *control_flow = ControlFlow::Poll;

        match event {

            Event::WindowEvent {event, ..} => match event {
                WindowEvent::CloseRequested => {
                    info!("Close requested, shutting down...");
                    *control_flow = ControlFlow::Exit;
                },
                WindowEvent::Resized (size) => {
                    canvas.set_size(size.into());
                },
                WindowEvent::ScaleFactorChanged {/*new_inner_size, */..} => {
                    // new_inner_size is &&mut so we have to dereference it twice
                    // canvas does not support resize, do nothing
                    //canvas.set_size((*new_inner_size).into());
                },
                _ => (),
            },

            Event::MainEventsCleared => {
                let _ = A::tick(&mut state, &mut canvas);
           },
            Event::RedrawRequested(_) => {
                canvas.clear();
                let _ = canvas.update();
            },

            _ => ()
        };
    });
}

#[cfg(test)]
mod tests {
    use crate::{Application, Canvas};

    fn setup_logger() -> Result<(), fern::InitError> {
        use fern::colors::{Color, ColoredLevelConfig};

        let colors = ColoredLevelConfig::new()
            .info(Color::Green)
            .debug(Color::Magenta)
            .warn(Color::Yellow)
            .error(Color::Red);

        fern::Dispatch::new()
            .format(move |out, message, record| {
                out.finish(format_args!(
                    "{}[{}][{}] {}",
                    chrono::Local::now().format("[%H:%M:%S]"),
                    colors.color(record.level()),
                    record.target(),
                    message
                ))
            })
            .level(log::LevelFilter::Debug)
            .chain(std::io::stdout())
            .chain(fern::log_file("output.log")?)
            .apply()?;
        Ok(())
    }

    struct TestApp {}

    impl Application for TestApp {

        fn init(&mut self, _canvas: &mut Canvas) -> Result<(), &'static str> {
            Ok(())
        }

        fn tick(&mut self, _canvas: &mut Canvas) -> Result<(), &'static str> {
            Ok(())
        }
    }

    #[test]
    fn run_no_app() {
        use crate::utils::Size;

        crate::run_canvas("vk_create", Size {w: 1280, h: 720}, TestApp {});
    }
}