/* The font rasterizer takes a standard font and converts it into a bitmap
 * embeddable font. In other words, it takes a .ttf in and outputs a .c/.h pair.
 *
 * It can also print a PNG file showing how each glyph has been rendered.
*
 * Usage: rasterizer font_name glyph_width glyph_height
 * -> Generates a .png image with the font rasterized
 * -> Generates a .c file with the content of the font */

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

#include <ft2build.h>
#include FT_FREETYPE_H

#include "unicode_for_symbol.h"

#define ENSURE(action, description...) { if (!(action)) { fprintf(stderr, "Error: "); fprintf(stderr, description); fprintf(stderr, "\n"); exit(-1);}}

// Pixel format is RGB888

typedef struct {
  unsigned char red;
  unsigned char green;
  unsigned char blue;
} pixel_t;

typedef struct {
  pixel_t * pixels;
  int width;
  int height;
} image_t;

#ifdef GENERATE_PNG
#include <png.h>
void writeImageToPNGFile(image_t * image, char * filename);
#endif

#define CHARACTER_RANGE_START 0x20
#define CHARACTER_RANGE_END 0x7E

#define GRID_WIDTH 19
#define GRID_HEIGHT 8

#if (GRID_WIDTH*GRID_HEIGHT < (NUMBER_OF_SYMBOLS+CHARACTER_RANGE_END-CHARACTER_RANGE_START+1))
#error Grid too small. Consider increasing GRID_WIDTH or GRID_HEIGHT
#endif

void drawGlyphInImage(FT_Bitmap * glyphBitmap, image_t * image, int x, int y);

int main(int argc, char * argv[]) {
  FT_Library library;
  FT_Face face;
  image_t bitmap_image;

  int expectedNumberOfArguments = 7;
#ifdef GENERATE_PNG
  expectedNumberOfArguments = 8;
#endif
  if (argc != expectedNumberOfArguments) {
#ifdef GENERATE_PNG
    fprintf(stderr, "Usage: %s font_file glyph_width glyph_height font_name output_header output_implementation output_png\n", argv[0]);
#else
    fprintf(stderr, "Usage: %s font_file glyph_width glyph_height font_name output_header output_implementation\n", argv[0]);
#endif
    fprintf(stderr, "  font_file: Path of the font file to load\n");
    fprintf(stderr, "  glyph_width: Width of bitmap glyphs, in pixels\n");
    fprintf(stderr, "  glyph_height: Height of bitmap glyphs, in pixels\n");
    fprintf(stderr, "  font_name: name of the loaded font\n");
    fprintf(stderr, "  output_header: Name of the generated C header file\n");
    fprintf(stderr, "  output_implementation: Name of the generated C source file\n");
#ifdef GENERATE_PNG
    fprintf(stderr, "  output_png: Name of the generated PNG file\n");
#endif
    exit(1);
  }

  char * font_file = argv[1];
  int requested_glyph_width = atoi(argv[2]);
  int requested_glyph_height = atoi(argv[3]);
  char * font_name = argv[4];
  char * output_header = argv[5];
  char * output_implementation = argv[6];
#ifdef GENERATE_PNG
  char * output_png = argv[7];
#endif

  ENSURE(!FT_Init_FreeType(&library), "Initializing library");

  // 0 means we're picking the first face in the provided file
  ENSURE(!FT_New_Face(library, font_file, 0, &face), "Loading font file %s", font_file);

  ENSURE(!FT_Set_Pixel_Sizes(face, requested_glyph_width, requested_glyph_height), "Setting face pixel size to %dx%d", requested_glyph_width, requested_glyph_height);

  /* Glyph metrics are complicated. Here are some useful links:
   * https://www.freetype.org/freetype2/docs/glyphs/metrics.png
   * https://www.freetype.org/freetype2/docs/glyphs/glyphs-3.html
   * https://www.freetype.org/freetype2/docs/reference/ft2-basic_types.html#FT_Bitmap
   */
  int maxWidth = 0;
  int maxAboveBaseline = 0;
  int maxBelowBaseline = 0;
  for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
    ENSURE(!FT_Load_Char(face, character, FT_LOAD_RENDER), "Loading character 0x%02x", character);
    int aboveBaseline = face->glyph->bitmap_top;
    int belowBaseline = face->glyph->bitmap.rows - face->glyph->bitmap_top;
    int width = face->glyph->bitmap_left + face->glyph->bitmap.width;
    if (width > maxWidth) {
      maxWidth = width;
    }
    if (aboveBaseline > maxAboveBaseline) {
      maxAboveBaseline = aboveBaseline;
    }
    if (belowBaseline > maxBelowBaseline) {
      maxBelowBaseline = belowBaseline;
    }
  }
  for (int charIndex = 0; charIndex < NUMBER_OF_SYMBOLS; charIndex++) {
    wchar_t wideChar = codePointForSymbol[charIndex];
    ENSURE(!FT_Load_Char(face, wideChar, FT_LOAD_RENDER), "Loading character 0x%02x", wideChar);
    int aboveBaseline = face->glyph->bitmap_top;
    int belowBaseline = face->glyph->bitmap.rows - face->glyph->bitmap_top;
    int width = face->glyph->bitmap_left + face->glyph->bitmap.width;
    if (width > maxWidth) {
      maxWidth = width;
    }
    if (aboveBaseline > maxAboveBaseline) {
      maxAboveBaseline = aboveBaseline;
    }
    if (belowBaseline > maxBelowBaseline) {
      maxBelowBaseline = belowBaseline;
    }
  }

  int glyph_width = maxWidth-1;
  int glyph_height = maxAboveBaseline+maxBelowBaseline;
  //printf("Actual glyph size = %dx%d\n", glyph_width, glyph_height);

  int grid_size = 1;

  bitmap_image.width = GRID_WIDTH*glyph_width+(GRID_WIDTH-1)*grid_size;
  bitmap_image.height = GRID_HEIGHT*glyph_height+(GRID_HEIGHT-1)*grid_size;
  bitmap_image.pixels = malloc(sizeof(pixel_t)*bitmap_image.width*bitmap_image.height);
  ENSURE(bitmap_image.pixels != NULL, "Allocating bitmap image of size %dx%d at %ld bytes per pixel", bitmap_image.width, bitmap_image.height, sizeof(pixel_t));

  // Draw the grid and the background
  for (int i = 0; i<bitmap_image.width;i++) {
    for (int j = 0; j<bitmap_image.height;j++) {
      pixel_t pixel = {.red = 0xFF, .green = 0xFF, .blue = 0xFF};
      if (i%(glyph_width+grid_size) >= glyph_width || j%(glyph_height+grid_size) >= glyph_height) {
        pixel = (pixel_t){.red = 0xFF, .green = 0, .blue = 0};
      }
      *(bitmap_image.pixels + j*bitmap_image.width + i) = pixel;
    }
  }

  // We're doing the ASCII table, so characters from 0 to 255 inclusive
  for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
    int x = (character-CHARACTER_RANGE_START)%(GRID_WIDTH);
    int y = (character-CHARACTER_RANGE_START)/(GRID_WIDTH);
    // FT_LOAD_RENDER: Render the glyph upon load
    ENSURE(!FT_Load_Char(face, character, FT_LOAD_RENDER), "Loading character 0x%02x", character);
    //printf("Advances = %dx%d\n", face->glyph->bitmap_left, face->glyph->bitmap_top);
    drawGlyphInImage(&face->glyph->bitmap,
        &bitmap_image,
        x*(glyph_width+grid_size) + face->glyph->bitmap_left,
        y*(glyph_height+grid_size) + maxAboveBaseline - face->glyph->bitmap_top
    );
  }
  // We are now using unicode to access non-ASCII characters
  for (int charIndex = 0; charIndex < NUMBER_OF_SYMBOLS; charIndex++) {
    wchar_t wideChar = codePointForSymbol[charIndex];
    int x = (charIndex+1+CHARACTER_RANGE_END-CHARACTER_RANGE_START)%(GRID_WIDTH);
    int y = (charIndex+1+CHARACTER_RANGE_END-CHARACTER_RANGE_START)/(GRID_WIDTH);
    // FT_LOAD_RENDER: Render the glyph upon load
    ENSURE(!FT_Load_Char(face, wideChar, FT_LOAD_RENDER), "Loading character 0x%02x", wideChar);
    //printf("Advances = %dx%d\n", face->glyph->bitmap_left, face->glyph->bitmap_top);
    drawGlyphInImage(&face->glyph->bitmap,
        &bitmap_image,
        x*(glyph_width+grid_size) + face->glyph->bitmap_left,
        y*(glyph_height+grid_size) + maxAboveBaseline - face->glyph->bitmap_top
    );
  }

#if GENERATE_PNG
  writeImageToPNGFile(&bitmap_image, output_png);
#endif

  FILE * headerFile = fopen(output_header, "w");
  fprintf(headerFile, "/* Auto-generated by rasterizer */\n\n");
  fprintf(headerFile, "#define BITMAP_%s_FIRST_CHARACTER 0x%2x\n", font_name, CHARACTER_RANGE_START);
  fprintf(headerFile, "#define BITMAP_%s_LAST_CHARACTER 0x%2x\n\n", font_name, CHARACTER_RANGE_END+NUMBER_OF_SYMBOLS);
  fprintf(headerFile, "#define BITMAP_%s_CHARACTER_WIDTH %d\n", font_name, glyph_width);
  fprintf(headerFile, "#define BITMAP_%s_CHARACTER_HEIGHT %d\n\n", font_name, glyph_height);
  fprintf(headerFile, "extern const unsigned char bitmap%s[%d][%d][%d];\n", font_name, NUMBER_OF_SYMBOLS+CHARACTER_RANGE_END-CHARACTER_RANGE_START+1, glyph_height, glyph_width);
  fclose(headerFile);

  FILE * sourceFile = fopen(output_implementation, "w");
  fprintf(sourceFile, "/* Auto-generated by rasterizer */\n\n");
  fprintf(sourceFile, "const unsigned char bitmap%s[%d][%d][%d] = {\n", font_name, NUMBER_OF_SYMBOLS+CHARACTER_RANGE_END-CHARACTER_RANGE_START+1, glyph_height, glyph_width);
  for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
    fprintf(sourceFile, "  {\n");
    int characterX = ((character-CHARACTER_RANGE_START)%GRID_WIDTH * (glyph_width+grid_size));
    int characterY = ((character-CHARACTER_RANGE_START)/GRID_WIDTH * (glyph_height+grid_size));
    for (int y = 0; y < glyph_height; y++) {
      fprintf(sourceFile, "    {");
      for (int x = 0; x < glyph_width; x++) {
        pixel_t * pixel = (bitmap_image.pixels + (y+characterY)*bitmap_image.width + (x+characterX));
        fprintf(sourceFile, "0x%02x", 0xFF - pixel->green);
        if (x+1 < glyph_width) {
          fprintf(sourceFile, ", ");
        }
      }
      fprintf(sourceFile, "}");
      if (y+1 < glyph_height) {
        fprintf(sourceFile, ",");
      }
      fprintf(sourceFile, "\n");
    }
    fprintf(sourceFile, "  }");
    fprintf(sourceFile, ",");
    fprintf(sourceFile, "\n");
  }
  for (int charIndex = 0; charIndex < NUMBER_OF_SYMBOLS; charIndex++) {
    wchar_t wideChar = codePointForSymbol[charIndex];
    fprintf(sourceFile, "  {\n");
    int characterX = ((charIndex+1+CHARACTER_RANGE_END-CHARACTER_RANGE_START)%GRID_WIDTH * (glyph_width+grid_size));
    int characterY = ((charIndex+1+CHARACTER_RANGE_END-CHARACTER_RANGE_START)/GRID_WIDTH * (glyph_height+grid_size));
    for (int y = 0; y < glyph_height; y++) {
      fprintf(sourceFile, "    {");
      for (int x = 0; x < glyph_width; x++) {
        pixel_t * pixel = (bitmap_image.pixels + (y+characterY)*bitmap_image.width + (x+characterX));
        fprintf(sourceFile, "0x%02x", 0xFF - pixel->green);
        if (x+1 < glyph_width) {
          fprintf(sourceFile, ", ");
        }
      }
      fprintf(sourceFile, "}");
      if (y+1 < glyph_height) {
        fprintf(sourceFile, ",");
      }
      fprintf(sourceFile, "\n");
    }
    fprintf(sourceFile, "  }");
    if (charIndex < NUMBER_OF_SYMBOLS - 1) {
      fprintf(sourceFile, ",");
    }
    fprintf(sourceFile, "\n");
  }

  fprintf(sourceFile, "};\n");
  fclose(sourceFile);

  free(bitmap_image.pixels);

  return 0;
}

void drawGlyphInImage(FT_Bitmap * glyphBitmap, image_t * image, int x, int y) {
  // printf("Drawing glyph. Size is %dx%d, pitch is %d\n", glyphBitmap->width, glyphBitmap->rows, glyphBitmap->pitch);
  ENSURE(glyphBitmap->pixel_mode == FT_PIXEL_MODE_GRAY, "Checking glyph is in FT_PIXEL_MODE_GRAY");
  for (int j=0;j<glyphBitmap->rows;j++) {
    for (int i=0;i<glyphBitmap->width;i++) {
      uint8_t glyphPixel = *(glyphBitmap->buffer + j*glyphBitmap->pitch + i);
      pixel_t * currentPixelPointer = (image->pixels + (y+j)*image->width + (x+i));
      *currentPixelPointer = (pixel_t){.red = (0xFF-glyphPixel), .green = (0xFF-glyphPixel), .blue = (0xFF-glyphPixel)}; // Alpha blending
    }
  }
}

#if GENERATE_PNG

void writeImageToPNGFile(image_t * image, char * filename) {
  FILE * file = fopen(filename, "wb"); // Write in binary mode
  ENSURE(file != NULL, "Opening file %s", filename);

  png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  ENSURE(png != NULL, "Allocating PNG write structure");

  png_infop info = png_create_info_struct(png);
  ENSURE(info != NULL, "Allocating info structure");

  png_init_io(png, file);

  png_set_IHDR(png, info,
      image->width, image->height,
      8, // Number of bits per channel
      PNG_COLOR_TYPE_RGB,
      PNG_INTERLACE_NONE,
      PNG_COMPRESSION_TYPE_DEFAULT,
      PNG_FILTER_TYPE_DEFAULT);

  png_write_info(png, info);

  for (int j=0;j<image->height;j++) {
    png_write_row(png, (png_bytep)(image->pixels+j*image->width));
  }

  png_write_end(png, NULL);

  png_free_data(png, info, PNG_FREE_ALL, -1); // -1 = all items
  png_destroy_write_struct(&png, (png_infopp)NULL);
  fclose(file);
}
#endif