#include <gfx/util/shader.h>

#include <gfx/core.h>
#include <shaders/brdf_integration_map.frag.h>
#include <shaders/cook_torrance.frag.h>
#include <shaders/cook_torrance.vert.h>
#include <shaders/cubemap_filtering.vert.h>
#include <shaders/debug3d.frag.h>
#include <shaders/debug3d.vert.h>
#include <shaders/immediate_mode.frag.h>
#include <shaders/immediate_mode.vert.h>
#include <shaders/irradiance_map.frag.h>
#include <shaders/prefiltered_environment_map.frag.h>
#include <shaders/quad.vert.h>
#include <shaders/skyquad.frag.h>
#include <shaders/skyquad.vert.h>
#include <shaders/view_normal_mapped_normals.frag.h>
#include <shaders/view_normal_mapped_normals.vert.h>
#include <shaders/view_normals.frag.h>
#include <shaders/view_normals.vert.h>
#include <shaders/view_tangents.frag.h>
#include <shaders/view_tangents.vert.h>
#include <shaders/view_texture.frag.h>
#include <shaders/view_texture.vert.h>

#include <assert.h>
#include <string.h>

static ShaderProgram* make_shader_program(
    GfxCore* gfxcore, const char* vert_source, const char* frag_source,
    const ShaderCompilerDefine* defines, size_t num_defines) {
  assert(gfxcore);
  assert(vert_source);
  assert(frag_source);

  Shader* vert = 0;
  Shader* frag = 0;

  ShaderDesc vertex_shader_desc = {
      .code = vert_source, .type = VertexShader, .num_defines = num_defines};
  ShaderDesc fragment_shader_desc = {
      .code = frag_source, .type = FragmentShader, .num_defines = num_defines};
  if (num_defines > 0) {
    memcpy(
        vertex_shader_desc.defines, defines,
        num_defines * sizeof(ShaderCompilerDefine));
    memcpy(
        fragment_shader_desc.defines, defines,
        num_defines * sizeof(ShaderCompilerDefine));
  }
  vert = gfx_make_shader(gfxcore, &vertex_shader_desc);
  if (!vert) {
    goto cleanup;
  }
  frag = gfx_make_shader(gfxcore, &fragment_shader_desc);
  if (!frag) {
    goto cleanup;
  }

  ShaderProgramDesc shader_program_desc = {
      .vertex_shader = vert, .fragment_shader = frag};
  ShaderProgram* prog = gfx_make_shader_program(gfxcore, &shader_program_desc);
  if (!prog) {
    goto cleanup;
  }
  return prog;

cleanup:
  if (vert) {
    gfx_destroy_shader(gfxcore, &vert);
  }
  if (frag) {
    gfx_destroy_shader(gfxcore, &frag);
  }
  return 0;
}

ShaderProgram* gfx_make_brdf_integration_map_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, quad_vert, brdf_integration_map_frag, 0, 0);
}

ShaderProgram* gfx_make_cook_torrance_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, cook_torrance_vert, cook_torrance_frag, 0, 0);
}

ShaderProgram* gfx_make_cook_torrance_shader_perm(
    GfxCore* gfxcore, const ShaderCompilerDefine* defines, size_t num_defines) {
  return make_shader_program(
      gfxcore, cook_torrance_vert, cook_torrance_frag, defines, num_defines);
}

ShaderProgram* gfx_make_immediate_mode_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, immediate_mode_vert, immediate_mode_frag, 0, 0);
}

ShaderProgram* gfx_make_irradiance_map_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, cubemap_filtering_vert, irradiance_map_frag, 0, 0);
}

ShaderProgram* gfx_make_prefiltered_environment_map_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, cubemap_filtering_vert, prefiltered_environment_map_frag, 0, 0);
}

ShaderProgram* gfx_make_debug3d_shader(GfxCore* gfxcore) {
  return make_shader_program(gfxcore, debug3d_vert, debug3d_frag, 0, 0);
}

ShaderProgram* gfx_make_skyquad_shader(GfxCore* gfxcore) {
  return make_shader_program(gfxcore, skyquad_vert, skyquad_frag, 0, 0);
}

ShaderProgram* gfx_make_view_normal_mapped_normals_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, view_normal_mapped_normals_vert, view_normal_mapped_normals_frag,
      0, 0);
}

ShaderProgram* gfx_make_view_normals_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, view_normals_vert, view_normals_frag, 0, 0);
}

ShaderProgram* gfx_make_view_tangents_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, view_tangents_vert, view_tangents_frag, 0, 0);
}

ShaderProgram* gfx_make_view_texture_shader(GfxCore* gfxcore) {
  return make_shader_program(
      gfxcore, view_texture_vert, view_texture_frag, 0, 0);
}