use crate::util::vertex_3d::{Vertex3D};
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 crate::canvas::managed::shader::text_shader::GlyphInstance;

// I don't think this is going to work without getting into Box'ing
pub trait DrawableTest<V, H, In> where H: Handle{
    fn get_vertices(&self) -> Vec<V>;
    fn get_instances(&self) -> Vec<In>;
    fn get_handle(&self) -> H;
}


pub struct DrawableTestee {
    pub vertices: Vec<u32>,
    pub instances: Vec<u32>,
    pub handle: Arc<CanvasTextureHandle>
}

impl<V, H: Handle, In> DrawableTest<V, H, In> for DrawableTestee {
    fn get_vertices(&self) -> Vec<V> {
        unimplemented!()
    }

    fn get_instances(&self) -> Vec<In> {
        unimplemented!()
    }

    fn get_handle(&self) -> H {
        unimplemented!()
    }
}




pub trait Drawable {

    fn get_vertices(&self) -> Vec<(f32, f32, f32)>;
    fn get_color(&self) -> (f32, f32, f32, f32);
    fn get_ti_coords(&self) -> Vec<(f32, f32)>;

    fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>>;
    fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>>;
    // fn get_text_handle(&self) -> Option<Arc<CanvasTextHandle>>;

    // These needs to return a vector of raw-ass data in addition to the definition for this data
    fn collect(&self) -> Vec<RuntimeVertexDef> {
        let color = self.get_color();
//        self.get_vertices().iter().zip(self.get_ti_coords().iter()).map(|(a, b)|
//            Vertex3D {
//                v_position: [a.0, a.1, a.2],
//                color: [color.0, color.1, color.2, color.3],
//                ti_position: [b.0, b.1],
//            }).collect()
        // TODO
        vec![RuntimeVertexDef::from_primitive(0)]
    }
}

pub trait VertexDefinitionAndData {

}

pub struct CanvasFrame {
    pub colored_drawables: Vec<RuntimeVertexDef>,
    pub textured_drawables: HashMap<Arc<CanvasTextureHandle>, Vec<Vec<RuntimeVertexDef>>>,
    pub image_drawables: HashMap<Arc<CanvasImageHandle>, Vec<Vec<RuntimeVertexDef>>>,
    pub text_drawables: HashMap<Arc<CanvasFontHandle>, Vec<GlyphInstance>>
}

impl CanvasFrame {

    /// Creates a bare canvas frame with empty accumulators a
    pub fn new() -> CanvasFrame {
        CanvasFrame {
            colored_drawables: vec![],
            textured_drawables: Default::default(),
            image_drawables: Default::default(),
            text_drawables: Default::default()
        }
    }

    //
//    pub fn draw_test<V : VertexDefinitionAndData, H: Handle, In>(&mut self, drawable: &dyn DrawableTest<V, H, In>) {
//        let h = drawable.get_handle();
//
//        let v = drawable.get_vertices();
//
//        let v = v.get(0).unwrap();
//
//        // need to fill up the drawables....
//
//
//    }


    // TODO: Fix this for text and fonts
    /// Accumulates the drawables collected Vertex2D's
    pub fn draw(&mut self, drawable: &dyn Drawable) {
        match drawable.get_texture_handle() {
            Some(handle) => {
                self.textured_drawables
                    .entry(handle.clone())
                    .or_insert(Vec::new())
                    .push(drawable.collect());
            }
            None => {
                match drawable.get_image_handle() {
                    Some(handle) => {
                        self.image_drawables
                            .entry(handle.clone())
                            .or_insert(Vec::new())
                            .push(drawable.collect());
                    }
                    None => {
                        self.colored_drawables.extend(drawable.collect());
                    }
                }
            }
        }
    }
}