use integral_geometry::{Rect, Size};

use std::{ffi, ffi::CString, mem, num::NonZeroU32, ptr, slice};

#[derive(Default)]

pub struct PipelineState {

    blending: bool,

}

impl PipelineState {

    pub fn new() -> Self {

        Self::default()

    }

    pub fn with_blend(mut self) -> Self {

        unsafe {

            gl::Enable(gl::BLEND);

            gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);

        }

        self.blending = true;

        self

    }

}

impl Drop for PipelineState {

    fn drop(&mut self) {

        if self.blending {

            unsafe { gl::Disable(gl::BLEND) }

        }

    }

}

#[derive(Debug)]

pub struct Texture2D {

    handle: Option<NonZeroU32>,

    size: Size,

}

impl Drop for Texture2D {

    fn drop(&mut self) {

        if let Some(handle) = self.handle {

            unsafe {

                gl::DeleteTextures(1, &handle.get());

            }

        }

    }

}

fn new_texture() -> Option<NonZeroU32> {

    let mut handle = 0;

    unsafe {

        gl::GenTextures(1, &mut handle);

    }

    NonZeroU32::new(handle)

}

fn tex_params(filter: TextureFilter) {

    unsafe {

        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as i32);

        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as i32);

        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, filter as i32);

        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, filter as i32);

    }

}

#[derive(Clone, Copy, Debug)]

pub enum TextureFormat {

    Rgba = gl::RGBA as isize,

}

#[derive(Clone, Copy, Debug)]

pub enum TextureInternalFormat {

    Rgba8 = gl::RGBA as isize,

}

#[derive(Clone, Copy, Debug)]

pub enum TextureDataType {

    UnsignedByte = gl::UNSIGNED_BYTE as isize,

}

#[derive(Clone, Copy, Debug)]

pub enum TextureFilter {

    Nearest = gl::NEAREST as isize,

    Linear = gl::LINEAR as isize,

}

#[inline]

fn get_u32(value: Option<NonZeroU32>) -> u32 {

    value.map_or(0, |v| v.get())

}

fn is_out_of_bounds(data: &[u8], data_stride: Option<NonZeroU32>, texture_size: Size) -> bool {

    let data_stride = get_u32(data_stride);

    data_stride == 0 && texture_size.area() * 4 > data.len() as u32

        || data_stride != 0

            && texture_size.width > data_stride

            && (texture_size.height * data_stride) * 4 > data.len() as u32

}

impl Texture2D {

    pub fn new(size: Size, internal_format: TextureInternalFormat, filter: TextureFilter) -> Self {

        if let Some(handle) = new_texture() {

            unsafe {

                gl::BindTexture(gl::TEXTURE_2D, handle.get());

                gl::TexImage2D(

                    gl::TEXTURE_2D,

                    0,

                    internal_format as i32,

                    size.width as i32,

                    size.height as i32,

                    0,

                    TextureFormat::Rgba as u32,

                    TextureDataType::UnsignedByte as u32,

                    std::ptr::null(),

                )

            }

            tex_params(filter);

            Self {

                handle: Some(handle),

                size,

            }

        } else {

            Self { handle: None, size }

        }

    }

    pub fn with_data(

        data: &[u8],

        data_stride: Option<NonZeroU32>,

        size: Size,

        internal_format: TextureInternalFormat,

        format: TextureFormat,

        data_type: TextureDataType,

        filter: TextureFilter,

    ) -> Self {

        if is_out_of_bounds(data, data_stride, size) {

            return Self { handle: None, size };

        }

        if let Some(handle) = new_texture() {

            unsafe {

                gl::BindTexture(gl::TEXTURE_2D, handle.get());

                gl::PixelStorei(gl::UNPACK_ROW_LENGTH, get_u32(data_stride) as i32);

                gl::TexImage2D(

                    gl::TEXTURE_2D,

                    0,

                    internal_format as i32,

                    size.width as i32,

                    size.height as i32,

                    0,

                    format as u32,

                    data_type as u32,

                    data.as_ptr() as *const _,

                )

            }

            tex_params(filter);

            Self {

                handle: Some(handle),

                size,

            }

        } else {

            Self { handle: None, size }

        }

    }

    pub fn update(

        &self,

        region: Rect,

        data: &[u8],

        data_stride: Option<NonZeroU32>,

        format: TextureFormat,

        data_type: TextureDataType,

    ) {

        if let Some(handle) = self.handle {

            unsafe {

                gl::BindTexture(gl::TEXTURE_2D, handle.get());

                gl::PixelStorei(gl::UNPACK_ROW_LENGTH, get_u32(data_stride) as i32);

                gl::TexSubImage2D(

                    gl::TEXTURE_2D,

                    0,

                    region.left(),

                    region.top(),

                    region.width() as i32,

                    region.height() as i32,

                    format as u32,

                    data_type as u32,

                    data.as_ptr() as *const _,

                );

            }

        }

    }

    pub fn retrieve(&self, data: &mut [u8]) {

        if self.size.area() * 4 > data.len() as u32 {

            return;

        }

        if let Some(handle) = self.handle {

            unsafe {

                gl::BindTexture(gl::TEXTURE_2D, handle.get());

                gl::GetTexImage(

                    gl::TEXTURE_2D,

                    0,

                    TextureFormat::Rgba as u32,

                    TextureDataType::UnsignedByte as u32,

                    data.as_mut_ptr() as *mut _,

                );

            }

        }

    }

}

#[derive(Clone, Copy, Debug)]

#[repr(u32)]

pub enum BufferType {

    Array = gl::ARRAY_BUFFER,

    ElementArray = gl::ELEMENT_ARRAY_BUFFER,

}

#[derive(Clone, Copy, Debug)]

#[repr(u32)]

pub enum BufferUsage {

    DynamicDraw = gl::DYNAMIC_DRAW,

}

#[derive(Debug)]

pub struct Buffer {

    pub handle: Option<NonZeroU32>,

    pub buffer_type: BufferType,

    pub usage: BufferUsage,

}

impl Buffer {

    pub fn empty(buffer_type: BufferType, usage: BufferUsage) -> Buffer {

        let mut buffer = 0;

        unsafe {

            gl::GenBuffers(1, &mut buffer);

        }

        Buffer {

            handle: NonZeroU32::new(buffer),

            buffer_type: buffer_type,

            usage,

        }

    }

    fn with_data(buffer_type: BufferType, usage: BufferUsage, data: &[u8]) -> Buffer {

        let mut buffer = 0;

        unsafe {

            gl::GenBuffers(1, &mut buffer);

            if buffer != 0 {

                gl::BindBuffer(buffer_type as u32, buffer);

                gl::BufferData(

                    buffer_type as u32,

                    data.len() as isize,

                    data.as_ptr() as _,

                    usage as u32,

                );

            }

        }

        Buffer {

            handle: NonZeroU32::new(buffer),

            buffer_type,

            usage,

        }

    }

    pub fn ty(&self) -> BufferType {

        self.buffer_type

    }

    pub fn handle(&self) -> Option<NonZeroU32> {

        self.handle

    }

    pub fn write_typed<T>(&self, data: &[T]) {

        if let Some(handle) = self.handle {

            unsafe {

                gl::BindBuffer(self.buffer_type as u32, handle.get());

                gl::BufferData(

                    self.buffer_type as u32,

                    (data.len() * mem::size_of::<T>()) as isize,

                    data.as_ptr() as *const _,

                    self.usage as u32,

                );

            }

        }

    }

    pub fn write(&self, data: &[u8]) {

        if let Some(handle) = self.handle {

            unsafe {

                gl::BindBuffer(self.buffer_type as u32, handle.get());

                gl::BufferData(

                    self.buffer_type as u32,

                    data.len() as isize,

                    data.as_ptr() as *const _,

                    self.usage as u32,

                );

            }

        }

    }

}

impl Drop for Buffer {

    fn drop(&mut self) {

        if let Some(handle) = self.handle {

            let handle = handle.get();

            unsafe {

                gl::DeleteBuffers(1, &handle);

            }

        }

    }

}

#[derive(Debug)]

pub enum VariableBinding<'a> {

    Attribute(&'a str, u32),

    Uniform(&'a str, u32),

    UniformBlock(&'a str, u32),

    Sampler(&'a str, u32),

}

#[derive(Debug)]

pub struct Shader {

    pub program: u32,

}

impl Drop for Shader {

    fn drop(&mut self) {

        unsafe {

            gl::DeleteProgram(self.program);

        }

    }

}

impl Shader {

    pub fn new<'a>(

        vs: &str,

        ps: Option<&str>,

        bindings: &[VariableBinding<'a>],

    ) -> Result<Self, String> {

        unsafe fn compile_shader(shader_type: u32, shader_code: &str) -> Result<u32, String> {

            let shader = gl::CreateShader(shader_type);

            let len = shader_code.len() as i32;

            let code_strings = shader_code.as_ptr() as *const i8;

            gl::ShaderSource(shader, 1, &code_strings, &len);

            gl::CompileShader(shader);

            let mut success = 0i32;

            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut success as _);

            if success == gl::FALSE as i32 {

                let mut log_size = 0i32;

                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut log_size as _);

                let mut log = vec![0u8; log_size as usize];

                gl::GetShaderInfoLog(shader, log_size, ptr::null_mut(), log.as_mut_ptr() as _);

                gl::DeleteShader(shader);

                Err(String::from_utf8_unchecked(log))

            } else {

                Ok(shader)

            }

        }

        let vs = unsafe { compile_shader(gl::VERTEX_SHADER, vs)? };

        let ps = if let Some(ps) = ps {

            Some(unsafe { compile_shader(gl::FRAGMENT_SHADER, ps)? })

        } else {

            None

        };

        unsafe {

            let program = gl::CreateProgram();

            gl::AttachShader(program, vs);

            if let Some(ps) = ps {

                gl::AttachShader(program, ps);

            }

            for bind in bindings {

                match bind {

                    &VariableBinding::Attribute(ref name, id) => {

                        let c_str = CString::new(name.as_bytes()).unwrap();

                        gl::BindAttribLocation(

                            program,

                            id,

                            c_str.to_bytes_with_nul().as_ptr() as *const _,

                        );

                    }

                    _ => {}

                }

            }

            gl::LinkProgram(program);

            let mut success = 0i32;

            gl::GetProgramiv(program, gl::LINK_STATUS, &mut success);

            if success == gl::FALSE as i32 {

                let mut log_size = 0i32;

                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut log_size as _);

                let mut log = vec![0u8; log_size as usize];

                gl::GetProgramInfoLog(program, log_size, ptr::null_mut(), log.as_mut_ptr() as _);

                gl::DeleteProgram(program);

                return Err(String::from_utf8_unchecked(log));

            }

            gl::UseProgram(program);

            for bind in bindings {

                match bind {

                    VariableBinding::Uniform(name, id) => {

                        let c_str = CString::new(name.as_bytes()).unwrap();

                        let index = gl::GetUniformLocation(

                            program,

                            c_str.to_bytes_with_nul().as_ptr() as *const _,

                        );

                        // TODO: impl for block?

                    }

                    VariableBinding::UniformBlock(name, id) => {

                        let c_str = CString::new(name.as_bytes()).unwrap();

                        let index = gl::GetUniformBlockIndex(

                            program,

                            c_str.to_bytes_with_nul().as_ptr() as *const _,

                        );

                        gl::UniformBlockBinding(program, index, *id);

                    }

                    VariableBinding::Sampler(name, id) => {

                        let c_str = CString::new(name.as_bytes()).unwrap();

                        let index = gl::GetUniformLocation(

                            program,

                            c_str.to_bytes_with_nul().as_ptr() as *const _,

                        );

                        gl::Uniform1i(index, *id as i32);

                    }

                    _ => {}

                }

            }

            Ok(Shader { program })

        }

    }

    pub fn bind(&self) {

        unsafe {

            gl::UseProgram(self.program);

        }

    }

    pub fn set_matrix(&self, name: &str, matrix: *const f32) {

        unsafe {

            let c_str = CString::new(name).unwrap();

            let index = gl::GetUniformLocation(

                self.program,

                c_str.to_bytes_with_nul().as_ptr() as *const _,

            );

            gl::UniformMatrix4fv(index, 1, gl::FALSE, matrix);

        }

    }

    pub fn bind_texture_2d(&self, index: u32, texture: &Texture2D) {

        self.bind();

        if let Some(handle) = texture.handle {

            unsafe {

                gl::ActiveTexture(gl::TEXTURE0 + index);

                gl::BindTexture(gl::TEXTURE_2D, handle.get());

            }

        }

    }

}

pub enum InputFormat {

    Float(u32, bool),

    Integer(u32),

}

pub struct InputElement {

    pub shader_slot: u32,

    pub buffer_slot: u32,

    pub format: InputFormat,

    pub components: u32,

    pub stride: u32,

    pub offset: u32,

}

// TODO:

pub struct InputLayout {

    pub elements: Vec<InputElement>,