use super::super::Render;
use crate::errors::PipelineError;
use crate::pipeline::new_element::{self, Target};
use crate::pipeline::new_element::{Element, ElementEvent};
use crate::RUNTIME;
use femtovg::{renderer::OpenGl, Canvas};
use std::cell::RefCell;
use std::rc::Rc;
use std::{
    fmt::Debug,
    sync::{Arc, Mutex},
};

#[derive(Clone, Copy, Debug)]
pub enum ElementType {
    Asso,
    Indenpendent,
}

#[derive(Clone)]
pub struct Layer {
    pub visiable: bool,
    pub alpha: f32,
    pub name: String,
    element_type: ElementType,
    element: Rc<RefCell<Element>>,
}

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

impl Layer {
    pub fn new(
        visiable: bool,
        layer_name: String,
        element: Rc<RefCell<Element>>,
        element_type: ElementType,
    ) -> Self {
        Layer {
            alpha: 1.0,
            visiable,
            name: layer_name,
            element,
            element_type,
        }
    }

    pub(super) fn draw(
        &mut self,
        render: &Render,
        window_size: (f32, f32),
    ) -> Result<(), PipelineError> {
        if self.visiable {
            let mut element = self.element.borrow_mut();
            element.r(ElementEvent::Draw, render);
            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;
    }
}