//! OpenGL context wrappers, texture cache management, shader compilation,

//! vertex buffer abstractions, and FFI-safe GL type aliases for the C/Python API.

#![allow(unused_variables)]

use alloc::{

    boxed::Box,

    rc::Rc,

    string::{String, ToString},

    vec::Vec,

};

use core::{

    ffi, fmt,

    hash::{Hash, Hasher},

    mem::ManuallyDrop,

    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},

};

use azul_css::{

    props::{

        basic::{ColorF, ColorU},

        style::StyleTransformVec,

    },

    AzString, OptionI32, OptionU32, OptionUsize, StringVec, U8Vec,

};

pub use gl_context_loader::{

    ctypes::*, gl, GLeglImageOES, GLsync, GLvoid, GenericGlContext, GlType as GlContextGlType,

};

pub use crate::glconst::*;

use crate::{

    geom::PhysicalSizeU32,

    hit_test::DocumentId,

    resources::{

        Brush, Epoch, ExternalImageId, ImageDescriptor, ImageDescriptorFlags, RawImage,

        RawImageData, RawImageFormat,

    },

    svg::{TessellatedGPUSvgNode, TessellatedSvgNode},

    window::RendererType,

    OrderedMap,

};

pub type GLuint = u32;

pub type GLint = i32;

pub type GLint64 = i64;

pub type GLuint64 = u64;

pub type GLenum = u32;

pub type GLintptr = isize;

pub type GLboolean = u8;

pub type GLsizeiptr = isize;

pub type GLbitfield = u32;

pub type GLsizei = i32;

pub type GLclampf = f32;

pub type GLfloat = f32;

pub const GL_RESTART_INDEX: u32 = core::u32::MAX;

/// Passing *const c_void is not easily possible when generating APIs,

/// so this wrapper struct is for easier API generation

#[repr(C)]

#[derive(Debug)]

pub struct GlVoidPtrConst {

    pub ptr: *const GLvoid,

    pub run_destructor: bool,

}

impl Clone for GlVoidPtrConst {

}

impl Drop for GlVoidPtrConst {

}

/// Struct returned from the C API

///

/// Because of Python, every object has to be clone-able,

/// so yes there may exist more than one mutable reference

#[repr(C)]

#[derive(Debug)]

pub struct GlVoidPtrMut {

    pub ptr: *mut GLvoid,

}

impl Clone for GlVoidPtrMut {

}

/// FFI-safe wrapper for `&str`.

#[repr(C)]

pub struct Refstr {

    pub ptr: *const u8,

    pub len: usize,

}

impl Clone for Refstr {

}

impl core::fmt::Debug for Refstr {

}

impl Refstr {

}

impl From<&str> for Refstr {

}

/// FFI-safe wrapper for `&[&str]`.

#[repr(C)]

pub struct RefstrVecRef {

    pub ptr: *const Refstr,

    pub len: usize,

}

impl Clone for RefstrVecRef {

}

impl core::fmt::Debug for RefstrVecRef {

}

impl RefstrVecRef {

}

impl From<&[Refstr]> for RefstrVecRef {

}

/// FFI-safe wrapper for `&mut [GLint64]`.

#[repr(C)]

pub struct GLint64VecRefMut {

    pub ptr: *mut i64,

    pub len: usize,

}

impl Clone for GLint64VecRefMut {

}

impl core::fmt::Debug for GLint64VecRefMut {

}

impl From<&mut [GLint64]> for GLint64VecRefMut {

}

impl GLint64VecRefMut {

}

/// FFI-safe wrapper for `&mut [GLfloat]`.

#[repr(C)]

pub struct GLfloatVecRefMut {

    pub ptr: *mut f32,

    pub len: usize,

}

impl Clone for GLfloatVecRefMut {

}

impl core::fmt::Debug for GLfloatVecRefMut {

}

impl From<&mut [GLfloat]> for GLfloatVecRefMut {

}

impl GLfloatVecRefMut {

}

/// FFI-safe wrapper for `&mut [GLint]`.

#[repr(C)]

pub struct GLintVecRefMut {

    pub ptr: *mut i32,

    pub len: usize,

}

impl Clone for GLintVecRefMut {

}

impl core::fmt::Debug for GLintVecRefMut {

}

impl From<&mut [GLint]> for GLintVecRefMut {

}

impl GLintVecRefMut {

}

/// FFI-safe wrapper for `&[GLuint]`.

#[repr(C)]

pub struct GLuintVecRef {

    pub ptr: *const u32,

    pub len: usize,

}

impl Clone for GLuintVecRef {

}

impl core::fmt::Debug for GLuintVecRef {

}

impl From<&[GLuint]> for GLuintVecRef {

}

impl GLuintVecRef {

}

/// FFI-safe wrapper for `&[GLenum]`.

#[repr(C)]

pub struct GLenumVecRef {

    pub ptr: *const u32,

    pub len: usize,

}

impl Clone for GLenumVecRef {

}

impl core::fmt::Debug for GLenumVecRef {

}

impl From<&[GLenum]> for GLenumVecRef {

}

impl GLenumVecRef {

}

/// FFI-safe wrapper for `&[u8]`.

#[repr(C)]

pub struct U8VecRef {

    pub ptr: *const u8,

    pub len: usize,

}

impl Clone for U8VecRef {

}

impl From<&[u8]> for U8VecRef {

}

impl U8VecRef {

}

impl fmt::Debug for U8VecRef {

}

impl PartialOrd for U8VecRef {

}

impl Ord for U8VecRef {

}

impl PartialEq for U8VecRef {

}

impl Eq for U8VecRef {}

impl core::hash::Hash for U8VecRef {

    {

}

/// FFI-safe wrapper for `&[f32]`.

#[repr(C)]

pub struct F32VecRef {

    pub ptr: *const f32,

    pub len: usize,

}

impl Clone for F32VecRef {

}

impl core::fmt::Debug for F32VecRef {

}

impl From<&[f32]> for F32VecRef {

}

impl F32VecRef {

}

/// FFI-safe wrapper for `&[i32]`.

#[repr(C)]

pub struct I32VecRef {

    pub ptr: *const i32,

    pub len: usize,

}

impl Clone for I32VecRef {

}

impl core::fmt::Debug for I32VecRef {

}

impl From<&[i32]> for I32VecRef {

}

impl I32VecRef {

}

/// FFI-safe wrapper for `&mut [GLboolean]` (i.e. `&mut [u8]`).

#[repr(C)]

pub struct GLbooleanVecRefMut {

    pub ptr: *mut u8,

    pub len: usize,

}

impl Clone for GLbooleanVecRefMut {

}

impl core::fmt::Debug for GLbooleanVecRefMut {

}

impl From<&mut [GLboolean]> for GLbooleanVecRefMut {

}

impl GLbooleanVecRefMut {

}

/// FFI-safe wrapper for `&mut [u8]`.

#[repr(C)]

pub struct U8VecRefMut {

    pub ptr: *mut u8,

    pub len: usize,

}

impl Clone for U8VecRefMut {

}

impl core::fmt::Debug for U8VecRefMut {

}

impl From<&mut [u8]> for U8VecRefMut {

}

impl U8VecRefMut {

}

impl_option!(

    U8VecRef,

    OptionU8VecRef,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub struct DebugMessage {

    pub message: AzString,

    pub source: GLenum,

    pub ty: GLenum,

    pub id: GLenum,

    pub severity: GLenum,

}

impl_option!(

    DebugMessage,

    OptionDebugMessage,

    copy = false,

    [Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash]

);

impl_vec!(DebugMessage, DebugMessageVec, DebugMessageVecDestructor, DebugMessageVecDestructorType, DebugMessageVecSlice, OptionDebugMessage);

impl_vec_debug!(DebugMessage, DebugMessageVec);

impl_vec_partialord!(DebugMessage, DebugMessageVec);

impl_vec_ord!(DebugMessage, DebugMessageVec);

impl_vec_clone!(DebugMessage, DebugMessageVec, DebugMessageVecDestructor);

impl_vec_partialeq!(DebugMessage, DebugMessageVec);

impl_vec_eq!(DebugMessage, DebugMessageVec);

impl_vec_hash!(DebugMessage, DebugMessageVec);

impl_vec!(GLint, GLintVec, GLintVecDestructor, GLintVecDestructorType, GLintVecSlice, OptionI32);

impl_vec_debug!(GLint, GLintVec);

impl_vec_partialord!(GLint, GLintVec);

impl_vec_ord!(GLint, GLintVec);

impl_vec_clone!(GLint, GLintVec, GLintVecDestructor);

impl_vec_partialeq!(GLint, GLintVec);

impl_vec_eq!(GLint, GLintVec);

impl_vec_hash!(GLint, GLintVec);

impl_vec!(GLuint, GLuintVec, GLuintVecDestructor, GLuintVecDestructorType, GLuintVecSlice, OptionU32);

impl_vec_debug!(GLuint, GLuintVec);

impl_vec_partialord!(GLuint, GLuintVec);

impl_vec_ord!(GLuint, GLuintVec);

impl_vec_clone!(GLuint, GLuintVec, GLuintVecDestructor);

impl_vec_partialeq!(GLuint, GLuintVec);

impl_vec_eq!(GLuint, GLuintVec);

impl_vec_hash!(GLuint, GLuintVec);

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum GlType {

    Gl,

    Gles,

}

impl From<GlContextGlType> for GlType {

        }

}

// (U8Vec, u32)

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct GetProgramBinaryReturn {

    pub _0: U8Vec,

    pub _1: u32,

}

// (i32, u32, AzString)

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct GetActiveAttribReturn {

    pub _0: i32,

    pub _1: u32,

    pub _2: AzString,

}

// (i32, u32, AzString)

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct GetActiveUniformReturn {

    pub _0: i32,

    pub _1: u32,

    pub _2: AzString,

}

#[repr(C)]

pub struct GLsyncPtr {

    pub ptr: *const c_void, /* *const __GLsync */

    pub run_destructor: bool,

}

impl Clone for GLsyncPtr {

}

impl core::fmt::Debug for GLsyncPtr {

}

impl GLsyncPtr {

}

impl Drop for GLsyncPtr {

}

/// Each pipeline (window) has its own OpenGL textures. GL Textures can technically

/// be shared across pipelines, however this turns out to be very difficult in practice.

pub type GlTextureStorage = OrderedMap<Epoch, OrderedMap<ExternalImageId, Texture>>;

/// Non-cleaned up textures. When a GlTexture is registered, it has to stay active as long

/// as WebRender needs it for drawing. To transparently do this, we store the epoch that the

/// texture was originally created with, and check, **after we have drawn the frame**,

/// if there are any textures that need cleanup.

///

/// Because the Texture2d is wrapped in an Rc, the destructor (which cleans up the OpenGL

/// texture) does not run until we remove the textures

///

/// Note: Because textures could be used after the current draw call (ex. for scrolling),

/// the ACTIVE_GL_TEXTURES are indexed by their epoch. Use `renderer.flush_pipeline_info()`

/// to see which textures are still active and which ones can be safely removed.

///

/// See: https://github.com/servo/webrender/issues/2940

///

/// WARNING: Not thread-safe (however, the Texture itself is thread-unsafe, so it's unlikely to ever

/// be misused)

static mut ACTIVE_GL_TEXTURES: Option<OrderedMap<DocumentId, GlTextureStorage>> = None;

/// Inserts a new texture into the OpenGL texture cache, returns a new image ID

/// for the inserted texture

///

/// This function exists so azul doesn't have to use `lazy_static` as a dependency

    unsafe {

    }

/// Destroys all textures from the given `document_id`

/// where the texture is **older** than the given `epoch`.

    // TODO: Handle overflow of Epochs correctly (low priority)

    unsafe {

        };

        };

        // NOTE: original code used retain() but that

        // doesn't work on no_std

        }

    }

// document_id, epoch, external_image_id

/// Removes a DocumentId from the active epochs

    unsafe {

        };

    }

/// Destroys all textures, usually done before destroying the OpenGL context

// Search all epoch hash maps for the given key

// There does not seem to be a way to get the epoch for the key,

// so we simply have to search all active epochs

//

// NOTE: Invalid textures can be generated on minimize / maximize

// Luckily, webrender simply ignores an invalid texture, so we don't

// need to check whether a window is maximized or minimized - if

// we encounter an invalid ID, webrender simply won't draw anything,

// but at least it won't crash. Usually invalid textures are also 0x0

// pixels large - so it's not like we had anything to draw anyway.

/// For .get_gl_precision_format(), but ABI-safe - returning an array or a tuple is not ABI-safe

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct GlShaderPrecisionFormatReturn {

    pub _0: GLint,

    pub _1: GLint,

    pub _2: GLint,

}

#[repr(C)]

pub struct GlContextPtr {

    /// `ManuallyDrop` so the owned `Box` is freed ONLY when `run_destructor` is

    /// still set (see `Drop`). The codegen FFI wrappers (`AzTexture` etc.) embed

    /// this by value AND have their own `Drop` that `drop_in_place`s the real

    /// type first; Rust's drop glue would then drop this field a SECOND time on

    /// the same bytes. Gating the `Box` free on `run_destructor` (which the first

    /// drop clears in the shared memory) makes that second drop a safe no-op.

    /// Layout is unchanged: `ManuallyDrop<Box<T>>` is a single pointer, identical

    /// to the old `Box<T>` and to the FFI `*mut c_void`.

    pub ptr: ManuallyDrop<Box<Rc<GlContextPtrInner>>>,

    /// Whether to force a hardware or software renderer

    pub renderer_type: RendererType,

    pub run_destructor: bool,

}

impl Clone for GlContextPtr {

}

impl Drop for GlContextPtr {

        // Only free the owned Box if this instance still owns it. The FFI wrapper

        // double-drop (see the struct doc) hits these same bytes a second time

        // with `run_destructor` already cleared by the first drop -> no-op, no

        // double-free.

}

impl GlContextPtr {

    /// Whether this hardware GL context proved usable at construction (the SVG

    /// shaders compiled+linked at some GLSL version). `false` means context

    /// creation succeeded but the driver can't run our shaders -- the caller

    /// should fall back to CPU rendering. Always `false` for a Software context

    /// (which never compiles these shaders); only meaningful on the GPU path.

    /// The GLSL `#version` the driver accepted at construction (e.g. "150" or

    /// "300 es"), discovered by the probe. Empty string if the context is

    /// unusable / software. Exposed in the API so apps can report/branch on it.

    /// Soft-brush shader program for the GPU painting API (0 if unusable).

}

#[repr(C)]

pub struct GlContextPtrInner {

    pub ptr: Rc<GenericGlContext>,

    /// SVG shader program (library-internal use)

    pub svg_shader: GLuint,

    /// SVG multicolor shader program (library-internal use)

    pub svg_multicolor_shader: GLuint,

    /// FXAA shader program (library-internal use)

    pub fxaa_shader: GLuint,

    /// Soft-brush shader program for the GPU painting API (0 if unusable).

    pub brush_shader: GLuint,

    /// The GLSL `#version` directive that compiled (e.g. "150" or "300 es"),

    /// discovered by the probe in `new()`. Empty if the context is unusable.

    pub glsl_version: AzString,

}

impl Drop for GlContextPtrInner {

}

impl_option!(

    GlContextPtr,

    OptionGlContextPtr,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord]

);

impl core::fmt::Debug for GlContextPtr {

}

static SVG_VERTEX_SHADER: &[u8] = b"#version 150

#if __VERSION__ != 100

    #define varying out

    #define attribute in

#endif

uniform vec2 vBboxSize;

uniform mat4 vTransformMatrix;

attribute vec2 vAttrXY;

void main() {

    vec4 vTransposed = vec4(vAttrXY, 1.0, 1.0) * vTransformMatrix;

    vec2 vTransposedInScreen = vTransposed.xy / vBboxSize;

    vec2 vCalcFinal = (vTransposedInScreen * vec2(2.0)) - vec2(1.0);

    gl_Position = vec4(vCalcFinal, 1.0, 1.0);

}";

static SVG_FRAGMENT_SHADER: &[u8] = b"#version 150

precision highp float;

uniform vec4 fDrawColor;

#if __VERSION__ == 100

    #define oFragColor gl_FragColor

#else

    out vec4 oFragColor;

#endif

void main() {

    oFragColor = fDrawColor;

}";

static SVG_MULTICOLOR_VERTEX_SHADER: &[u8] = b"#version 150

#if __VERSION__ != 100

    #define varying out

    #define attribute in

#endif

uniform vec2 vBboxSize;

uniform mat4 vTransformMatrix;

attribute vec3 vAttrXY;

attribute vec4 vColor;

varying vec4 fColor;

void main() {

    vec4 vTransposed = vec4(vAttrXY.xy, 1.0, 1.0) * vTransformMatrix;

    vec2 vTransposedInScreen = vTransposed.xy / vBboxSize;

    vec2 vCalcFinal = (vTransposedInScreen * vec2(2.0)) - vec2(1.0);

    gl_Position = vec4(vCalcFinal, vAttrXY.z, 1.0);

    fColor = vColor;

}";

static SVG_MULTICOLOR_FRAGMENT_SHADER: &[u8] = b"#version 150

precision highp float;

#if __VERSION__ != 100

    #define varying in

#endif

#if __VERSION__ == 100

    #define oFragColor gl_FragColor

#else

    out vec4 oFragColor;

#endif

varying vec4 fColor;

void main() {

    oFragColor = fColor;

}";

// Soft-brush shaders for the GPU painting API. A unit quad [-1,1]^2 (aUv) is

// positioned in NDC (aPos); the fragment computes the same radial falloff as

// the CPU `brush_dab_coverage` (1 - smoothstep(hardness, 1, dist)) so GPU and

// CPU strokes match. Version-agnostic via `__VERSION__` like the SVG shaders.

static BRUSH_VERTEX_SHADER: &[u8] = b"#version 150

#if __VERSION__ != 100

    #define varying out

    #define attribute in

#endif

attribute vec2 aPos;

attribute vec2 aUv;

varying vec2 vUv;

void main() {

    vUv = aUv;

    gl_Position = vec4(aPos, 0.0, 1.0);

}";

static BRUSH_FRAGMENT_SHADER: &[u8] = b"#version 150

precision highp float;

#if __VERSION__ != 100

    #define varying in

#endif

#if __VERSION__ == 100

    #define oFragColor gl_FragColor

#else

    out vec4 oFragColor;

#endif

uniform vec4 uColor;     // rgb + alpha (alpha already folds in flow * color.a)

uniform float uHardness; // 0 = soft .. 1 = hard edge

varying vec2 vUv;

void main() {

    float d = length(vUv);

    if (d > 1.0) { discard; }

    float edge0 = clamp(uHardness, 0.0, 1.0);

    float x = clamp((d - edge0) / max(1.0 - edge0, 1.0e-4), 0.0, 1.0);

    float cov = 1.0 - (x * x * (3.0 - 2.0 * x));

    oFragColor = vec4(uColor.rgb, uColor.a * cov);

}";

/// Checks if a shader compiled successfully. Logs an error under `std`.

/// (Retained for diagnostics; the version probe in `GlContextPtr::new` now does

/// its own status checks.)

#[allow(dead_code)]

        #[cfg(feature = "std")]

/// Checks if a program linked successfully. Logs an error under `std`.

#[allow(dead_code)]

        #[cfg(feature = "std")]

/// Swap the leading `#version ...` line of a bundled shader for `version_line`

/// (which must include the trailing newline). The shader bodies branch on

/// `__VERSION__`, so only the directive needs to change between GL and GLES.

#[cfg(feature = "std")]

/// Try to compile+link a vertex+fragment program at a specific GLSL `#version`.

/// Returns the linked program id, or `None` (after cleanup) on ANY compile or

/// link failure. This is how we PROVE a GL context is actually usable and which

/// `#version` its driver accepts -- creating a context can succeed yet leave it

/// unable to compile our shaders (broken driver, or a GLES context that rejects

/// the desktop `#version 150`).

#[cfg(feature = "std")]

    } else {

    }

/// GLSL `#version` directives to try, in preference order, per context type.

/// The first that compiles+links the SVG shaders is used for every program.

    }

impl GlContextPtr {

        // Only attempt the SVG/FXAA GL shaders for a real GPU. In Software/CPU

        // mode nothing composites through them.

        //

        // PROVE the context is usable rather than trusting context creation: try

        // compiling the SVG program at each candidate `#version` for this context

        // type (desktop GL 1.50/3.30/1.40, or GLES 3.00/1.00) and use the first

        // that compiles+links for ALL programs. A GLES GPU (mobile) rejects the

        // desktop `#version 150`, and a broken driver rejects everything -- in the

        // latter case all program IDs stay 0 and `is_gl_usable()` returns false so

        // the window can fall back to CPU rendering.

        #[cfg(feature = "std")]

                use crate::gl_fxaa::{FXAA_FRAGMENT_SHADER, FXAA_VERTEX_SHADER};

                // Probe via the SVG program; the first version that links wins.

                }

                        // "150" / "300 es": the directive minus "#version " and newline.

                            gl_type

                        );

                    }

                    None => {

                            gl_type

                        );

                    }

                }

            } else {

            };

        // no_std build keeps the original behavior (no probe / no shaders).

        #[cfg(not(feature = "std"))]

        let (svg_program_id, svg_multicolor_program_id, fxaa_program_id, brush_program_id, glsl_version) =

            (0u32, 0u32, 0u32, 0u32, AzString::from_const_str(""));

}

impl GlContextPtr {