use crate::error::Result;
use crate::framebuffer::GLImage;
use crate::gl::FramebufferInterface;
use crate::texture::Texture;
use crate::viewport::Viewport;
use gl::types::{GLenum, GLuint};
use librashader_common::{FilterMode, ImageFormat, Size, WrapMode};
use librashader_presets::Scale2D;

#[derive(Debug)]
pub struct Framebuffer {
    pub(crate) image: GLuint,
    pub(crate) handle: GLuint,
    pub(crate) size: Size<u32>,
    pub(crate) format: GLenum,
    pub(crate) max_levels: u32,
    pub(crate) mip_levels: u32,
    pub(crate) is_raw: bool,
}

impl Framebuffer {
    pub(crate) fn new<T: FramebufferInterface>(max_levels: u32) -> Self {
        T::new(max_levels)
    }

    /// Create a framebuffer from an already initialized texture and framebuffer.
    pub fn new_from_raw(
        texture: GLuint,
        fbo: GLuint,
        format: GLenum,
        size: Size<u32>,
        miplevels: u32,
    ) -> Framebuffer {
        Framebuffer {
            image: texture,
            size,
            format,
            max_levels: miplevels,
            mip_levels: miplevels,
            handle: fbo,
            is_raw: true,
        }
    }

    pub(crate) fn clear<T: FramebufferInterface, const REBIND: bool>(&self) {
        T::clear::<REBIND>(self)
    }

    pub(crate) fn scale<T: FramebufferInterface>(
        &mut self,
        scaling: Scale2D,
        format: ImageFormat,
        viewport: &Viewport,
        original: &Texture,
        source: &Texture,
        mipmap: bool,
    ) -> Result<Size<u32>> {
        T::scale(self, scaling, format, viewport, original, source, mipmap)
    }

    pub(crate) fn copy_from<T: FramebufferInterface>(&mut self, image: &GLImage) -> Result<()> {
        T::copy_from(self, image)
    }

    pub(crate) fn as_texture(&self, filter: FilterMode, wrap_mode: WrapMode) -> Texture {
        Texture {
            image: GLImage {
                handle: self.image,
                format: self.format,
                size: self.size,
                padded_size: Default::default(),
            },
            filter,
            mip_filter: filter,
            wrap_mode,
        }
    }
}

impl Drop for Framebuffer {
    fn drop(&mut self) {
        if self.is_raw {
            return;
        }

        unsafe {
            if self.handle != 0 {
                gl::DeleteFramebuffers(1, &self.handle);
            }
            if self.image != 0 {
                gl::DeleteTextures(1, &self.image);
            }
        }
    }
}