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, Move, Geom};
use winit::event::Event;
use crate::util::tr_event::TrEvent;

/// Trait which may be inherited by objects that wish to be drawn to the screen
pub trait Drawable {
    fn get(&self,
           window_size: (u32, u32),
           position: (f32, f32),
           rotation: f32,
           size: (f32, f32),
           depth: f32,
    ) -> Vec<VertexTypeContainer>;
}

/// Trait which may be inherited by objects that wish to receive events
pub trait Eventable<T> {
    fn notify(&mut self, event: &TrEvent<T>) -> ();
}

/// Trait which may be inherited by objects that wish to be updated
pub trait Updatable {
    fn update(&mut self, delta_time: f32) -> ();
}

/// 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: Move, geom: Geom) {
        for i in drawable.get(
            self.window_size,
            (mv.pos_x, mv.pos_y),
            geom.rotation,
            (geom.size_x, geom.size_y),
            geom.depth
        ) {
            self.map.push(i);
        }
    }
}