#include "text.h"

#include <fcntl.h>
#include <mimalloc.h>
#include <unistd.h>
#include <utils.h>

#include "freetype/freetype.h"
#include "hash.h"
#include "utils.h"

static bool wayc_font_cache_lookup(struct font_s* font, codepoint_t codepoint,
                                   struct glyph_s* out) {
  struct glyph_s glyph;
  bool ok = wayc_hashmap_get(&font->cache, &codepoint, &glyph);
  if (ok) *out = glyph;
  return ok;
}

[[maybe_unused]] static void wayc_font_cache_insert(struct font_s* font,
                                                    codepoint_t codepoint,
                                                    struct glyph_s glyph) {
  wayc_notnull(font);
  wayc_hashmap_insert(&font->cache, &codepoint, &glyph);
}

enum font_context_error_e wayc_font_context_init(struct font_context_s* ctx) {
  wayc_notnull(ctx);

  FT_Error err = FT_Init_FreeType(&ctx->library);
  if (err) return FONT_CONTEXT_ERROR_LIBRARY;
  return FONT_CONTEXT_ERROR_NONE;
}

void wayc_font_context_deinit(struct font_context_s* ctx) {
  wayc_notnull(ctx);

  FT_Done_FreeType(ctx->library);
}

enum font_error_e wayc_font_init(struct font_s* font,
                                 struct font_context_s* ctx, const char* path) {
  wayc_notnull(font);
  wayc_notnull(ctx);
  wayc_notnull(path);

  bool success = false;

  i32 fd = open(path, O_RDONLY);
  if (fd < 0) return FONT_ERROR_FILE_LOAD;
  wayc_defer(close(fd));

  isize size = lseek(fd, 0, SEEK_END);
  if (size < 0) return FONT_ERROR_FILE_LOAD;
  lseek(fd, 0, SEEK_SET);

  u8* data = (u8*)mi_malloc(size);
  wayc_defer_cond({ mi_free(data); }, success, true);

  isize _read = read(fd, data, size);
  if (_read < 0 || _read != size) return FONT_ERROR_FILE_LOAD;

  FT_Error err = FT_New_Memory_Face(ctx->library, data, size, 0, &font->face);
  if (err) return FONT_ERROR_FONT_LOAD;

  font->data = data;
  wayc_hashmap_init(&font->cache);

  success = true;
  return FONT_ERROR_NONE;
}

enum font_error_e wayc_font_lookup(struct font_s* font, struct atlas_s* atlas,
                                   codepoint_t codepoint, struct glyph_s* out) {
  wayc_notnull(font);
  wayc_notnull(out);

  FT_Face face = font->face;

  bool found = wayc_font_cache_lookup(font, codepoint, out);
  if (found) return FONT_ERROR_NONE;

  FT_UInt glyph_index = FT_Get_Char_Index(face, codepoint);
  if (glyph_index == 0) return FONT_ERROR_NOT_MATCH;

  FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
  FT_GlyphSlot slot = face->glyph;
  FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL);

  wayc_panic("not yet implemented");
}

void wayc_font_deinit(struct font_s* font) {
  wayc_notnull(font);

  wayc_hashmap_deinit(&font->cache);
  FT_Done_Face(font->face);
  mi_free(font->data);
}