use std::sync::Arc;
use crate::canvas::*;
use crate::canvas::managed::handles::{CanvasFontHandle, CanvasImageHandle, CanvasTextureHandle, Handle};
use crate::canvas::canvas_frame::{Drawable};
use crate::util::vertex::{VertexTypeContainer, TextureVertex3D, Vertex3D};
use winit::event::{DeviceEvent, MouseButton, ElementState, Event, WindowEvent};
use crate::util::tr_event::{TrEvent, TrWindowEvent, TrUIEvent};


///
#[derive(Debug, Clone)]
pub struct Sprite {
    texture_handle: Arc<CanvasTextureHandle>,

}

/// Container class which implements drawable.
impl Sprite {
    fn generate_verts(
        window_size: (u32, u32),
        position: (f32, f32),
        size: (f32, f32),
        depth: f32,
    ) -> Vec<TextureVertex3D> {
        let ss_position = (
            position.0 / window_size.0 as f32 - 1.0,
            position.1 / window_size.1 as f32 - 1.0
        );

        let ss_size = (
            size.0 / window_size.0 as f32,
            size.1 / window_size.1 as f32
        );

        vec![
            TextureVertex3D {
                v_position: [ss_position.0, ss_position.1, depth],                   // top left
                ti_position: [-0.0, -0.0],
            },
            TextureVertex3D {
                v_position: [ss_position.0, ss_position.1 + ss_size.1, depth],          // bottom left
                ti_position: [-0.0, 1.0],
            },
            TextureVertex3D {
                v_position: [ss_position.0 + ss_size.0, ss_position.1 + ss_size.1, depth], // bottom right
                ti_position: [1.0, 1.0],
            },
            TextureVertex3D {
                v_position: [ss_position.0, ss_position.1, depth],                   // top left
                ti_position: [-0.0, -0.0],
            },
            TextureVertex3D {
                v_position: [ss_position.0 + ss_size.0, ss_position.1 + ss_size.1, depth], // bottom right
                ti_position: [1.0, 1.0],
            },
            TextureVertex3D {
                v_position: [ss_position.0 + ss_size.0, ss_position.1, depth],          // top right
                ti_position: [1.0, -0.0],
            },
        ]
    }

    ///
    pub fn new(texture_handle: Arc<CanvasTextureHandle>) -> Sprite {
        Sprite {
            texture_handle: texture_handle.clone(),

        }
    }
}


impl Drawable for Sprite {
    fn render(&self,
              window_size: (u32, u32),
              position: (f32, f32),
              rotation: f32,
              size: (f32, f32),
              depth: f32,
    ) -> Vec<VertexTypeContainer> {
        let normalized_depth = (depth / 255.0);

        vec![
            VertexTypeContainer::TextureType(
                Sprite::generate_verts(window_size, position, size, normalized_depth),
                self.texture_handle.clone())
        ]
    }
    //
    // fn update<T>(&self, delta_time: f32) -> Vec<TrUIEvent<T>> {
    //     Vec::new()
    // }
    //
    // fn notify<Y, T>(&self, tr_event: Vec<TrEvent<Y>>, ui_events: Vec<TrUIEvent<T>>) -> Vec<TrUIEvent<T>> {
    //     match tr_event {
    //         TrEvent::WindowEvent { event: TrWindowEvent::MouseInput { device_id, state, button, modifiers }, .. } => {
    //             match button {
    //                 MouseButton::Left => {
    //                     if *state == ElementState::Pressed {
    //
    //                     }
    //                 }
    //                 _ => {}
    //             }
    //         }
    //         _ => {}
    //     }
    //     Vec::new()
    // }
}