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::render_system::Position;

enum CustomEvent {

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

}


/// 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, pos: Position, 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);
    //     }
    // }
}