use std::io::Cursor;
use std::mem;
use glow::{Buffer, HasContext, PixelUnpackData, Program, Texture, VertexArray};
use image::{DynamicImage, EncodableLayout, ImageReader};
use tracing::{debug, error, warn};
use crate::map::Tileset;

pub struct MapRender {
    vbo: Buffer,
    vao: VertexArray,
    ebo: Buffer,
    shader_program: Program,
    test_texture: Texture,
}

#[allow(unsafe_code)]
impl MapRender {
    pub fn new(gl: &glow::Context) -> Option<Self> {
        use glow::HasContext as _;

        let shader_version = egui_glow::ShaderVersion::get(gl);

        unsafe {
            if !shader_version.is_new_shader_interface() {
                warn!(
                    "Custom 3D painting hasn't been ported to {:?}",
                    shader_version
                );
                return None;
            }

            let vbo = gl.create_buffer().unwrap();
            let ebo = gl.create_buffer().unwrap();
            let vao = gl.create_vertex_array().unwrap();

            let vertex_shader = gl.create_shader(glow::VERTEX_SHADER).unwrap();
            gl.shader_source(vertex_shader, include_str!("vertex.glsl"));
            gl.compile_shader(vertex_shader);
            if !gl.get_shader_compile_status(vertex_shader) {
                // shader compilation failed
                error!("vertex shader compilation failed: {}", gl.get_shader_info_log(vertex_shader));
                return None;
            }

            let fragment_shader = gl.create_shader(glow::FRAGMENT_SHADER).unwrap();
            gl.shader_source(fragment_shader, include_str!("frag.glsl"));
            gl.compile_shader(fragment_shader);
            if !gl.get_shader_compile_status(fragment_shader) {
                // shader compilation failed
                error!("fragment shader compilation failed: {}", gl.get_shader_info_log(fragment_shader));
                return None;
            }

            let shader_program = gl.create_program().unwrap();
            gl.attach_shader(shader_program, vertex_shader);
            gl.attach_shader(shader_program, fragment_shader);
            gl.link_program(shader_program);
            if !gl.get_program_link_status(shader_program) {
                error!("linking shader failed: {}", gl.get_program_info_log(shader_program));
            }

            gl.use_program(Some(shader_program));

            gl.delete_shader(vertex_shader);
            gl.delete_shader(fragment_shader);

            let test_img = ImageReader::new(Cursor::new(include_bytes!("../../0.png"))).with_guessed_format().unwrap().decode().unwrap();
            let test_img_rgb8 = test_img.flipv().into_rgb8();
            let w = test_img_rgb8.width();
            let h = test_img_rgb8.height();
            let raw = test_img_rgb8.into_raw();
            let test_texture = gl.create_texture().unwrap();
            gl.bind_texture(glow::TEXTURE_2D, Some(test_texture));
            gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::REPEAT as i32);
            gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::REPEAT as i32);
            gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
            gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
            gl.tex_image_2d(
                glow::TEXTURE_2D,
                0,
                glow::RGB as i32,
                w as i32,
                h as i32,
                0,
                glow::RGB,
                glow::UNSIGNED_BYTE,
                PixelUnpackData::Slice(Some(&raw)),
            );
            gl.generate_mipmap(glow::TEXTURE_2D);
            gl.uniform_1_i32(
                gl.get_uniform_location(shader_program, "tex").as_ref(),
                0
            );

            Some(Self {
                vbo,
                shader_program,
                vao,
                ebo,
                test_texture,
            })
        }
    }

    pub fn destroy(&self, gl: &glow::Context) {
        use glow::HasContext as _;
        unsafe {
            gl.delete_program(self.shader_program);
            gl.delete_buffer(self.vbo);
            gl.delete_vertex_array(self.vao);
        }
    }

    pub fn paint(&self, gl: &glow::Context, tileset: Tileset, options: ExtraRenderOptions) {
        use glow::HasContext as _;



        let verticies: &[f32] = &[
            // X     Y     Z     S     T
               0.5,  0.5,  0.0,  1.0,  1.0, // top right
               0.5, -0.5,  0.0,  1.0,  0.0, // bottom right
              -0.5, -0.5,  0.0,  0.0,  0.0, // bottom left
              -0.5,  0.5,  0.0,  0.0,  1.0, // top left
        ];
        let indicies: &[u32] = &[
            0, 1, 3,
            1, 2, 3
        ];

        unsafe {
            gl.clear_color(0.5, 0.1, 0.1, 1.0);
            gl.clear(glow::COLOR_BUFFER_BIT);

            gl.bind_vertex_array(Some(self.vao));

            gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo));
            gl.buffer_data_u8_slice(glow::ARRAY_BUFFER, bytemuck::cast_slice(verticies), glow::DYNAMIC_DRAW);

            gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.ebo));
            gl.buffer_data_u8_slice(glow::ELEMENT_ARRAY_BUFFER, bytemuck::cast_slice(indicies), glow::DYNAMIC_DRAW);

            gl.vertex_attrib_pointer_f32(0, 3, glow::FLOAT, false, (5 * mem::size_of::<f32>()) as i32, 0);
            gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, (5 * mem::size_of::<f32>()) as i32, 3 * mem::size_of::<f32>() as i32);

            gl.enable_vertex_attrib_array(0);
            gl.enable_vertex_attrib_array(1);
            gl.use_program(Some(self.shader_program));


            gl.active_texture(glow::TEXTURE0);
            gl.bind_texture(glow::TEXTURE_2D, Some(self.test_texture));

            gl.bind_vertex_array(Some(self.vao));
            gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.ebo));


            gl.draw_elements(glow::TRIANGLES, 6, glow::UNSIGNED_INT, 0);

        }
    }
}

#[derive(Copy, Clone)]
pub struct ExtraRenderOptions {
}