use crate::geometry::*;
use crate::render::{Surface, Shader, Surfaces};

use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use std::cell::RefCell;
use std::io;

#[cfg(feature="threads")]
use std::sync::{Arc, Mutex};

#[derive(Debug)]
pub struct ShaderBinding {
    shader: Option<Box<dyn Shader>>,
    rect: Rectangle<u8, Virtual>,
    opacity: u8
}

#[derive(Clone)]
pub struct BoundSurface<T> {
    pub binding: T
}

impl Debug for BoundSurface<Rc<RefCell<ShaderBinding>>> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BoundSurface")
        .field("shader", &self.binding.borrow().shader)
        .field("opacity", &self.binding.borrow().opacity)
        .finish()
    }
}

pub type SimpleSurface = BoundSurface<Rc<RefCell<ShaderBinding>>>;

impl Default for BoundSurface<Rc<RefCell<ShaderBinding>>>{
    fn default() -> Self {
        Self {
            binding: Rc::new(RefCell::new(ShaderBinding {
                shader: None,
                rect: Rectangle::everything(),
                opacity: 255
            })),
        }
    }
}

impl Surface for BoundSurface<Rc<RefCell<ShaderBinding>>> {
    fn rect(&self) -> Rectangle<u8, Virtual> {
        self.binding.borrow().rect.clone()
    }

    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut f: F) {
        if let Some(ref shader) = self.binding.borrow().shader {
            f(shader.as_ref());
        }
    }

    fn set_shader(&mut self, shader: Box<dyn Shader>) {
        self.binding.borrow_mut().shader = Some(shader);
    }

    fn clear_shader(&mut self) {
        self.binding.borrow_mut().shader = None;
    }
    
    fn set_rect(&mut self, rect: &Rectangle<u8, Virtual>) {
        self.binding.borrow_mut().rect = rect.clone();
    }

    fn opacity(&self) -> u8 {
        self.binding.borrow().opacity
    }

    fn set_opacity(&mut self, opacity: u8) {
        self.binding.borrow_mut().opacity = opacity
    }
}

#[cfg(feature="threads")]
pub type SharedSurface = BoundSurface<Arc<Mutex<ShaderBinding>>>;

#[cfg(feature="threads")]
impl Default for BoundSurface<Arc<Mutex<ShaderBinding>>> {
    fn default() -> Self {
        Self {
            binding: Arc::new(Mutex::new(ShaderBinding {
                shader: None,
                rect: Rectangle::everything()
            })),
        }
    }
}

#[cfg(feature="threads")]
impl Surface for BoundSurface<Arc<Mutex<ShaderBinding>>> {
    fn rect(&self) -> Rectangle<u8, Virtual> {
        let r = self.binding.lock().unwrap();
        r.rect.clone()
        //self.binding.lock().unwrap().rect.clone()
    }

    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut f: F) {
        if let Some(ref shader) = self.binding.lock().unwrap().shader {
            f(shader.as_ref());
        }
    }

    fn set_shader(&mut self, shader: Box<dyn Shader>) {
        self.binding.lock().unwrap().shader = Some(shader);
    }

    fn clear_shader(&mut self) {
        self.binding.lock().unwrap().shader = None;
    }
}

#[cfg(feature="threads")]
impl Debug for BoundSurface<Arc<Mutex<ShaderBinding>>> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BoundSurface")
        .field("shader", &self.binding.lock().unwrap().shader)
        .finish()
    }
}

#[derive(Clone)]
pub struct SurfacePool<S: Surface + Default> {
    surfaces: Vec<S>
}

impl<S: Surface + Debug> Debug for SurfacePool<S> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.surfaces.fmt(f)
    }
}

impl<S: Surface + Default> SurfacePool<S> {
    pub const fn new() -> Self {
        Self {
            surfaces: Vec::new()
        }
    }

    pub fn iter(&self) -> std::slice::Iter<S> {
        self.surfaces.iter()
    }
}

impl<S: Surface + Default> Surfaces<S> for SurfacePool<S> {
    fn new_surface(&mut self, area: &Rectangle<u8, Virtual>) -> Result<S, io::Error> {
        let mut surface = S::default();
        surface.set_rect(area);
        self.surfaces.push(surface.clone());
        return Ok(surface);
    }
}