use std::sync::Arc;
use std::collections::HashMap;
use std::hash::Hash;
use crate::canvas::*;
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, Handle};
use vulkano::pipeline::vertex::Vertex;
use std::any::Any;
use crate::{VertexTypeContainer};
use winit::event::Event;
use crate::util::tr_event::{TrEvent, TrUIEvent};
use crate::drawables::sprite::{Velocity, Geometry};

/// Trait which may be inherited by objects that wish to be drawn to the screen
pub trait Drawable {

    // Render expects the implementer to create custom render logic based on interior data within
    // the struct. This data as of right now, will *only* be mutatable via events & update
    fn render(&self,
              window_size: (u32, u32),
              position: (f32, f32),
              rotation: f32,
              size: (f32, f32),
              depth: f32,
    ) -> Vec<VertexTypeContainer>;

    // Update simply passes the delta time. The implementor doesn't necessarily need to use delta_time
    // or even add anything other than a Vec::new() to the function.
    fn update<T>(&self, delta_time: f32) -> Vec<TrUIEvent<T>>;

    // Notify is where custom events created in other parts of the system will be ingested. It
    // might be a good idea in the future to have some of pre-function-call filtering so we
    // don't have as many notifies that just immediately reject.
    fn notify<Y, T>(&self, tr_event : Vec<TrEvent<Y>>, ui_events: Vec<TrUIEvent<T>>) -> Vec<TrUIEvent<T>>;
}


/// Accumulator for Vectors of VertexTypes
#[derive(Default)]
pub struct CanvasFrame {
    pub map: Vec<VertexTypeContainer>,
    window_size: (u32, u32),
}

impl CanvasFrame {
    pub fn new(window_size: (u32, u32)) -> CanvasFrame {
        CanvasFrame {
            map: vec![],
            window_size: window_size,
        }
    }

    /// Push this drawable onto the back of the accumulator
    pub fn add(&mut self, drawable: Vec<VertexTypeContainer>) {
        for i in drawable {
            self.map.push(i);
        }
    }

    /// Push this drawable onto the back of the accumulator
    pub fn draw(&mut self, drawable: &dyn Drawable, mv: Velocity, geom: Geometry) {
        for i in drawable.render(
            self.window_size,
            (mv.pos_x, mv.pos_y),
            geom.rotation,
            (geom.size_x, geom.size_y),
            geom.depth
        ) {
            self.map.push(i);
        }
    }
}