#include "BitmapFont.h"
#include "AssetManager.h"
#include "Renderer.h"
#include "SDL_render.h"
#include "aliases.h"
#include "reusable_ids.h"
#include <stdlib.h>
#include <string.h>

struct bitmap_font {
  AssetID font_atlas;
  u64 width;
  u64 height;
  u64 tile_width;
  u64 tile_height;
  u64 rows;
  u64 cols;
};

RenderRect get_character_sprite(BitmapFont *font, u64 index);

BitmapFont *create_bitmap_font(AssetManager *am, const Renderer *renderer,
                               const char *filepath, u64 tile_width,
                               u64 tile_height) {
  BitmapFont *font = (BitmapFont *)malloc(sizeof(BitmapFont));
  if (!font) {
    return NULL;
  }

  font->font_atlas =
      load_asset_to_manager(am, filepath, ASSET_TYPE_IMAGE, renderer);

  if (font->font_atlas == INVALID_ID) {
    destroy_bitmap_font(am, &font);

    return NULL;
  }

  SDL_Texture *texture = get_texture(am, font->font_atlas);

  i32 w;
  i32 h;

  if (SDL_QueryTexture(texture, NULL, NULL, &w, &h) != 0) {
    destroy_bitmap_font(am, &font);

    return NULL;
  }

  font->width = w;
  font->height = h;

  font->tile_width = tile_width;
  font->tile_height = tile_height;

  font->rows = font->height / font->tile_height;
  font->cols = font->width / font->tile_width;

  return font;
}

TextSize get_text_size_from_bitmap_font(BitmapFont *font, u64 font_size,
                                        const char *text) {
  u64 length = strlen(text);

  if (!font || font_size == 0 || length == 0) {
    return (TextSize){0};
  }

  TextSize size = {.width = 0, .height = font_size};

  f64 ratio = (f64)font_size / font->tile_height;

  size.width = (i32)(font->tile_width * ratio * length);

  return size;
}

void render_bitmap_font_text(AssetManager *am, Renderer *renderer,
                             BitmapFont *font, u64 font_size, const char *text,
                             u64 start_index, RenderRect dst_rect,
                             SDL_Color text_color) {
  if (!am || !renderer || !font || font_size == 0) {
    return;
  }

  u64 length = strlen(text);

  if (length == 0) {
    return;
  }

  SDL_Texture *texture = get_texture(am, font->font_atlas);

  u64 char_index = 0;
  RenderRect src = {0};
  RenderRect dst = {
      .y = dst_rect.y,
      .width = font->tile_width,
      .height = font->tile_height,
  };

  for (u64 i = 0; i < length; ++i) {
    char_index = (u64)(text[i]) - start_index;

    src = get_character_sprite(font, char_index);
    dst.x = i * font->tile_width + dst_rect.x;

    set_texture_color_modulation(texture, text_color);

    render_texture(renderer, texture, &src, &dst);
  }
}

void destroy_bitmap_font(AssetManager *am, BitmapFont **font) {
  if (!am || !(*font)) {
    return;
  }

  remove_asset_from_manager(am, &((*font)->font_atlas));

  free(*font);

  *font = NULL;
}

RenderRect get_character_sprite(BitmapFont *font, u64 index) {
  u64 char_count = font->cols * font->rows;

  if (index >= char_count) {
    return (RenderRect){0};
  }

  u64 col = index % font->cols;
  u64 row = index / font->cols;

  RenderRect rect = {
      .x = col * font->tile_width,
      .y = row * font->tile_height,
      .width = font->tile_width,
      .height = font->tile_height,
  };

  return rect;
}