Create a new version of paste:

use crate::shaders::packed_fragment::PACKED_FRAGMENT_SHADER;
use crate::shaders::planar_fragment::PLANAR_FRAGMENT_SHADER;
use crate::shaders::video_vertex::VIDEO_VERTEX_SHADER;
use gl::types::*;
use liborwell_rust::common::pixel_formats::{PixelFormat, GL_SYMBOLS};
use liborwell_rust::common::profiler::Profiler;
use liborwell_rust::common::renderer::{OnConsume, Renderer};
use liborwell_rust::common::stoppable_thread::StoppableThread;
use std::cell::RefCell;
use std::ffi::CStr;
use std::ffi::CString;
use std::fs::File;
use std::io::Read;
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Mutex};
use std::time::Duration;
//use liborwell_rust::common::pixel_format::PixelFormat;
use liborwell_rust::common::decoded_packet::DecodedPacket;
use liborwell_rust::common::ffmpeg_decoded_packet::FfmpegDecodedPacket;
use liborwell_rust::common::ffmpeg_decoded_packet_simulated::FfmpegDecodedPacketSimulated;
use liborwell_rust::common::runnable::Runnable;

use super::renderer;
use super::renderer_error::RendererError;
use super::shader::Shader;
use super::vertex_array_object::VertexArrayObject;
use super::vertex_buffer_object::VertexBufferObject;

const fps_measure_interval: Duration = Duration::from_millis(1000);

enum CurrentProgram {
    PLANAR,
    PACKED,
}

struct GLRenderer {
    fps: Arc<Mutex<Profiler<u32>>>,
    stoppable_thread: StoppableThread,
    pub decoded_frame: Option<DecodedPacket>,
    current_fragment_program: Option<CurrentProgram>,
    planar_program: Option<Shader>,
    packed_program: Option<Shader>,
    current_frame_width: Option<u32>,
    current_frame_height: Option<u32>,
    current_pixel_format: Option<PixelFormat>,
    texture_id: [u32; GLRenderer::TEXTURE_NUMBER as usize],
    texture_location: [i32; GLRenderer::TEXTURE_NUMBER as usize],
    pixel_buffer_objects: [u32; GLRenderer::TEXTURE_NUMBER as usize],
    vertex_buffer_object: Option<VertexBufferObject>,
    vertex_array_object: Option<VertexArrayObject>,
    alpha: i32,
    texture_format: i32,
    vertex_in_location: i32,
    texture_in_location: i32,
}

impl GLRenderer {
    const TEXTURE_NUMBER: u8 = 3;
    const VERTEX_POINTER: u8 = 0;
    const FRAGMENT_POINTER: u8 = 1;
    const VERTICES_TEXTURES: [f32; 20] = [
        -1.0, -1.0, 0.0, 0.0, 1.0, 1.0, -1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0,
        0.0, 1.0, 0.0,
    ];
    pub fn new() -> Self {
        let r = GLRenderer {
            stoppable_thread: StoppableThread::new(),
            decoded_frame: None, //DecodedPacket::FFMPEG(FfmpegDecodedPacket::blank()),
            fps: Arc::new(Mutex::new(Profiler::<u32>::new(fps_measure_interval))),
            current_fragment_program: None,
            planar_program: None,
            packed_program: None,
            current_frame_width: None,
            current_frame_height: None,
            current_pixel_format: None,
            texture_id: [0; GLRenderer::TEXTURE_NUMBER as usize],
            texture_location: [0; GLRenderer::TEXTURE_NUMBER as usize],
            pixel_buffer_objects: [0; GLRenderer::TEXTURE_NUMBER as usize],
            vertex_buffer_object: None,
            vertex_array_object: None,
            alpha: 0,
            texture_format: 0,
            vertex_in_location: 0,
            texture_in_location: 0,
        };
        r
    }

    //TODO: separate in 2 cases: u32 and i32, there are constants that could have those types
    pub fn translate_gl(s: &GL_SYMBOLS) -> i32 {
        match s {
            GL_SYMBOLS::GL__RED => gl::RED as i32,
            GL_SYMBOLS::GL__UNSIGNED_BYTE => gl::UNSIGNED_BYTE as i32,
            _ => panic!("unsupported gl symbol format"),
        }
    }

    pub fn init_vertex_stuff(&mut self) {
        self.planar_program = Some(Shader::new());
        self.planar_program
            .as_mut()
            .unwrap()
            .compile(VIDEO_VERTEX_SHADER, PLANAR_FRAGMENT_SHADER)
            .unwrap();
        /*
        self.packed_program = Some(Shader::new());
        self.packed_program
            .as_mut()
            .unwrap()
            .compile(VIDEO_VERTEX_SHADER, PACKED_FRAGMENT_SHADER)
            .unwrap();
        */
    }

    pub fn dimension_info(
        frame: &DecodedPacket,
    ) -> ([i32; 3], [i32; 3], [usize; 3], [usize; 3], [isize; 3]) {
        let ffmpeg_decoded_packet = match frame {
            //DecodedPacket::FFMPEG(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            DecodedPacket::FFMPEG_SIMULATED(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            _ => panic!("packet not supported yet"),
        };
        //Width of each plane Y,U,V or R,G,B
        let mut width: [i32; 3] = [0; 3];
        //Height of each plane
        let mut height: [i32; 3] = [0; 3];
        //Stride of each plane (explained below)
        let mut linesize: [usize; 3] = [0; 3];
        //Planesize of each plane (explained below)
        let mut plane_size: [usize; 3] = [0; 3];
        //Texture size of each OpenGL texture
        let mut texture_size: [isize; 3] = [0; 3];
        /*
            Our Frame called `frame` has a PixelFormat (example: AV_PIX_FMT_YUV420P).
            We're gonna get, in the list of PixelFormats, for parameters for this format.
            The parameters are things like the ratio of U and V components of the YUV
            component, in the case of an YUV frame, or the details about RGB in the
            case of an RGB decodedFrame->
        */
        //let pixel_format = PixelFormat::YUV420P;
        let pixel_format_translator =
            Some(liborwell_rust::common::pixel_formats_impl::pixel_format_yuv420p);
        for i in 0..3 {
            let width_ratio = &pixel_format_translator.as_ref().unwrap().yuv_widths[i];
            let height_ratio = &pixel_format_translator.as_ref().unwrap().yuv_heights[i];
            /*
                linesize[i] is the stride (https://docs.microsoft.com/en-us/windows/win32/medfound/image-stride)
                for each plane.
                Basically, the stride must be greater or equal to the width of the plane,
                and is there for performance purposes.
                We need to render to a texture. Each plane has a planeSize[i],
                which is basically linesize[i]*height[i]. We need to take linesize in consideration
                when copying to the texture, which is, of course, of size width[i]*height[i].
                So, basically, we need to copy the plane to the texture ignoring the padding bytes
                that come after the stride.
            */
            //TODO: can linesize be <0?
            linesize[i] = ffmpeg_decoded_packet.get_line_size(i);
            width[i] = (ffmpeg_decoded_packet.get_width() * width_ratio.numerator
                / width_ratio.denominator) as i32;
            height[i] = (ffmpeg_decoded_packet.get_height() * height_ratio.numerator
                / height_ratio.denominator) as i32;
            plane_size[i] = linesize[i] * (height[i] as usize);
            texture_size[i] = (width[i] * height[i]) as isize;
            /*
                Now that we setted width, height, linesize and planarSize, our renderer can
                render the image by doing the correct copy taking the stride into account.
            */
        }
        (width, height, linesize, plane_size, texture_size)
    }

    pub fn parse_frame(&mut self, frame: &DecodedPacket) {
        let (width, height, linesize, plane_size, texture_size) =
            GLRenderer::dimension_info(&frame);
        let ffmpeg_decoded_packet = match frame {
            //DecodedPacket::FFMPEG(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            DecodedPacket::FFMPEG_SIMULATED(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            _ => panic!("packet not supported yet"),
        };
        let (frame_width, frame_height) = (
            ffmpeg_decoded_packet.get_width(),
            ffmpeg_decoded_packet.get_height(),
        );
        let pixel_format = Some(PixelFormat::YUV420P);
        let pixel_format_translator =
            Some(liborwell_rust::common::pixel_formats_impl::pixel_format_yuv420p);
        /*
            If any of these change: current_frame_width, current_frame_height, current_pixel_format,
            we obviously need to recreate all textures
        */
        if self.current_frame_width != Some(frame_width)
            || self.current_frame_height != Some(frame_height)
            || self.current_pixel_format != pixel_format
        {
            let current_fragment_program: Option<&Shader>;
            if pixel_format_translator.as_ref().unwrap().is_planar {
                self.planar_program.as_ref().unwrap().activate();
                self.current_fragment_program = Some(CurrentProgram::PLANAR);
                current_fragment_program = self.planar_program.as_ref();
            } else {
                self.packed_program.as_ref().unwrap().activate();
                self.current_fragment_program = Some(CurrentProgram::PACKED);
                current_fragment_program = self.packed_program.as_ref();
            }
            println!(
                "current_fragment_program: {}",
                current_fragment_program.as_ref().unwrap().program()
            );
            unsafe {
                self.vertex_in_location = gl::GetAttribLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("aPos").unwrap().as_ptr(),
                );
                println!("vertex_in_location: {}", self.vertex_in_location);
                self.texture_in_location = gl::GetAttribLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("aTexCoord").unwrap().as_ptr(),
                );
                println!("texture_in_location: {}", self.texture_in_location);
            }

            self.vertex_array_object = Some(VertexArrayObject::new());
            self.vertex_buffer_object = Some(VertexBufferObject::new());

            println!(
                "frame has dimensions w: {}, h: {}
                Gonna create textures:
                Y: {}x{}
                U: {}x{}
                V: {}x{}",
                frame_width,
                frame_height,
                width[0],
                height[0],
                width[1],
                height[1],
                width[2],
                height[2]
            );
            unsafe {
                //gl::BindBuffer(gl::ARRAY_BUFFER, self.vertex_buffer_object.as_ref().unwrap().inner_value().unwrap());
                self.vertex_array_object
                    .as_ref()
                    .unwrap()
                    .activate()
                    .unwrap();
                self.vertex_buffer_object
                    .as_ref()
                    .unwrap()
                    .activate()
                    .unwrap();
                //println!("did bind, vertex_in_location: {}, texture_in_location: {}", self.vertex_in_location, self.texture_in_location);
                gl::BufferData(
                    gl::ARRAY_BUFFER,
                    std::mem::size_of_val(&GLRenderer::VERTICES_TEXTURES) as isize,
                    GLRenderer::VERTICES_TEXTURES.as_ptr() as *const libc::c_void,
                    gl::STATIC_DRAW,
                );

                gl::VertexAttribPointer(
                    self.vertex_in_location as u32,
                    3,
                    gl::FLOAT,
                    gl::FALSE,
                    (5 * ::std::mem::size_of::<f32>()) as i32,
                    0 as *const libc::c_void,
                );
                gl::EnableVertexAttribArray(self.vertex_in_location as u32);

                gl::VertexAttribPointer(
                    self.texture_in_location as u32,
                    2,
                    gl::FLOAT,
                    gl::FALSE,
                    (5 * ::std::mem::size_of::<f32>()) as i32,
                    3 as *const libc::c_void,
                );
                gl::EnableVertexAttribArray(self.texture_in_location as u32);

                self.texture_location[0] = gl::GetUniformLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("tex_y").unwrap().as_ptr(),
                );
                self.texture_location[1] = gl::GetUniformLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("tex_u").unwrap().as_ptr(),
                );
                self.texture_location[2] = gl::GetUniformLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("tex_v").unwrap().as_ptr(),
                );

                println!("tex_y: {}", self.texture_location[0]);
                println!("tex_u: {}", self.texture_location[1]);
                println!("tex_v: {}", self.texture_location[2]);

                //alpha = program->uniformLocation("alpha");
                self.alpha = gl::GetUniformLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("alpha").unwrap().as_ptr(),
                );
                println!("alpha: {}", self.alpha);

                gl::Uniform1f(self.alpha, 1.0);
                self.texture_format = gl::GetUniformLocation(
                    current_fragment_program.as_ref().unwrap().program(),
                    CString::new("tex_format").unwrap().as_ptr(),
                );
                println!("tex_format: {}", self.texture_format);
            }

            //TODO: delete these textures
            unsafe {
                gl::GenTextures(
                    GLRenderer::TEXTURE_NUMBER as i32,
                    self.texture_id.as_mut_ptr(),
                );
                gl::GenBuffers(3, self.pixel_buffer_objects.as_mut_ptr());
            }
            for i in 0..GLRenderer::TEXTURE_NUMBER {
                println!("texture_id[i]= {}", self.texture_id[i as usize]);
                unsafe {
                    gl::BindTexture(gl::TEXTURE_2D, self.texture_id[i as usize]);
                    //gl::BindTexture(gl::TEXTURE_2D, self.texture_id[i as usize]);
                    //We need to call glBufferData at least once, so then we can use glBufferSubData
                    gl::BindBuffer(
                        gl::PIXEL_UNPACK_BUFFER,
                        self.pixel_buffer_objects[i as usize],
                    );
                    gl::BufferData(
                        gl::PIXEL_UNPACK_BUFFER as GLenum,
                        (texture_size[i as usize] * std::mem::size_of::<u8>() as isize)as gl::types::GLsizeiptr,
                        //std::mem::transmute(ffmpeg_decoded_packet.data(i.into())),//.as_ptr() as *mut libc::c_void,
                        std::ptr::null(),
                        gl::STREAM_DRAW as GLenum,
                    );
                    gl::TexImage2D(
                        gl::TEXTURE_2D,
                        0,
                        GLRenderer::translate_gl(
                            &pixel_format_translator
                                .as_ref()
                                .unwrap()
                                .yuv_internal_formats[i as usize],
                        ),
                        width[i as usize],
                        height[i as usize],
                        0,
                        GLRenderer::translate_gl(
                            &pixel_format_translator.as_ref().unwrap().yuv_gl_format[i as usize],
                        ) as GLenum,
                        GLRenderer::translate_gl(
                            &pixel_format_translator.as_ref().unwrap().data_type,
                        ) as GLenum,
                        std::ptr::null(),
                    );
                    gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
                    gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as GLint);
                    gl::TexParameteri(
                        gl::TEXTURE_2D,
                        gl::TEXTURE_WRAP_S,
                        gl::CLAMP_TO_EDGE as GLint,
                    );
                    gl::TexParameteri(
                        gl::TEXTURE_2D,
                        gl::TEXTURE_WRAP_T,
                        gl::CLAMP_TO_EDGE as GLint,
                    );
                    gl::TexParameteri(
                        gl::TEXTURE_2D,
                        gl::TEXTURE_WRAP_R,
                        gl::CLAMP_TO_EDGE as GLint,
                    );
                }
            }
        }
    }

    pub fn draw(&self, frame: &DecodedPacket) {
        let (width, height, linesize, plane_size, texture_size) =
            GLRenderer::dimension_info(&frame);
        let pixel_format_translator =
            Some(liborwell_rust::common::pixel_formats_impl::pixel_format_yuv420p);
        let ffmpeg_decoded_packet = match frame {
            //DecodedPacket::FFMPEG(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            DecodedPacket::FFMPEG_SIMULATED(ffmpeg_decoded_packet) => ffmpeg_decoded_packet,
            _ => panic!("packet not supported yet"),
        };
        unsafe {
            gl::ClearColor(0.0f32, 0.0f32, 0.0f32, 1.0f32);
            gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
        }

        let current_fragment_program: Option<&Shader>;
        match self.current_fragment_program.as_ref().unwrap() {
            CurrentProgram::PLANAR => current_fragment_program = self.planar_program.as_ref(),
            CurrentProgram::PACKED => current_fragment_program = self.packed_program.as_ref(),
        }
        current_fragment_program.as_ref().unwrap().activate();
        self.vertex_array_object
            .as_ref()
            .unwrap()
            .activate()
            .unwrap();
        //To be done
        for i in 0..1 {
            for j in 0..GLRenderer::TEXTURE_NUMBER {
                //m_pbo[i][j] = QOpenGLBuffer(QOpenGLBuffer::PixelUnpackBuffer);
                //m_pbo[i][j].setUsagePattern(QOpenGLBuffer::StreamDraw);
                //m_pbo[i][j].create();
            }
        }
        for j in 0..GLRenderer::TEXTURE_NUMBER {
            unsafe {
                gl::ActiveTexture(gl::TEXTURE0 + (j as u32));
                gl::BindTexture(gl::TEXTURE_2D, self.texture_id[j as usize]);
                gl::BindBuffer(
                    gl::PIXEL_UNPACK_BUFFER,
                    self.pixel_buffer_objects[j as usize],
                );
            }

            /*
                We're gonna write to our Pixel Buffer Object line by line ignoring the stride.
                There are height[j] lines for the current plane j, and linesize[j] is the stride
                for plane j.
            */
            unsafe {
                gl::BufferSubData(
                    gl::PIXEL_UNPACK_BUFFER as GLenum,
                    0,
                    (width[j as usize] * std::mem::size_of::<u8>() as i32)as gl::types::GLsizeiptr,
                    ffmpeg_decoded_packet.data(j as usize).as_ptr() 
                        as *const libc::c_void,
                );
                //println!("width[j]: {}", width[j as usize]);
            }
            /*
            for i in 0..(height[j as usize] - 1) {
                let offset = (i * (linesize[j as usize] as i32)) as isize;
                let plane_pointer = ffmpeg_decoded_packet.data(j.into()).as_ptr();
                unsafe {
                    gl::BufferSubData(
                        gl::PIXEL_UNPACK_BUFFER as GLenum,
                        offset,
                        width[j as usize] as usize as gl::types::GLsizeiptr,
                        plane_pointer.offset(offset) as *const u8 as *const libc::c_void,
                    );
                }
            }
            */
            unsafe {
                gl::TexSubImage2D(
                    gl::TEXTURE_2D,
                    0,
                    0,
                    0,
                    width[j as usize],
                    height[j as usize],
                    GLRenderer::translate_gl(
                        &pixel_format_translator.as_ref().unwrap().yuv_gl_format[j as usize],
                    ) as GLenum,
                    GLRenderer::translate_gl(&pixel_format_translator.as_ref().unwrap().data_type)
                        as GLenum,
                    std::ptr::null(), //ffmpeg_decoded_packet.data(j as usize).as_ptr() as *const u8 as *const libc::c_void//
                );
                gl::Uniform1i(self.texture_location[j as usize], j as GLint);
            }
        }
        unsafe {
            gl::Uniform1i(self.texture_format, 0);

            //gl::BindVertexArray(self.vertex_array_object);
            self.vertex_array_object
                .as_ref()
                .unwrap()
                .activate()
                .unwrap();
            gl::DrawArrays(gl::TRIANGLE_STRIP, 0, 4);
        }
    }
}

pub struct SmartVideoRenderer {
    on_consume: OnConsume,
    stoppable_thread: StoppableThread,
    scene: RefCell<GLRenderer>,
}

impl Renderer for SmartVideoRenderer {
    fn set_on_consume(&mut self, f: OnConsume) {
        self.on_consume = f;
    }
}

impl SmartVideoRenderer {
    pub fn new(on_consume: OnConsume) -> Self {
        SmartVideoRenderer {
            on_consume: on_consume,
            stoppable_thread: StoppableThread::new(),
            scene: RefCell::new(GLRenderer::new()),
        }
    }
}

impl Runnable for SmartVideoRenderer {
    fn run(&mut self) {
        let width = 1280;
        let height = 720;
        let mut f = File::open("/home/dev/orwell/lab/orwell_gtk/assets/vaporwave.yuv")
            .expect("Unable to open file");
        let on_consume = self.on_consume.clone();
        let mut decoded_packet =
            DecodedPacket::FFMPEG_SIMULATED(FfmpegDecodedPacketSimulated::new(width, height));
        //let decoded_packet = FfmpegDecodedPacketSimulated::new(width,height);
        let ffmpeg_decoded_packet = match &mut decoded_packet {
            DecodedPacket::FFMPEG_SIMULATED(f) => f,
            _ => panic!("packet not supported"),
        };
        f.read_exact(ffmpeg_decoded_packet.y.as_mut_slice())
            .unwrap();
        f.read_exact(ffmpeg_decoded_packet.u.as_mut_slice())
            .unwrap();
        f.read_exact(ffmpeg_decoded_packet.v.as_mut_slice())
            .unwrap();
    }
}

impl renderer::Renderer for SmartVideoRenderer {
    fn initialize(&self) -> Result<(), RendererError> {
        let renderer = unsafe {
            let p = gl::GetString(gl::RENDERER);
            CStr::from_ptr(p as *const i8)
        };
        println!("Renderer: {}", renderer.to_string_lossy());

        let version = unsafe {
            let p = gl::GetString(gl::VERSION);
            CStr::from_ptr(p as *const i8)
        };
        println!("OpenGL version supported: {}", version.to_string_lossy());
        Ok(())
    }

    fn finalize(&self) {
        //self.scene.replace(SmartVideoRenderer::new());
    }

    fn render(&self) {
        println!("render called");
        //self.scene.borrow_mut().draw();
        let width = 1280;
        let height = 720;
        let mut f = File::open("/home/dev/orwell/lab/orwell_gtk/assets/vaporwave.yuv")
            .expect("Unable to open file");

        let mut ffmpeg_decoded_packet = FfmpegDecodedPacketSimulated::new(width, height);
        
        f.read_exact(ffmpeg_decoded_packet.y.as_mut_slice())
            .unwrap();
        f.read_exact(ffmpeg_decoded_packet.u.as_mut_slice())
            .unwrap();
        f.read_exact(ffmpeg_decoded_packet.v.as_mut_slice())
            .unwrap();
        
        let decoded_packet = DecodedPacket::FFMPEG_SIMULATED(ffmpeg_decoded_packet);
        self.scene.borrow_mut().init_vertex_stuff();
        self.scene.borrow_mut().parse_frame(&decoded_packet);
        self.scene.borrow_mut().draw(&decoded_packet);
        //Ok(());
    }
}