use crate::util::vertex_3d::{Vertex3D};
use std::sync::Arc;
use std::collections::HashMap;
use crate::canvas::canvas_state::{Drawable, CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, DrawableTest};
use crate::canvas::shader::text_shader::GlyphInstance;
use std::hash::Hash;

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

impl CanvasFrame {

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


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


struct Pair<T> {
    x: T,
    y: T,
}

impl Pair<Vertex3D> {
    fn new(x: Vertex3D, y: Vertex3D) -> Self {
        Self {
            x,
            y,
        }
    }
}

impl Pair<GlyphInstance> {
    fn new(x: GlyphInstance, y: GlyphInstance) -> Self {
        Self {
            x,
            y,
        }
    }
}

pub struct GenericCanvasFrame<H, V, In> {
    frame_data: HashMap<H, Vec<(Vec<V>, Vec<In>)>>
}

impl<V, In> GenericCanvasFrame<Vertex3D, V, In>  {

    /// Creates a bare canvas frame with empty accumulators
    pub fn new() -> GenericCanvasFrame<Vertex3D, V, In> {
        GenericCanvasFrame {
            frame_data: Default::default()
        }
    }

    pub fn draw(&mut self, drawable: &dyn DrawableTest<V, Vertex3D, In>) {
        self.frame_data
            .entry(drawable.get_handle().clone())
            .or_insert(Vec::new())
            .push((drawable.get_vertices(), drawable.get_instances()));
    }
}