#include <string.h>

#include <daw/types.h>
#include <daw/daw.h>
#include <daw/logging.h>
#include <daw/resources.h>
#include <daw/rendering.h>

extern Instance* GLOBAL_PLATFORM;

extern const char* ShaderType_str[];

void* get_asset(Resources* r, u32 idx) {
  switch (r->assets[idx].type) {
  case Asset_shader:
    // The shaders used to compile shader programs are not preserved.
    WARN("We don't store pure shaders");
    break;

  case Asset_shaderprog:
    LOG("Idx: r->get[%d] = %d", idx, r->get[idx]);
    //LOG("Ptr: &r->shader[r->get[idx]] = %z", &r->shader[r->get[idx]]);
    return &r->shader[r->get[idx]];

  case Asset_texture:
    return &r->texture[r->get[idx]];

  case Asset_error:
  case Asset_audio:
  case Asset_font:
  default:
    ERROR("Asset type Not implemented");
    break;
  }
  return NULL;
}

i32 resources_load(Resources *resources) {
  resources->get = calloc(resources->assets_len, sizeof(usize));
  usize audio_len = 0;
  usize font_len = 0;
  usize shader_len = 0;
  usize shaderprog_len = 0;
  usize texture_len = 0;

  usize i = 0;

  // Count each type of resource so we can allocate appropriate sizes.
  for (i = 0; i < resources->assets_len; i++) {
    usize idx = 0;

    switch (resources->assets[i].type) {
      case Asset_audio:      idx = audio_len++;      WARN("Audio resource type not implemented!"); break;
      case Asset_font:       idx = font_len++;       WARN("Font resource type not implemented!"); break;
      case Asset_shader:     idx = shader_len++;     break;
      case Asset_shaderprog: idx = shaderprog_len++; break;
      case Asset_texture:    idx = texture_len++;    break;

      case Asset_error: break;
      default:
        ERROR("Unknown resource type!");
        exit(EXIT_FAILURE);
        break;
    }

    // Update index translation table.
    resources->get[i] = idx;
  }

  //resources->audio = calloc(audio_len, sizeof());
  //resources->font = calloc(font_len, sizeof());
  resources->shader = calloc(shaderprog_len, sizeof(Shader));
  resources->texture = calloc(texture_len, sizeof(Texture));

  Shader* imm_shader = calloc(shader_len, sizeof(Shader));

  audio_len = 0;
  font_len = 0;
  shader_len = 0;
  shaderprog_len = 0;
  texture_len = 0;

  for (i = 0; i < resources->assets_len; i++) {
    switch (resources->assets[i].type) {
    case Asset_audio:
        //resources->audio_len++;
        WARN("Audio resource type not implemented!");
        break;
    case Asset_font:
        //resources->font_len++;
        WARN("Font resource type not implemented!");
        break;
    case Asset_shader: {
        ShaderType t =
            guess_shadertype_from_filename(resources->assets[i].shader.path);
        const Shader s = compile_shader(resources->assets[i].shader.path, t);
        LOG("Compiled %s! (%s)", resources->assets[i].shader.path, ShaderType_str[t]);

        imm_shader[shader_len] = s;
        shader_len++;
    } break;
    case Asset_shaderprog: {
        const usize sz = resources->assets[i].shaderprog.shader_len;
        const u32* shader_ids = resources->assets[i].shaderprog.shader;
        Shader* shaders = calloc(sz, sizeof(Shader));

        for (usize j = 0; j < sz; j++) {
          //DEBUG("shader[%d] = %d\n", j, imm_shader[resources->assets[i].shaderprog.shader[j]].program);
          //shaders[j] = imm_shader[resources->assets[i].shaderprog.shader[j]];
          u32 shader_idx = shader_ids[j];
          //DEBUG("Idx: get[%d] = %d\n", shader_idx, imm_shader[resources->get[shader_idx]].program);
          shaders[j] = imm_shader[resources->get[shader_idx]];
        }

        const Shader s = compose_shader(shaders, sz);

        resources->shader[resources->shader_len] = s;
        resources->shader_len++;
    } break;
    case Asset_texture:
        resources->texture[resources->texture_len] = load_texture(&resources->assets[i].texture);
        resources->texture_len++;
        LOG("Loaded texture \"%s\"!", resources->assets[i].texture.path);
        break;

    case Asset_error:
        break;
    default:
        ERROR("Unknown resource type!");
        exit(EXIT_FAILURE);
        break;
    }

    //resources->get[i] = idx;
  }

  LOG("Total assets: %lu", resources->assets_len);
  LOG(" Shaders: %lu", resources->shader_len);
  LOG(" Textures: %lu", resources->texture_len);

  // Delete the immediate shaders
  for (i = 0; i < shader_len; i++) {
    // glDeleteShader()
  }

  shaders_delete(imm_shader, shader_len);
  free(imm_shader);

  return 0;
}

isize resource_make_global(isize resource_id) {
  ERROR("`resource_make_global` Not implemented");
  return -1;
}