/******************************************************************************/
/***        include files                                                   ***/
/******************************************************************************/

#include "epd_driver.h"
#include "zlib.h"

#include <esp_assert.h>
#include <esp_heap_caps.h>
#include <esp_log.h>

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

/******************************************************************************/
/***        macro definitions                                               ***/
/******************************************************************************/

/******************************************************************************/
/***        type definitions                                                ***/
/******************************************************************************/

typedef struct {
  uint8_t mask; /* char data will be bitwise AND with this */
  uint8_t lead; /* start bytes of current char in utf-8 encoded character */
  uint32_t beg; /* beginning of codepoint range */
  uint32_t end; /* end of codepoint range */
  int32_t
      bits_stored; /* the number of bits from the codepoint that fits in char */
} utf_t;

/******************************************************************************/
/***        local function prototypes                                       ***/
/******************************************************************************/

static inline int32_t min(int32_t x, int32_t y) {
  return x < y ? x : y;
}

static inline int32_t max(int32_t x, int32_t y) {
  return x > y ? x : y;
}

static int32_t utf8_len(const uint8_t ch);

static uint32_t next_cp(uint8_t** string);

static FontProperties font_properties_default();

static void IRAM_ATTR draw_char(const GFXfont* font,
                                uint8_t* buffer,
                                int32_t* cursor_x,
                                int32_t cursor_y,
                                uint16_t buf_width,
                                uint16_t buf_height,
                                uint32_t cp,
                                const FontProperties* props);

/**
 * @brief Calculate the bounds of a character when drawn at (x, y), move the
 *        cursor (*x) forward, adjust the given bounds.
 */
static void get_char_bounds(const GFXfont* font,
                            uint32_t cp,
                            int32_t* x,
                            int32_t* y,
                            int32_t* minx,
                            int32_t* miny,
                            int32_t* maxx,
                            int32_t* maxy,
                            const FontProperties* props);

/******************************************************************************/
/***        exported variables                                              ***/
/******************************************************************************/

/******************************************************************************/
/***        local variables                                                 ***/
/******************************************************************************/

/**
 * @brief UTF-8 decode inspired from rosetta code
 *
 * https://rosettacode.org/wiki/UTF-8_encode_and_decode#C
 */
static utf_t* utf[] = {
    /*             mask        lead        beg      end       bits */
    [0] = &(utf_t){0b00111111, 0b10000000, 0, 0, 6},
    [1] = &(utf_t){0b01111111, 0b00000000, 0000, 0177, 7},
    [2] = &(utf_t){0b00011111, 0b11000000, 0200, 03777, 5},
    [3] = &(utf_t){0b00001111, 0b11100000, 04000, 0177777, 4},
    [4] = &(utf_t){0b00000111, 0b11110000, 0200000, 04177777, 3},
    &(utf_t){0},
};

/******************************************************************************/
/***        exported functions                                              ***/
/******************************************************************************/

void get_glyph(const GFXfont* font, uint32_t code_point, GFXglyph** glyph) {
  UnicodeInterval* intervals = font->intervals;
  *glyph = NULL;
  for (int32_t i = 0; i < font->interval_count; i++) {
    UnicodeInterval* interval = &intervals[i];
    if (code_point >= interval->first && code_point <= interval->last) {
      *glyph = &font->glyph[interval->offset + (code_point - interval->first)];
      return;
    }
    if (code_point < interval->first) {
      return;
    }
  }
  return;
}

void get_text_bounds(const GFXfont* font,
                     const char* string,
                     int32_t* x,
                     int32_t* y,
                     int32_t* x1,
                     int32_t* y1,
                     int32_t* w,
                     int32_t* h,
                     const FontProperties* properties) {
  FontProperties props;
  if (properties == NULL) {
    props = font_properties_default();
  } else {
    props = *properties;
  }

  if (*string == '\0') {
    *w = 0;
    *h = 0;
    *y1 = *y;
    *x1 = *x;
    return;
  }
  int32_t minx = 100000, miny = 100000, maxx = -1, maxy = -1;
  int32_t original_x = *x;
  uint32_t c;
  while ((c = next_cp((uint8_t**)&string))) {
    get_char_bounds(font, c, x, y, &minx, &miny, &maxx, &maxy, &props);
  }
  *x1 = min(original_x, minx);
  *w = maxx - *x1;
  *y1 = miny;
  *h = maxy - miny;
}

void write_mode(const GFXfont* font,
                const char* string,
                int32_t* cursor_x,
                int32_t* cursor_y,
                uint8_t* framebuffer,
                DrawMode_t mode,
                const FontProperties* properties) {
  if (*string == '\0')
    return;

  FontProperties props =
      (properties == NULL) ? font_properties_default() : *properties;

  int32_t x1 = 0, y1 = 0, w = 0, h = 0;
  int32_t tmp_cur_x = *cursor_x;
  int32_t tmp_cur_y = *cursor_y;
  get_text_bounds(font, string, &tmp_cur_x, &tmp_cur_y, &x1, &y1, &w, &h,
                  &props);

  uint8_t* buffer;
  int32_t buf_width;
  int32_t buf_height;
  int32_t baseline_height = *cursor_y - y1;

  // The local cursor position:
  // 0, if drawing to a local temporary buffer
  // the given cursor position, if drawing to a full frame buffer
  int32_t local_cursor_x = 0;
  int32_t local_cursor_y = 0;

  if (framebuffer == NULL) {
    buf_width = (w / 2 + w % 2);
    buf_height = h;
    buffer = (uint8_t*)malloc(buf_width * buf_height);
    memset(buffer, 255, buf_width * buf_height);
    local_cursor_y = buf_height - baseline_height;
  } else {
    buf_width = EPD_WIDTH / 2;
    buf_height = EPD_HEIGHT;
    buffer = framebuffer;
    local_cursor_x = *cursor_x;
    local_cursor_y = *cursor_y;
  }

  uint32_t c;

  int32_t cursor_x_init = local_cursor_x;
  int32_t cursor_y_init = local_cursor_y;

  uint8_t bg = props.bg_color;
  if (props.flags & DRAW_BACKGROUND) {
    for (int32_t l = 0; l < font->advance_y; l++) {
      epd_draw_hline(local_cursor_x,
                     local_cursor_y - (font->advance_y - baseline_height) + l,
                     w, bg << 4, buffer);
    }
  }
  while ((c = next_cp((uint8_t**)&string))) {
    draw_char(font, buffer, &local_cursor_x, local_cursor_y, buf_width,
              buf_height, c, &props);
  }

  *cursor_x += local_cursor_x - cursor_x_init;
  *cursor_y += local_cursor_y - cursor_y_init;

  if (framebuffer == NULL) {
    Rect_t area = {
        .x = x1, .y = *cursor_y - h + baseline_height, .width = w, .height = h};
    epd_draw_image(area, buffer, mode);
    free(buffer);
  }
}

void writeln(const GFXfont* font,
             const char* string,
             int32_t* cursor_x,
             int32_t* cursor_y,
             uint8_t* framebuffer) {
  return write_mode(font, string, cursor_x, cursor_y, framebuffer,
                    BLACK_ON_WHITE, NULL);
}

void write_string(const GFXfont* font,
                  const char* string,
                  int32_t* cursor_x,
                  int32_t* cursor_y,
                  uint8_t* framebuffer) {
  char *token, *newstring, *tofree;
  if (string == NULL) {
    ESP_LOGE("font.c", "cannot draw a NULL string!");
    return;
  }
  tofree = newstring = strdup(string);
  if (newstring == NULL) {
    ESP_LOGE("font.c", "cannot allocate string copy!");
    return;
  }

  // taken from the strsep manpage
  int32_t line_start = *cursor_x;
  while ((token = strsep(&newstring, "\n")) != NULL) {
    *cursor_x = line_start;
    writeln(font, token, cursor_x, cursor_y, framebuffer);
    *cursor_y += font->advance_y;
  }

  free(tofree);
}

/******************************************************************************/
/***        local functions                                                 ***/
/******************************************************************************/

static int32_t utf8_len(const uint8_t ch) {
  int32_t len = 0;
  for (utf_t** u = utf; *u; ++u) {
    if ((ch & ~(*u)->mask) == (*u)->lead) {
      break;
    }
    ++len;
  }
  if (len > 4) { /* Malformed leading byte */
    assert("invalid unicode.");
  }
  return len;
}

static uint32_t next_cp(uint8_t** string) {
  if (**string == 0)
    return 0;

  int32_t bytes = utf8_len(**string);
  uint8_t* chr = *string;
  *string += bytes;
  int32_t shift = utf[0]->bits_stored * (bytes - 1);
  uint32_t codep = (*chr++ & utf[bytes]->mask) << shift;

  for (int32_t i = 1; i < bytes; ++i, ++chr) {
    shift -= utf[0]->bits_stored;
    codep |= ((uint8_t)*chr & utf[0]->mask) << shift;
  }

  return codep;
}

static FontProperties font_properties_default() {
  FontProperties props = {
      .fg_color = 0, .bg_color = 15, .fallback_glyph = 0, .flags = 0};
  return props;
}

static void IRAM_ATTR draw_char(const GFXfont* font,
                                uint8_t* buffer,
                                int32_t* cursor_x,
                                int32_t cursor_y,
                                uint16_t buf_width,
                                uint16_t buf_height,
                                uint32_t cp,
                                const FontProperties* props) {
  GFXglyph* glyph;
  get_glyph(font, cp, &glyph);

  if (!glyph) {
    get_glyph(font, props->fallback_glyph, &glyph);
  }

  if (!glyph) {
    return;
  }

  uint32_t offset = glyph->data_offset;
  uint8_t width = glyph->width;
  uint8_t height = glyph->height;
  int32_t left = glyph->left;

  int32_t byte_width = (width / 2 + width % 2);
  unsigned long bitmap_size = byte_width * height;
  uint8_t* bitmap = NULL;
  if (font->compressed) {
    bitmap = (uint8_t*)malloc(bitmap_size);
    uncompress(bitmap, &bitmap_size, &font->bitmap[offset],
               glyph->compressed_size);
  } else {
    bitmap = &font->bitmap[offset];
  }

  uint8_t color_lut[16];
  for (int32_t c = 0; c < 16; c++) {
    int32_t color_difference =
        (int32_t)props->fg_color - (int32_t)props->bg_color;
    color_lut[c] = max(0, min(15, props->bg_color + c * color_difference / 15));
  }

  for (int32_t y = 0; y < height; y++) {
    int32_t yy = cursor_y - glyph->top + y;
    if (yy < 0 || yy >= buf_height) {
      continue;
    }
    int32_t start_pos = *cursor_x + left;
    bool byte_complete = start_pos % 2;
    int32_t x = max(0, -start_pos);
    int32_t max_x = min(start_pos + width, buf_width * 2);
    for (int32_t xx = start_pos; xx < max_x; xx++) {
      uint32_t buf_pos = yy * buf_width + xx / 2;
      uint8_t old = buffer[buf_pos];
      uint8_t bm = bitmap[y * byte_width + x / 2];
      if ((x & 1) == 0) {
        bm = bm & 0xF;
      } else {
        bm = bm >> 4;
      }

      if ((xx & 1) == 0) {
        buffer[buf_pos] = (old & 0xF0) | color_lut[bm];
      } else {
        buffer[buf_pos] = (old & 0x0F) | (color_lut[bm] << 4);
      }
      byte_complete = !byte_complete;
      x++;
    }
  }
  if (font->compressed) {
    free(bitmap);
  }
  *cursor_x += glyph->advance_x;
}

static void get_char_bounds(const GFXfont* font,
                            uint32_t cp,
                            int32_t* x,
                            int32_t* y,
                            int32_t* minx,
                            int32_t* miny,
                            int32_t* maxx,
                            int32_t* maxy,
                            const FontProperties* props) {
  GFXglyph* glyph;
  get_glyph(font, cp, &glyph);

  if (!glyph) {
    get_glyph(font, props->fallback_glyph, &glyph);
  }

  if (!glyph)
    return;

  int32_t x1 = *x + glyph->left;
  int32_t y1 = *y + (glyph->top - glyph->height);
  int32_t x2 = x1 + glyph->width;
  int32_t y2 = y1 + glyph->height;

  // background needs to be taken into account
  if (props->flags & DRAW_BACKGROUND) {
    *minx = min(*x, min(*minx, x1));
    *maxx = max(max(*x + glyph->advance_x, x2), *maxx);
    *miny = min(*y + font->descender, min(*miny, y1));
    *maxy = max(font->descender + font->advance_y, max(*maxy, y2));
  } else {
    if (x1 < *minx)
      *minx = x1;
    if (y1 < *miny)
      *miny = y1;
    if (x2 > *maxx)
      *maxx = x2;
    if (y2 > *maxy)
      *maxy = y2;
  }
  *x += glyph->advance_x;
}

/******************************************************************************/
/***        END OF FILE                                                     ***/
/******************************************************************************/