use std::collections::HashMap;
use std::ffi::c_void;
use std::process::abort;

use cstr::cstr;
use ecs::component::local::Local;
use ecs::sole::Single;
use ecs::system::{Into as _, System};
use ecs::{Component, Query};
use tracing::warn;

use crate::camera::Camera;
use crate::color::Color;
use crate::data_types::dimens::Dimens;
use crate::event::{Present as PresentEvent, Start as StartEvent};
use crate::lighting::LightSource;
use crate::material::Material;
use crate::matrix::Matrix;
use crate::mesh::Mesh;
use crate::opengl::buffer::{
    ArrayKind as ArrayBufferKind,
    Buffer,
    ElementArrayKind as ElementArrayBufferKind,
    Usage as BufferUsage,
};
use crate::opengl::currently_bound::CurrentlyBound;
#[cfg(feature = "debug")]
use crate::opengl::debug::{MessageSeverity, MessageSource, MessageType};
use crate::opengl::shader::{
    Error as GlShaderError,
    Program as GlShaderProgram,
    Shader as GlShader,
};
use crate::opengl::texture::{
    set_active_texture_unit,
    Texture as GlTexture,
    TextureUnit,
};
use crate::opengl::vertex_array::{PrimitiveKind, VertexArray};
use crate::opengl::{clear_buffers, enable, BufferClearMask, Capability};
use crate::projection::new_perspective;
use crate::shader::Program as ShaderProgram;
use crate::texture::{Id as TextureId, Map as TextureMap, Texture};
use crate::transform::Transform;
use crate::vector::{Vec2, Vec3};
use crate::vertex::Vertex;
use crate::window::Window;

#[derive(Debug, Default)]
pub struct Extension {}

impl ecs::extension::Extension for Extension
{
    fn collect(self, mut collector: ecs::extension::Collector<'_>)
    {
        collector.add_system(StartEvent, initialize);

        collector.add_system(
            PresentEvent,
            render.into_system().initialize((GlObjects::default(),)),
        );
    }
}

fn initialize(window: Single<Window>)
{
    window
        .make_context_current()
        .expect("Failed to make window context current");

    gl::load_with(|symbol| match window.get_proc_address(symbol) {
        Ok(addr) => addr as *const c_void,
        Err(err) => {
            println!(
                "FATAL ERROR: Failed to get adress of OpenGL function {symbol}: {err}",
            );

            abort();
        }
    });

    #[cfg(feature = "debug")]
    initialize_debug();

    let window_size = window.size().expect("Failed to get window size");

    set_viewport(&Vec2 { x: 0, y: 0 }, window_size);

    window.set_framebuffer_size_callback(|new_window_size| {
        set_viewport(&Vec2::ZERO, new_window_size);
    });

    enable(Capability::DepthTest);
}

fn render(
    query: Query<(Mesh, TextureMap, ShaderProgram, Material, Transform)>,
    light_source_query: Query<(LightSource,)>,
    camera_query: Query<(Camera,)>,
    window: Single<Window>,
    mut gl_objects: Local<GlObjects>,
)
{
    let Some(camera) = camera_query.iter().find_map(|(camera,)| {
        if !camera.current {
            return None;
        }

        Some(camera)
    }) else {
        warn!("No current camera. Nothing will be rendered");
        return;
    };

    let light_source = light_source_query
        .iter()
        .next()
        .map(|(light_source,)| light_source);

    let GlObjects {
        shader_programs: gl_shader_programs,
        textures: gl_textures,
    } = &mut *gl_objects;

    clear_buffers(BufferClearMask::COLOR | BufferClearMask::DEPTH);

    for (mesh, texture_map, shader_program, material, transform) in &query {
        let shader_program = gl_shader_programs
            .entry(shader_program.u64_hash())
            .or_insert_with(|| create_gl_shader_program(&shader_program).unwrap());

        shader_program.activate(|shader_program_curr_bound| {
            apply_transformation_matrices(
                &transform,
                shader_program,
                &camera,
                window.size().expect("Failed to get window size"),
                &shader_program_curr_bound,
            );

            apply_light(
                &material,
                shader_program,
                light_source.as_deref(),
                &camera,
                &shader_program_curr_bound,
            );

            for (texture_id, texture) in &texture_map.inner {
                let gl_texture = gl_textures
                    .entry(*texture_id)
                    .or_insert_with(|| create_gl_texture(texture));

                let texture_unit = TextureUnit::from_texture_id(*texture_id)
                    .unwrap_or_else(|| {
                        panic!("Texture id {texture_id} is a invalid texture unit");
                    });

                set_active_texture_unit(texture_unit);

                gl_texture.bind(|_| {});
            }

            draw_mesh(&mesh);
        });
    }
}

#[derive(Debug, Default, Component)]
struct GlObjects
{
    shader_programs: HashMap<u64, GlShaderProgram>,
    textures: HashMap<TextureId, GlTexture>,
}

fn set_viewport(position: &Vec2<u32>, size: Dimens<u32>)
{
    crate::opengl::set_viewport(position, size);
}

#[cfg(feature = "debug")]
fn initialize_debug()
{
    use crate::opengl::debug::{
        enable_debug_output,
        set_debug_message_callback,
        set_debug_message_control,
        MessageIdsAction,
    };

    enable_debug_output();

    set_debug_message_callback(opengl_debug_message_cb);

    set_debug_message_control(None, None, None, &[], MessageIdsAction::Disable);
}

fn draw_mesh(mesh: &Mesh)
{
    // TODO: Creating a new vertex buffer each draw is really dumb and slow this
    // should be rethinked
    let renderable = Renderable::new(mesh.vertices(), mesh.indices());

    renderable.vertex_arr.bind(|vert_arr_curr_bound| {
        if let Some(index_info) = &renderable.index_info {
            VertexArray::draw_elements(
                &vert_arr_curr_bound,
                PrimitiveKind::Triangles,
                0,
                index_info.cnt,
            );
        } else {
            VertexArray::draw_arrays(
                &vert_arr_curr_bound,
                PrimitiveKind::Triangles,
                0,
                3,
            );
        }
    });
}

fn create_gl_texture(texture: &Texture) -> GlTexture
{
    let gl_texture = GlTexture::new();

    gl_texture.bind(|texture_curr_bound| {
        GlTexture::generate(
            &texture_curr_bound,
            texture.dimensions(),
            texture.image().as_bytes(),
            texture.pixel_data_format(),
        );
    });

    gl_texture.apply_properties(texture.properties());

    gl_texture
}

fn create_gl_shader_program(
    shader_program: &ShaderProgram,
) -> Result<GlShaderProgram, GlShaderError>
{
    let gl_shaders = shader_program
        .shaders()
        .iter()
        .map(|shader| {
            let gl_shader = GlShader::new(shader.kind());

            gl_shader.set_source(shader.source())?;
            gl_shader.compile()?;

            Ok(gl_shader)
        })
        .collect::<Result<Vec<_>, _>>()?;

    let gl_shader_program = GlShaderProgram::new();

    for gl_shader in &gl_shaders {
        gl_shader_program.attach(gl_shader);
    }

    gl_shader_program.link()?;

    Ok(gl_shader_program)
}

#[derive(Debug)]
struct Renderable
{
    vertex_arr: VertexArray,

    /// Vertex and index buffer has to live as long as the vertex array
    _vertex_buffer: Buffer<Vertex, ArrayBufferKind>,
    index_info: Option<IndexInfo>,
}

impl Renderable
{
    fn new(vertices: &[Vertex], indices: Option<&[u32]>) -> Self
    {
        let vertex_arr = VertexArray::new();
        let vertex_buffer = Buffer::new();

        let mut index_info = None;

        vertex_arr.bind(|vert_arr_curr_bound| {
            vertex_buffer.bind(|vert_buf_curr_bound| {
                Buffer::store(&vert_buf_curr_bound, vertices, BufferUsage::Static);

                VertexArray::configure_attrs(&vert_arr_curr_bound, &vert_buf_curr_bound);
            });

            if let Some(indices) = indices {
                let new_index_buffer = Buffer::new();

                new_index_buffer.bind(|index_buf_curr_bound| {
                    Buffer::store(&index_buf_curr_bound, indices, BufferUsage::Static);
                });

                index_info = Some(IndexInfo {
                    _buffer: new_index_buffer,
                    cnt: indices.len().try_into().unwrap(),
                });
            }
        });

        Self {
            vertex_arr,
            _vertex_buffer: vertex_buffer,
            index_info,
        }
    }
}

fn apply_transformation_matrices(
    transform: &Transform,
    gl_shader_program: &GlShaderProgram,
    camera: &Camera,
    window_size: Dimens<u32>,
    shader_program_curr_bound: &CurrentlyBound<GlShaderProgram>,
)
{
    gl_shader_program.set_uniform_matrix_4fv(
        shader_program_curr_bound,
        cstr!("model"),
        &transform.as_matrix(),
    );

    let view = create_view(camera);

    gl_shader_program.set_uniform_matrix_4fv(
        shader_program_curr_bound,
        cstr!("view"),
        &view,
    );

    #[allow(clippy::cast_precision_loss)]
    let projection = new_perspective(
        80.0f32.to_radians(),
        window_size.width as f32 / window_size.height as f32,
        100.0,
        0.1,
    );

    gl_shader_program.set_uniform_matrix_4fv(
        shader_program_curr_bound,
        cstr!("projection"),
        &projection,
    );
}

fn apply_light(
    material: &Material,
    gl_shader_program: &GlShaderProgram,
    light_source: Option<&LightSource>,
    camera: &Camera,
    shader_program_curr_bound: &CurrentlyBound<GlShaderProgram>,
)
{
    gl_shader_program.set_uniform_vec_3fv(
        shader_program_curr_bound,
        cstr!("light.position"),
        &light_source.map_or_else(Vec3::default, |light_source| {
            light_source.position().clone()
        }),
    );

    gl_shader_program.set_uniform_vec_3fv(
        shader_program_curr_bound,
        cstr!("light.ambient"),
        &light_source
            .map_or(Color::WHITE_F32, |light_source| {
                light_source.ambient().clone()
            })
            .into(),
    );

    gl_shader_program.set_uniform_vec_3fv(
        shader_program_curr_bound,
        cstr!("light.diffuse"),
        &light_source
            .map_or(Color::WHITE_F32, |light_source| {
                light_source.diffuse().clone()
            })
            .into(),
    );

    gl_shader_program.set_uniform_vec_3fv(
        shader_program_curr_bound,
        cstr!("light.specular"),
        &light_source
            .map_or(Color::WHITE_F32, |light_source| {
                light_source.specular().clone()
            })
            .into(),
    );

    #[allow(clippy::cast_possible_wrap)]
    gl_shader_program.set_uniform_1i(
        shader_program_curr_bound,
        cstr!("material.ambient"),
        material.ambient_map().into_inner() as i32,
    );

    #[allow(clippy::cast_possible_wrap)]
    gl_shader_program.set_uniform_1i(
        shader_program_curr_bound,
        cstr!("material.diffuse"),
        material.diffuse_map().into_inner() as i32,
    );

    #[allow(clippy::cast_possible_wrap)]
    gl_shader_program.set_uniform_1i(
        shader_program_curr_bound,
        cstr!("material.specular"),
        material.specular_map().into_inner() as i32,
    );

    gl_shader_program.set_uniform_1fv(
        shader_program_curr_bound,
        cstr!("material.shininess"),
        material.shininess(),
    );

    gl_shader_program.set_uniform_vec_3fv(
        shader_program_curr_bound,
        cstr!("view_pos"),
        &camera.position,
    );
}

fn create_view(camera: &Camera) -> Matrix<f32, 4, 4>
{
    let mut view = Matrix::new();

    view.look_at(&camera.position, &camera.target, &camera.global_up);

    view
}

#[cfg(feature = "debug")]
#[tracing::instrument(skip_all)]
fn opengl_debug_message_cb(
    source: MessageSource,
    ty: MessageType,
    id: u32,
    severity: MessageSeverity,
    message: &str,
)
{
    use std::backtrace::{Backtrace, BacktraceStatus};

    use tracing::{event, Level};

    macro_rules! create_event {
        ($level: expr) => {
            event!($level, ?source, ?ty, id, ?severity, message);
        };
    }

    if matches!(severity, MessageSeverity::Notification) {
        return;
    }

    match ty {
        MessageType::Error => {
            create_event!(Level::ERROR);

            let backtrace = Backtrace::capture();

            if matches!(backtrace.status(), BacktraceStatus::Captured) {
                event!(Level::TRACE, "{backtrace}");
            }
        }
        MessageType::Other => {
            create_event!(Level::INFO);
        }
        _ => {
            create_event!(Level::WARN);
        }
    };
}

#[derive(Debug)]
struct IndexInfo
{
    _buffer: Buffer<u32, ElementArrayBufferKind>,
    cnt: u32,
}