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

use canvas::{
    Application,
    Canvas,
    texture::TextureHandle,
    sprite::{TextureSprite, TextSprite},
    utils::Position,
};

use std::time::Instant;

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::Info)
        .chain(std::io::stdout())
        .chain(fern::log_file("output.log")?)
        .apply()?; Ok(())
}

struct ExampleState {
    pub texture: TextureHandle,
    pub tex_sprite: TextureSprite,
    pub sub_sprite: TextureSprite,
    pub txt_sprites: Vec<TextSprite>,
    pub last_instant: Instant,
    pub last_offset: u32,
    pub last_pos: Position,
    pub last_rot: f32,
}

struct ExampleApp {}

impl Application<ExampleState> for ExampleApp {

    fn init(canvas: &mut Canvas) -> Result<ExampleState, &'static str> {
        use canvas::{
            utils::Size,
            sprite::Sprite,
        };

        //// 20 x 20 sprite of a picture
        let texture = canvas.create_texture_from_file("assets/camel.jpg", None, None, None)
            .unwrap();
        let mut tex_sprite = canvas.create_texture_sprite(Size {w: 1280, h: 720});
        tex_sprite.set_texture(texture.clone(), Some(Position {x: 0, y: 0}), 1.0);

        let mut sub_sprite = canvas.create_texture_sprite(Size {w: 100, h: 100});
        sub_sprite.set_texture(texture.clone(), Some(Position {x: 350, y: 0}), 1.0);

        let mut txt_sprites = Vec::<TextSprite>::with_capacity(10);
        for x in 0..5 {
            for y in 0..2 {
                let mut sprite = canvas.create_text_sprite("00", Size {w: 200, h: 200});
                sprite.set_position(Position { x: x * 100, y: y * 100});
                txt_sprites.push(sprite);
            }
        }

        canvas.clear();
        canvas.update();

        let last_instant = Instant::now();

        Ok(ExampleState {
            texture,
            tex_sprite,
            sub_sprite,
            txt_sprites,
            last_instant,
            last_offset: 0,
            last_pos: Position::origin(),
            last_rot: 0.0,
        })
    }

    fn tick(state: &mut ExampleState, canvas: &mut Canvas) -> Result<(), &'static str> {
        use canvas::sprite::Sprite;

        let now = Instant::now();
        let elapsed = now.duration_since(state.last_instant).as_millis();
        state.last_instant = now;
        debug!("frame time: {}ms", elapsed);
        for sprite in state.txt_sprites.iter_mut() {
            sprite.set_text(&format!("{}", elapsed));
        }

        //state.sub_sprite.for_each(|pix| unsafe {pix.flat = pix.flat.wrapping_add(1);});

        state.last_offset += 1;
        state.last_pos.y += 1;
        state.last_rot += 1.0;
        state.tex_sprite.set_texture(state.texture.clone(), None, state.last_rot/100.0);
        state.sub_sprite.set_texture(state.texture.clone(),
                                     Some(Position {x: state.last_offset, y: 0}), 1.0);
        state.sub_sprite.set_position(state.last_pos);
        state.sub_sprite.set_rotation(state.last_rot);

        //state.sub_sprite.set_scale(state.last_rot/1000.0);

        // inputs
        //if canvas.key_pressed(Key::A) {
        //    unimplemented!();
        //}
        //
        //if canvas.key_released(Key::A) {
        //    unimplemented!();
        //}
        //
        //match canvas.get_key_presses() {
        //    Key::A => unimplemented!(),
        //    _ => (),
        //}
        //
        //match canvas.get_key_releases() {
        //    Key::A => unimplemented!(),
        //    _ => (),
        //}

        //let _mouse = canvas.get_mouse_position();

        //// outputs
        //canvas.set_clear_color(Color::BLACK);
        //canvas.clear();

        //// white rectangle inset by one in the sprite
        //let mut bas_sprite = canvas.create_shape_sprite();
        //bas_sprite.set_shape(Shape::Rectangle (Rectangle {size: Size {w: 38, h: 38}}));
        //bas_sprite.set_color(Color::WHITE);
        //canvas.draw(&bas_sprite);



        //// scaled sprite of a manually drawed texture
        //let texture = canvas.create_texture(Size {w: 20, h: 20}, Some(Color::WHITE));
        //texture.borrow_mut().set_pixel(Position {x: 0, y: 0}, Pixel::rgb(0, 255, 0));
        //let _  = texture.borrow_mut().iter_mut(); //iterate on whole texture
        //pix_sprite = canvas.create_texture_sprite(Size {w: 20, h: 20}, 2.0);
        //pix_sprite.set_texture(texture, None);
        //let _  = pix_sprite.iter_mut(); //only iterate on the part used by the sprite
        //canvas.draw(&pix_sprite);

        //// floating text
        //let mut txt_sprite = canvas.create_text_sprite(Size {w: 10, h: 10}, 5.0);
        //txt_sprite.set_text("text");
        //txt_sprite.set_color(Color::BLACK);

        //// generic operations
        //txt_sprite.set_position(Position {x: 0, y: 0});
        //txt_sprite.set_rotation(50.0);
        //txt_sprite.set_alpha(255);
        //txt_sprite.set_scale(0.5);
        //canvas.draw(&txt_sprite);


        canvas.draw(&mut state.tex_sprite);
       // canvas.draw(&mut state.sub_sprite);
        for sprite in state.txt_sprites.iter_mut() {
            canvas.draw(sprite);
        }
        canvas.update();

        Ok(())
    }
}

fn main() -> Result<(), &'static str> {
    use canvas::utils::Size;

    setup_logger()
        .map_err(|_| "Failed to setup logger")?;
    canvas::run_canvas("vk_example", Size {w: 1280, h: 720}, ExampleApp {});
}