///
///	@file bdf2c.c		@brief BDF Font to C source convertor
///
///	Copyright (c) 2009, 2010 by Lutz Sammer.  All Rights Reserved.
///
///	Contributor(s): 
///
///	License: AGPLv3
///
///	This program is free software: you can redistribute it and/or modify
///	it under the terms of the GNU Affero General Public License as
///	published by the Free Software Foundation, either version 3 of the
///	License.
///
///	This program is distributed in the hope that it will be useful,
///	but WITHOUT ANY WARRANTY; without even the implied warranty of
///	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
///	GNU Affero General Public License for more details.
///
///	$Id$
//////////////////////////////////////////////////////////////////////////////

///
///	@mainpage
///		bdf2c - converts bdf font files into C include files.
///
///		The Bitmap Distribution Format (BDF) is a file format for
///		storing bitmap fonts. The content is presented as a text file
///		that is intended to be human and computer readable.
///

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include <errno.h>

#define VERSION "3"			///< version of this application

//////////////////////////////////////////////////////////////////////////////

int Outline;				///< true generate outlined font

//////////////////////////////////////////////////////////////////////////////

///
///	Create our header file.
///
///	@param out	file stream for output
///
void CreateFontHeaderFile(FILE * out)
{
    register int i;

    fprintf(out,
	"// (c) 2009, 2010 Lutz Sammer, License: AGPLv3\n\n"
	"\t/// bitmap font structure\n" "struct bitmap_font {\n"
	"\tunsigned char Width;\t\t///< max. character width\n"
	"\tunsigned char Height;\t\t///< character height\n"
	"\tunsigned short Chars;\t\t///< number of characters in font\n"
	"\tconst unsigned char *Widths;\t///< width of each character\n"
	"\tconst unsigned short *Index;\t///< encoding to character index\n"
	"\tconst unsigned char *Bitmap;\t///< bitmap of all characters\n"
	"};\n\n");

    fprintf(out, "\t/// @{ defines to have human readable font files\n");
    for (i = 0; i < 256; ++i) {
	fprintf(out, "#define %c%c%c%c%c%c%c%c 0x%02X\n",
	    (i & 0x80) ? 'X' : '_', (i & 0x40) ? 'X' : '_',
	    (i & 0x20) ? 'X' : '_', (i & 0x10) ? 'X' : '_',
	    (i & 0x08) ? 'X' : '_', (i & 0x04) ? 'X' : '_',
	    (i & 0x02) ? 'X' : '_', (i & 0x01) ? 'X' : '_', i);
    }
    fprintf(out, "\t/// @}\n");
}

//////////////////////////////////////////////////////////////////////////////

///
///	Print header for c file.
///
///	@param out	file stream for output
///	@param name	font variable name in C source file
///
void Header(FILE * out, const char *name)
{
    fprintf(out,
	"// Created from bdf2c Version %s, (c) 2009, 2010 by Lutz Sammer\n"
	"//\tLicense AGPLv3: GNU Affero General Public License version 3\n"
	"\n#include \"font.h\"\n\n", VERSION);

    fprintf(out,
	"\t/// character bitmap for each encoding\n"
	"static const unsigned char __%s_bitmap__[] = {\n", name);
}

///
///	Print width table for c file
///
///	@param out		file stream for output
///	@param name		font variable name in C source file
///	@param width_table	width table read from BDF file
///	@param chars		number of characters in width table
///
void WidthTable(FILE * out, const char *name, const unsigned *width_table,
    int chars)
{
    fprintf(out, "};\n\n");

    fprintf(out,
	"\t/// character width for each encoding\n"
	"static const unsigned char __%s_widths__[] = {\n", name);
    while (chars--) {
	fprintf(out, "\t%u,\n", *width_table++);
    }
}

///
///	Print encoding table for c file
///
///	@param out		file stream for output
///	@param name		font variable name in C source file
///	@param encoding_table	encoding table read from BDF file
///	@param chars		number of characters in encoding table
///
void EncodingTable(FILE * out, const char *name,
    const unsigned *encoding_table, int chars)
{
    fprintf(out, "};\n\n");

    fprintf(out,
	"\t/// character encoding for each index entry\n"
	"static const unsigned short __%s_index__[] = {\n", name);
    while (chars--) {
	fprintf(out, "\t%u,\n", *encoding_table++);
    }
}

///
///	Print footer for c file.
///
///	@param out		file stream for output
///	@param name		font variable name in C source file
///	@param width		character width of font
///	@param height		character height of font
///	@param chars		number of characters in font
///
void Footer(FILE * out, const char *name, int width, int height, int chars)
{
    fprintf(out, "};\n\n");
    fprintf(out,
	"\t/// bitmap font structure\n" "const struct bitmap_font %s = {\n",
	name);
    fprintf(out, "\t.Width = %d, .Height = %d,\n", width, height);
    fprintf(out, "\t.Chars = %d,\n", chars);
    fprintf(out, "\t.Widths = __%s_widths__,\n", name);
    fprintf(out, "\t.Index = __%s_index__,\n", name);
    fprintf(out, "\t.Bitmap = __%s_bitmap__,\n", name);
    fprintf(out, "};\n\n");
}

///
///	Dump character.
///
///	@param out	file stream for output
///	@param bitmap	input bitmap
///	@param width	character width
///	@param height	character height
///
void DumpCharacter(FILE * out, unsigned char *bitmap, int width, int height)
{
    int x;
    int y;
    int c;

    for (y = 0; y < height; ++y) {
	fputc('\t', out);
	for (x = 0; x < width; x += 8) {
	    c = bitmap[y * ((width + 7) / 8) + x / 8];
	    //printf("%d = %d\n", y * ((width+7)/8) + x/8, c);
	    if (c & 0x80) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x40) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x20) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x10) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x08) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x04) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x02) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    if (c & 0x01) {
		fputc('X', out);
	    } else {
		fputc('_', out);
	    }
	    fputc(',', out);
	}
	fputc('\n', out);
    }
}

///
///	Hex ascii to integer
///
///	@param p	hex input character (0-9a-fA-F)
///
///	@returns converted integer
///
static inline int Hex2Int(const char *p)
{
    if (*p <= '9') {
	return *p - '0';
    } else if (*p <= 'F') {
	return *p - 'A' + 10;
    } else {
	return *p - 'a' + 10;
    }
}

///
///	Rotate bitmap.
///
///	@param bitmap	input bitmap
///	@param shift	rotate counter (0-7)
///	@param width	character width
///	@param height	character height
///
void RotateBitmap(unsigned char *bitmap, int shift, int width, int height)
{
    int x;
    int y;
    int c;
    int o;

    if (shift < 0 || shift > 7) {
	fprintf(stderr, "This shift isn't supported\n");
	exit(-1);
    }

    for (y = 0; y < height; ++y) {
	o = 0;
	for (x = 0; x < width; x += 8) {
	    c = bitmap[y * ((width + 7) / 8) + x / 8];
	    bitmap[y * ((width + 7) / 8) + x / 8] = c >> shift | o;
	    o = c << (8 - shift);
	}
    }
}

///
///	Outline character.  Create an outline font from normal fonts.
///
///	@param bitmap	input bitmap
///	@param width	character width
///	@param height	character height
///
void OutlineCharacter(unsigned char *bitmap, int width, int height)
{
    int x;
    int y;
    unsigned char *outline;

    outline = alloca(((width + 7) / 8) * height);
    memset(outline, 0, ((width + 7) / 8) * height);
    for (y = 0; y < height; ++y) {
	for (x = 0; x < width; ++x) {
	    // Bit not set check surroundings
	    if (~bitmap[y * ((width + 7) / 8) + x / 8] & (0x80 >> x % 8)) {
		// Upper row bit was set
		if (y
		    && bitmap[(y - 1) * ((width + 7) / 8) +
			x / 8] & (0x80 >> x % 8)) {
		    outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
		    // Previous bit was set
		} else if (x
		    && bitmap[y * ((width + 7) / 8) + (x -
			    1) / 8] & (0x80 >> (x - 1) % 8)) {
		    outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
		    // Next bit was set
		} else if (x < width - 1
		    && bitmap[y * ((width + 7) / 8) + (x +
			    1) / 8] & (0x80 >> (x + 1) % 8)) {
		    outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
		    // below row was set
		} else if (y < height - 1
		    && bitmap[(y + 1) * ((width + 7) / 8) +
			x / 8] & (0x80 >> x % 8)) {
		    outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
		}
	    }
	}
    }
    memcpy(bitmap, outline, ((width + 7) / 8) * height);
}

///
///	Read BDF font file.
///
///	@paran bdf	file stream for input (bdf file)
///	@param out	file stream for output (C source file)
///	@param name	font variable name in C source file
///
///	@todo bbx isn't used to correct character position in bitmap
///
void ReadBdf(FILE * bdf, FILE * out, const char *name)
{
    char linebuf[1024];
    char *s;
    char *p;
    int fontboundingbox_width;
    int fontboundingbox_height;
    int chars;
    int i;
    int j;
    int n;
    int scanline;
    char charname[1024];
    int encoding;
    int bbx;
    int bby;
    int bbw;
    int bbh;
    int width;
    unsigned *width_table;
    unsigned *encoding_table;
    unsigned char *bitmap;

    fontboundingbox_width = 0;
    fontboundingbox_height = 0;
    chars = 0;
    for (;;) {
	if (!fgets(linebuf, sizeof(linebuf), bdf)) {	// EOF
	    break;
	}
	if (!(s = strtok(linebuf, " \t\n\r"))) {	// empty line
	    break;
	}
	// printf("token:%s\n", s);
	if (!strcasecmp(s, "FONTBOUNDINGBOX")) {
	    p = strtok(NULL, " \t\n\r");
	    fontboundingbox_width = atoi(p);
	    p = strtok(NULL, " \t\n\r");
	    fontboundingbox_height = atoi(p);
	} else if (!strcasecmp(s, "CHARS")) {
	    p = strtok(NULL, " \t\n\r");
	    chars = atoi(p);
	    break;
	}
    }
    /*
       printf("%d * %dx%d\n", chars, fontboundingbox_width,
       fontboundingbox_height);
     */
    //
    //	Some checks.
    //
    if (fontboundingbox_width <= 0 || fontboundingbox_height <= 0) {
	fprintf(stderr, "Need to know the character size\n");
	exit(-1);
    }
    if (chars <= 0) {
	fprintf(stderr, "Need to know the number of characters\n");
	exit(-1);
    }
    if (Outline) {			// Reserve space for outline border
	fontboundingbox_width++;
	fontboundingbox_height++;
    }
    //
    //	Allocate tables
    //
    width_table = malloc(chars * sizeof(*width_table));
    if (!width_table) {
	fprintf(stderr, "Out of memory\n");
	exit(-1);
    }
    encoding_table = malloc(chars * sizeof(*encoding_table));
    if (!encoding_table) {
	fprintf(stderr, "Out of memory\n");
	exit(-1);
    }
    /*	FIXME: needed for proportional fonts.
       offset_table = malloc(chars * sizeof(*offset_table));
       if (!offset_table) {
       fprintf(stderr, "Out of memory\n");
       exit(-1);
       }
     */
    bitmap =
	malloc(((fontboundingbox_width + 7) / 8) * fontboundingbox_height);
    if (!bitmap) {
	fprintf(stderr, "Out of memory\n");
	exit(-1);
    }

    Header(out, name);

    scanline = -1;
    n = 0;
    encoding = -1;
    bbx = 0;
    bby = 0;
    bbw = 0;
    bbh = 0;
    width = INT_MIN;
    strcpy(charname, "unknown character");
    for (;;) {
	if (!fgets(linebuf, sizeof(linebuf), bdf)) {	// EOF
	    break;
	}
	if (!(s = strtok(linebuf, " \t\n\r"))) {	// empty line
	    break;
	}
	// printf("token:%s\n", s);
	if (!strcasecmp(s, "STARTCHAR")) {
	    p = strtok(NULL, " \t\n\r");
	    strcpy(charname, p);
	} else if (!strcasecmp(s, "ENCODING")) {
	    p = strtok(NULL, " \t\n\r");
	    encoding = atoi(p);
	} else if (!strcasecmp(s, "DWIDTH")) {
	    p = strtok(NULL, " \t\n\r");
	    width = atoi(p);
	} else if (!strcasecmp(s, "BBX")) {
	    p = strtok(NULL, " \t\n\r");
	    bbw = atoi(p);
	    p = strtok(NULL, " \t\n\r");
	    bbh = atoi(p);
	    p = strtok(NULL, " \t\n\r");
	    bbx = atoi(p);
	    p = strtok(NULL, " \t\n\r");
	    bby = atoi(p);
	} else if (!strcasecmp(s, "BITMAP")) {
	    fprintf(out, "// %3d $%02x '%s'\n", encoding, encoding, charname);
	    fprintf(out, "//\twidth %d, bbx %d, bby %d, bbw %d, bbh %d\n",
		width, bbx, bby, bbw, bbh);

	    if (n == chars) {
		fprintf(stderr, "Too many bitmaps for characters\n");
		exit(-1);
	    }
	    if (width == INT_MIN) {
		fprintf(stderr, "character width not specified\n");
		exit(-1);
	    }
	    //
	    //	Adjust width based on bounding box
	    //
	    if (bbx < 0) {
		width -= bbx;
		bbx = 0;
	    }
	    if (bbx + bbw > width) {
		width = bbx + bbw;
	    }
	    if (Outline) {		// Reserve space for outline border
		++width;
	    }
	    width_table[n] = width;
	    encoding_table[n] = encoding;
	    ++n;
	    if (Outline) {		// Leave first row empty
		scanline = 1;
	    } else {
		scanline = 0;
	    }
	    memset(bitmap, 0,
		((fontboundingbox_width + 7) / 8) * fontboundingbox_height);
	} else if (!strcasecmp(s, "ENDCHAR")) {
	    if (bbx) {
		RotateBitmap(bitmap, bbx, fontboundingbox_width,
		    fontboundingbox_height);
	    }
	    if (Outline) {
		RotateBitmap(bitmap, 1, fontboundingbox_width,
		    fontboundingbox_height);
		OutlineCharacter(bitmap, fontboundingbox_width,
		    fontboundingbox_height);
	    }
	    DumpCharacter(out, bitmap, fontboundingbox_width,
		fontboundingbox_height);
	    scanline = -1;
	    width = INT_MIN;
	} else {
	    if (scanline >= 0) {
		p = s;
		j = 0;
		while (*p) {
		    i = Hex2Int(p);
		    ++p;
		    if (*p) {
			i = Hex2Int(p) | i * 16;
		    } else {
			bitmap[j + scanline * ((fontboundingbox_width +
				    7) / 8)] = i;
			break;
		    }
		    /* printf("%d = %d\n", 
		       j + scanline * ((fontboundingbox_width + 7)/8), i); */
		    bitmap[j + scanline * ((fontboundingbox_width + 7) / 8)] =
			i;
		    ++j;
		    ++p;
		}
		++scanline;
	    }
	}
    }

    // Output width table for proportional font.
    WidthTable(out, name, width_table, chars);
    // FIXME: Output offset table for proportional font.
    // OffsetTable(out, name, offset_table, chars);
    // Output encoding table for utf-8 support
    EncodingTable(out, name, encoding_table, chars);

    Footer(out, name, fontboundingbox_width, fontboundingbox_height, chars);
}

//////////////////////////////////////////////////////////////////////////////

///
///	Print version
///
void PrintVersion(void)
{
    printf("bdf2c Version %s, (c) 2009, 2010 by Lutz Sammer\n"
	"\tLicense AGPLv3: GNU Affero General Public License version 3\n",
	VERSION);
}

///
///	Print usage
///
void PrintUsage(void)
{
    printf("Usage: bdf2c [OPTIONs]\n"
	"\t-h or -?\tPrints this short page on stdout\n"
	"\t-b\tRead bdf file from stdin, write to stdout\n"
	"\t-c\tCreate font header on stdout\n"
	"\t-C file\tCreate font header file\n"
	"\t-n name\tName of c font variable (place it before -b)\n"
	"\t-O\tCreate outline for the font.\n");
    printf("\n\tOnly idiots print usage on stderr\n");
}

///
///	Main test program for bdf2c.
///
///
///	@param argc	number of arguments
///	@param argv	arguments vector
///
int main(int argc, char *const argv[])
{
    const char *name;

    name = "font";			// default variable name
    //
    //	Parse arguments.
    //
    for (;;) {
	switch (getopt(argc, argv, "bcC:n:hO?-")) {
	    case 'b':			// bdf file name
		ReadBdf(stdin, stdout, name);
		continue;
	    case 'c':			// create header file
		CreateFontHeaderFile(stdout);
		break;
	    case 'C':			// create header file
	    {
		FILE *out;

		if (!(out = fopen(optarg, "w"))) {
		    fprintf(stderr, "Can't open file '%s': %s\n", optarg,
			strerror(errno));
		    exit(-1);
		}
		CreateFontHeaderFile(out);
		fclose(out);
	    }
		continue;
	    case 'n':
		name = optarg;
		continue;
	    case 'O':
		Outline = 1;
		continue;

	    case EOF:
		break;
	    case '?':
	    case 'h':			// help usage
		PrintVersion();
		PrintUsage();
		exit(0);
	    case '-':
		fprintf(stderr, "We need no long options\n");
		PrintUsage();
		exit(-1);
	    case ':':
		PrintVersion();
		fprintf(stderr, "Missing argument for option '%c'\n", optopt);
		exit(-1);
	    default:
		PrintVersion();
		fprintf(stderr, "Unkown option '%c'\n", optopt);
		exit(-1);
	}
	break;
    }
    while (optind < argc) {
	fprintf(stderr, "Unhandled argument '%s'\n", argv[optind++]);
    }

    return 0;
}