#pragma once

#include "shader.h"

#include <functional>

namespace pp::panopainter {

struct LegacyCanvasDrawMergeCheckerboardUniforms {
    glm::mat4 mvp { 1.0f };
    bool colorize = false;
};

struct LegacyCanvasDrawMergeTextureUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
};

struct LegacyCanvasDrawMergeAtlasUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
    glm::vec2 offset {};
    glm::vec2 size { 1.0f };
};

struct LegacyCanvasDrawMergeEquirectUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
};

struct LegacyCanvasDrawMergeTextureMaskUniforms {
    int texture_slot = 0;
    glm::vec2 pattern_offset {};
};

struct LegacyCanvasDrawMergeTextureAlphaUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
    float alpha = 1.0f;
    int highlight = 0;
};

struct LegacyCanvasDrawMergeTextureBlendUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
    int destination_texture_slot = 2;
    bool use_destination_texture = false;
    int blend_mode = 0;
    float alpha = 1.0f;
};

struct LegacyCanvasDrawMergeTextureColorizeUniforms {
    glm::mat4 mvp { 1.0f };
    int texture_slot = 0;
    glm::vec4 color { 1.0f };
};

struct LegacyCanvasDrawMergeShaderExecution {
    std::function<void(kShader)> use_shader;
    std::function<void(kShaderUniform, int)> set_int;
    std::function<void(kShaderUniform, float)> set_float;
    std::function<void(kShaderUniform, const glm::vec2&)> set_vec2;
    std::function<void(kShaderUniform, const glm::vec4&)> set_vec4;
    std::function<void(kShaderUniform, const glm::mat4&)> set_mat4;
};

[[nodiscard]] inline LegacyCanvasDrawMergeShaderExecution legacy_shader_manager_draw_merge_execution() noexcept
{
    return {
        .use_shader = [](kShader shader) { ShaderManager::use(shader); },
        .set_int = [](kShaderUniform uniform, int value) { ShaderManager::u_int(uniform, value); },
        .set_float = [](kShaderUniform uniform, float value) { ShaderManager::u_float(uniform, value); },
        .set_vec2 = [](kShaderUniform uniform, const glm::vec2& value) { ShaderManager::u_vec2(uniform, value); },
        .set_vec4 = [](kShaderUniform uniform, const glm::vec4& value) { ShaderManager::u_vec4(uniform, value); },
        .set_mat4 = [](kShaderUniform uniform, const glm::mat4& value) { ShaderManager::u_mat4(uniform, value); },
    };
}

inline void apply_legacy_canvas_draw_merge_mvp(
    const glm::mat4& mvp,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.set_mat4(kShaderUniform::MVP, mvp);
}

inline void apply_legacy_canvas_draw_merge_mvp(const glm::mat4& mvp)
{
    apply_legacy_canvas_draw_merge_mvp(mvp, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_checkerboard_shader(
    const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::Checkerboard);
    execution.set_int(kShaderUniform::Colorize, uniforms.colorize);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_checkerboard_shader(
    const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_checkerboard_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_texture_shader(
    const LegacyCanvasDrawMergeTextureUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::Texture);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_texture_shader(
    const LegacyCanvasDrawMergeTextureUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_texture_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_atlas_shader(
    const LegacyCanvasDrawMergeAtlasUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::Atlas);
    execution.set_vec2(kShaderUniform::Tof, uniforms.offset);
    execution.set_vec2(kShaderUniform::Tsz, uniforms.size);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_atlas_shader(
    const LegacyCanvasDrawMergeAtlasUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_atlas_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_equirect_shader(
    const LegacyCanvasDrawMergeEquirectUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::Equirect);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
}

inline void setup_legacy_canvas_draw_merge_equirect_shader(
    const LegacyCanvasDrawMergeEquirectUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_equirect_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
    const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::TextureMask);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    execution.set_vec2(kShaderUniform::PatternOffset, uniforms.pattern_offset);
}

inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
    const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_texture_mask_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_texture_alpha_shader(
    const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::TextureAlpha);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    execution.set_float(kShaderUniform::Alpha, uniforms.alpha);
    execution.set_int(kShaderUniform::Highlight, uniforms.highlight);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_texture_alpha_shader(
    const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_texture_alpha_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_texture_blend_shader(
    const LegacyCanvasDrawMergeTextureBlendUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::TextureBlend);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    if (uniforms.use_destination_texture) {
        execution.set_int(kShaderUniform::TexBG, uniforms.destination_texture_slot);
    }
    execution.set_int(kShaderUniform::BlendMode, uniforms.blend_mode);
    execution.set_float(kShaderUniform::Alpha, uniforms.alpha);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_texture_blend_shader(
    const LegacyCanvasDrawMergeTextureBlendUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_texture_blend_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
    const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms,
    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
{
    execution.use_shader(kShader::TextureColorize);
    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
    execution.set_vec4(kShaderUniform::Col, uniforms.color);
    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
}

inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
    const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms)
{
    setup_legacy_canvas_draw_merge_texture_colorize_shader(uniforms, legacy_shader_manager_draw_merge_execution());
}

} // namespace pp::panopainter