use super::super::Render;
use crate::coords::cms::CMS;
use crate::pipeline::element::{self, Element, ElementID, Target, TargetType};
use crate::pipeline::offscreen_renderer::CanvasWrapper;
use crate::{coords::Range, widgets::widget::Widget};
use chrono::{prelude::*, DateTime};
use femtovg::{renderer::OpenGl, Canvas, ImageId};
use std::{
    cell::{Ref, RefCell},
    fmt::Debug,
    future::Future,
    pin::Pin,
    sync::{Arc, Mutex},
};
use core_extensions::SelfOps;
use crate::errors::PipelineError;

type PrepareFunc = Arc<
    Mutex<
        Option<
            Box<dyn FnOnce(LayerImplSync, Arc<Mutex<CanvasWrapper>>, CMS) -> Target + Sync + Send>,
        >,
    >,
>;
type DrawFunc = Arc<dyn Fn(&Layer, Render, (f32, f32)) + Send + Sync>;
pub type LayerImplSync = Arc<Mutex<Box<dyn LayerImpl + Send + Sync>>>;

#[derive(Clone)]
pub enum AssoElement {
    TimeSeries(Arc<Mutex<element::TimeSeriesElement>>),
    Instant(element::InstantElement),
    Test
}

#[derive(Clone)]
pub struct Layer {
    pub visiable: bool,
    pub alpha: f32,
    pub name: String,
    associated_element: AssoElement,
    time: Option<DateTime<Utc>>,
}

impl Debug for Layer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Layer")
            .field("visiable", &self.visiable)
            .finish()
    }
}

pub trait LayerImpl: Debug {
    fn draw(&self, canvas: &mut Canvas<OpenGl>, cms: &CMS) -> Option<Target>;
}

impl Layer {
    pub fn new(visiable: bool, layer_name: String, element: AssoElement) -> Self {
        Layer {
            alpha: 1.0,
            visiable,
            name: layer_name,
            associated_element: element,
            time: None,
        }
    }

    pub fn set_time(&mut self, time: DateTime<Utc>) {
        self.time = Some(time);
    }

    pub fn draw(&mut self, render: &Render, window_size: (f32, f32)) -> Result<(), PipelineError> {
        if self.visiable {
            match self.associated_element{
                AssoElement::Instant(ref mut e) => {
                    e.render(render);
                }
                AssoElement::TimeSeries(ref e) => {
                    let mut e = e.lock().unwrap();
                    let mut buffer = e.buffer.lock().unwrap();
                    let mut result = buffer.get_mut(&self.time.unwrap()).map(|x| x.as_mut());

                    if result.is_none(){
                        return Ok(()) ;
                    }

                    if let Some(result) = result.unwrap(){
                        let target = result.get_mut_target();

                        let mut canvas = render.get_canvas();
                        let mut canvas = canvas.as_mut().unwrap();
                        let (ox, oy) = target.origin(render);
                        let (x, y) = target.size(render);

                        let result_id = match target.target {
                            TargetType::ImageId(id) => id,
                            TargetType::Mem(ref mem) => {
                                let converted = canvas
                                    .load_image_mem(mem, femtovg::ImageFlags::empty())
                                    .unwrap();
                                target.set_target(TargetType::ImageId(converted));
                                converted
                            }
                        };

                        let paint = femtovg::Paint::image(result_id, ox, oy, x, y, 0.0, self.alpha);
                        let mut path = femtovg::Path::new();
                        path.rect(ox, oy, x, y);
                        canvas.fill_path(&path, &paint);

                    }
                }
                _ => {}
            }
            return Ok(());
        }

        Ok(())
    }

    pub fn get_thumbnail(&self) -> Option<gtk::gdk::Texture> {
        None
    }

    pub fn set_alpha(&mut self, alpha: f32) {
        self.alpha = alpha;
    }

    pub fn change_visiable(&mut self, visiable: bool) {
        self.visiable = visiable;
    }

    pub fn pop_associated_element(&mut self) -> AssoElement {
        std::mem::replace(&mut self.associated_element, AssoElement::Test)
    }

    pub fn get_associated_element(&self) -> &AssoElement {
        &self.associated_element
    }

    pub fn set_associated_element(&mut self, element: AssoElement) {
        self.associated_element = element;
    }

}