/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Viskov Nikolay 
 */

#include <stdio.h>
#include <string>
#include <string.h>
#include <stdlib.h>
#if defined(LINUX)
#include <ctype.h>
#endif
#include "T1Font.h"
#include "T1Glyph.h"

T1Font::T1Font(fwchar_t *family, StyleName sn, fchar* pathToFile):Font() {
	//this->_famName = family;
	_style = sn;   

    fullName = NULL;

	FILE *inputFile;

	if( inputFile = fopen(pathToFile, "rb")) {	

		try {
			initFont(inputFile);
		} catch (fchar*) {
			//printf("%s", str);
		} 
		
		fclose(inputFile);	

        //set default ascent and descent
        _ascent = 649;
        _descent = 195;


        fchar path[MAX_STR_LENGTH];
        size_t length = strlen(pathToFile) - 3;

        strncpy(path, pathToFile, length);
        strcpy(path + length, "afm");        

        if( inputFile = fopen(path, "rb")) {

		    try {
			    parseAFM(inputFile);
		    } catch (...) {
			    //printf("%s", str);
		    } 
    		
		    fclose(inputFile);
	    }

	}

}

T1Font::~T1Font(void) {

	for( Type1Map::iterator iter = subrsMap.begin(); iter != subrsMap.end(); iter++ ) {		
		delete iter->second;		
	}

	for( Type1Map::iterator iter = charStringMap.begin(); iter != charStringMap.end(); iter++ ) {		
		delete iter->second;		
	}

    /*for( Type1AFMMap::iterator iter = afmMap.begin(); iter != afmMap.end(); iter++ ) {		
		delete[] iter->second;		
	}*/

    delete fullName;
}

Glyph* T1Font::createGlyph(ufshort unicode, ufshort size) {    

    /*ffloat floatMas[4];
    
    Type1AFMMap::iterator iter = afmMap.find(unicode); 

    //return iter == glyphCodeMap.end()? NULL : (ufshort)iter->second;

    memcpy(floatMas, _boundingBox, 4 * sizeof(ffloat));    

    if (iter != afmMap.end()) {
        //printf("%s\n", iter->second);
        fchar* curValue = strstr( iter->second, " B ");
        if (curValue != NULL) {

            curValue += 3; 

            floatMas[0] = (ffloat) atof(curValue);
            //printf("0 = %f\n", floatMas[0]);

            while (*(++curValue) != ' ') {
			}

            floatMas[1] = (ffloat) atof(curValue);
            //printf("1 = %f\n", floatMas[1]);

            while (*(++curValue) != ' ') {
			}

            floatMas[2] = (ffloat) atof(curValue);           
            //printf("2 = %f\n", floatMas[2]);

            while (*(++curValue) != ' ') {
			}

            floatMas[3] = (ffloat) atof(curValue);
            //printf("3 = %f\n", floatMas[3]);
        }
    }*/

    Glyph *glyph = new T1Glyph(&(this->charStringMap), &(this->subrsMap), unicode, size, size / matrixScale, _boundingBox);
	
	return glyph;
}

//TODO: owerwrite this:
fwchar_t* T1Font::getPSName() {
	return fullName;
}

ffloat* T1Font::getLineMetrics() {
    /*
     * metrics[0] - ascent<p>
     * metrics[1] - descent<p>
     * metrics[2] - external leading<p>
     * metrics[3] - underline thickness<p>
     * metrics[4] - underline offset<p>
     * metrics[5] - strikethrough thickness<p>
     * metrics[6] - strikethrough offset<p>
     * metrics[7] - maximum fchar width<p>*/

    ffloat* floatMas = new ffloat[FONT_METRICS_QUANTITY];

    floatMas[0] = _ascent / matrixScale; //ascent
    floatMas[1] = _descent / matrixScale; //descent
    floatMas[2] = (_height - _ascent - _descent) / matrixScale;//_externalLeading;

	floatMas[3] = _underlineThickness / matrixScale;
	floatMas[4] = _underlineOffset / matrixScale;
	
    floatMas[5] = _underlineThickness / matrixScale;//_strikeOutSize;
	floatMas[6] = -_ascent/(2 * matrixScale);//_strikeOutOffset;

	floatMas[7] = ((ffloat)(_boundingBox[3] - _boundingBox[1])) / matrixScale;
	
	return floatMas;
}

bool T1Font::canDisplay(ufshort ch) {    
	return this->charStringMap.find(ch) != this->charStringMap.end();
}

ufshort T1Font::getUnicodeByIndex(ufshort index) {
    Type1GlyphCodeMap::iterator iter = glyphCodeMap.find(index); 

    return iter == glyphCodeMap.end()? 0 : (ufshort)iter->second;
}

void error(){
	//printf("invalidfont");
	throw "invalidfont";
}

inline ufshort hexCharToUShort(fchar ch){
	return  ch >= '0' && ch <= '9' ? ch - '0' :
			ch >= 'A' && ch <= 'F' ? ch - 'A' + 10 :
			ch >= 'a' && ch <= 'f' ? ch - 'a' + 10 :			
			0;   
}

void static getNextLine(fchar* str, FILE* font) {
	ufshort count = 0;
	ufchar ch = ' ';

    while (!feof(font) && (ch == ' ' || ch == '\n' || ch == '\r')) {
        ch = getc(font);
	}

    str[count] = ch;
	while (!feof(font) && ch != '\r' && ch != '\n') {
		str[++count] = (ch = getc(font));
	}
	
	str[count] = '\0';
}

static ufchar getNextChar(FILE* font) {
	ufchar ch;	
	do {
		ch = getc(font);
	} while (ch == '\r' || ch == '\n');

	return ch;
}

static ufchar decryptNextSimbol(FILE* font, ufshort* r, bool isASCII) {
	ufchar clipher = (ufchar)(
		isASCII ? 
		(ufchar) ((hexCharToUShort(getNextChar(font)) << 4 ) + (hexCharToUShort(getNextChar(font)))) : 
		getc(font)
	);

	ufchar plain = (ufchar)(clipher ^ (*r >> 8));
	*r = ( (ufchar)clipher + *r ) * C1 + C2;	
	return plain;
}

void static decodeASCIILine(fchar* str, ufshort* r, ufshort n, ufshort length) {
	fchar* p = str;
	ufchar plain;
	ufchar clipher;
	ufshort count = 0;	
	length /= 2;	
	
	while(count < length) {
		clipher = (ufchar)((hexCharToUShort(*p) << 4 ) + (hexCharToUShort(*(p + 1))));

		plain = (ufchar)(clipher ^ (*r >> 8));
		*r = ( (ufchar)clipher + *r ) * C1 + C2;

		if (count >= n) {
			str[count - n] = plain;
		}

		count ++;

		p+= 2;
	}		
	str[count - n] = '\0';
}

void static decodeBinaryLine(fchar* str, ufshort* r, ufshort n, ufshort length) {
	fchar* p = str;
	ufchar plain;
	ufchar clipher;
	ufshort count = 0;		
	while(count < length) {
		clipher = (ufchar)*p;
		
		plain = (ufchar)(clipher ^ (*r >> 8));
		*r = ( (ufchar)clipher + *r ) * C1 + C2;

		if (count >= n) {
			str[count - n] = plain;
		}

		count ++;

		p ++;
	}		
	str[count - n] = '\0';
}

void static decodeLine(fchar* str, ufshort* r, ufshort n, bool isASCII, ufshort length) {

	if (isASCII) {
		decodeASCIILine(str,r,n,length);
	} else {
		decodeBinaryLine(str,r,n,length);
	}
	return;
	/*fchar* p = str;
	ufchar plain;
	ufchar clipher;
	ufshort count = 0;	
	if (isASCII) {
		length /= 2;	
	}
	while(count < length) {
		clipher = (ufchar)(isASCII ? ((hexCharToUShort(*p) << 4 ) + (hexCharToUShort(*(p + 1)))) : *p);

		plain = (ufchar)(clipher ^ (*r >> 8));
		*r = ( (ufchar)clipher + *r ) * C1 + C2;

		//printf("%u ---- %u,%u\n", clipher, plain, *r);
		if (count >= n) {
			str[count - n] = plain;
		}

		count ++;

		p+= isASCII ? 2 : 1;
	}		
	str[count - n] = '\0';//*/
}

void static getNextDecodeLine(fchar* str, FILE* font, ufshort* r, bool isASCII) {
	ufshort count = 0;
	ufchar plain;
	while(!feof(font)) {		
		plain = decryptNextSimbol(font, r, isASCII);

		str[count ++] = plain;		

		if (plain == '\r' || plain == '\n') {
			break;		
		}
	}		
	
	str[count] = '\0';
}

void static getNextDecodeLexeme(fchar* str, FILE* font, ufshort* r, bool isASCII) {
	ufchar ch;
	ufshort count = 0;

	while (!feof(font) && ((ch = decryptNextSimbol(font, r, isASCII)) == ' ' || ch == '\n' || ch == '\r')) {
	}

	str[count ++] = ch;	
	while (!feof(font) && (ch = decryptNextSimbol(font, r, isASCII)) != ' ' && ch != '\n' && ch != '\r') {
		str[count ++] = ch;
	}

	str[count] = '\0';	
}

void static getNextLexeme(fchar* str, FILE* font) {
	ufchar ch;
	ufshort count = 0;

	while (!feof(font) && ((ch = getc(font)) == ' ' || ch == '\n' || ch == '\r' && ch != '{')) {
	}

	str[count ++] = ch;	
    while (!feof(font) && (ch = getc(font)) != ' ' && ch != '\n' && ch != '\r' && ch != '{') {
		str[count ++] = ch;
	}

	str[count] = '\0';	
}

ufshort static findUnicode(const fchar *str) {
	
	ufshort count = 0;
	ufshort strCount = 0;
	ufshort lastStrCount = 0;

	while(true) {
		if (GLYPH_LIST[count] == str[strCount]) {
			count ++;
			strCount ++;
			//next iteration				
		} else if ((GLYPH_LIST[count] ^ (1 << 7)) == str[strCount]) {
			strCount ++;
			if (str[strCount] == '\0') {
				return (ufshort)((GLYPH_LIST[count + 1] << 8) + GLYPH_LIST[count + 2]);
			}

			count = ((GLYPH_LIST[count + 5] << 8) + GLYPH_LIST[count + 6]);

			lastStrCount = strCount;

			if (!count) {
				return FONT_NOT_FOUND_UNICODE_VALUE;
			}

			//on next level
		} else {
			strCount = lastStrCount;

			for (;!(GLYPH_LIST[count] & (1 << 7)) ; ) {
				count ++;
			}

			count = ((GLYPH_LIST[count + 3] << 8) + GLYPH_LIST[count + 4]);

			if (!count) {
				return FONT_NOT_FOUND_UNICODE_VALUE;
			}

			//next on this level
		}
	}
}

ufshort static getUnicode(fchar *name) {
	if (!strncmp(name, ".notdef", 7)) {
		return 0;	
	}

	return findUnicode(name);
}

void T1Font::parseAFM(FILE *font) {
    fchar curStr[MAX_STR_LENGTH];

    while (!feof(font)) {
        getNextLexeme(curStr, font);
        //printf("%s\n",curStr);

        if (!strcmp(curStr, "EndFontMetrics") || !strcmp(curStr, "StartCharMetrics")) {

            return;
        } else if (!strcmp(curStr, "Ascender")) {
            getNextLexeme(curStr, font);
            _ascent = (ffloat) fabs(atof(curStr));
            //printf("ascend = %f\n", _ascent);
            
        } else if (!strcmp(curStr, "Descender")) {
            getNextLexeme(curStr, font);
            _descent = (ffloat) fabs(atof(curStr));
            //printf("descent = %f\n", _descent);
            
        } /*else if (!strcmp(curStr, "StartCharMetrics")) {
            getNextLexeme(curStr, font);            
            fchar* curValue;
            fchar psName[MAX_STR_LENGTH];
            ufshort count = (ufshort) atoi(curStr);
            for (ufshort i = 0; i < count; i ++) {
                getNextLine(curStr, font);

                //printf("%s\n",curStr);
                curValue = strstr( curStr, " N ");
                if (curValue != NULL) {

                    curValue += 3;

                    //printf("%s\n", curValue);
                    
                    ufshort i;
                    for (i = 0; curValue[i] != ' ' && curValue[i] != '\0'; i ++) {
                        psName[i] = curValue[i];
                    }
                    psName[i] = '\0';                    

                    curValue = new fchar[strlen(curStr) + 1]; 

                    strcpy(curValue, curStr);

                    //printf("%u = %s = %s\n",findUnicode(psName),curValue,psName);

				    afmMap[getUnicode(psName)] = curValue;
                }
            }
            
        }*/ else {
            getNextLine(curStr, font);
        }
    }
}


void T1Font::initFont(FILE *font) {
	fchar curStr[MAX_STR_LENGTH];

	DecodeState state = HEADER;

	ufshort r = DEF_R_EXEC;
	ufshort n = 4;

	ufshort lenIV = DEF_LENIV;	
	ufshort charStringR;	

	ufshort count = 0;
	ufshort tempShort = 0;
	ufshort length = 0;
	ufshort valueLength = 0;

    matrixScale = 1000;

	bool isASCII = true;

	ufchar ch;	
	EncodedValue *curValue;

	ch = getc(font);

	if (ch == 0x80 && getc(font) == 0x01) {
		isASCII = false;	
	} else if (ch == '%' && getc(font) == '!') {
		isASCII = true;	
	} else {
		error();	
	}	

	while (!feof(font)) {
		switch (state) {
		case HEADER: {
			getNextLexeme(curStr, font);

            if (!strcmp(curStr, "/UnderlinePosition")) {
                getNextLexeme(curStr, font);
                _underlineOffset = (ffloat) - atof(curStr);
		    } else if (!strcmp(curStr, "/UnderlineThickness")) {
                getNextLexeme(curStr, font);
                _underlineThickness = (ffloat) atof(curStr);			
		    } else if (strstr(curStr, "/FontBBox") != NULL) {
                //getNextLexeme(curStr, font);

                while (!feof(font) && ((ch = getc(font)) == '{')) {
				}

                ungetc(ch, font);

                getNextLexeme(curStr, font);
                _boundingBox[0] = (ffloat) atof(curStr);

                getNextLexeme(curStr, font);
                _boundingBox[1] = (ffloat) atof(curStr);

                getNextLexeme(curStr, font);
                _boundingBox[2] = (ffloat) atof(curStr);

                getNextLexeme(curStr, font);                
                _boundingBox[3] = (ffloat) atof(curStr);

                _height = ((ffloat)(_boundingBox[2] -_boundingBox[0]));

		    } else if (!strcmp(curStr, "/FullName")) {
                //getNextLexeme(curStr, font);                

				while (!feof(font) && ((ch = getc(font)) == '(')) {
				}

				curStr[count ++] = ch;	
				while (!feof(font) && (ch = getc(font)) != ')') {
					curStr[count ++] = ch;
				}

				curStr[count] = '\0';	

				fchar *ptr = curStr;

				ch = 0;
				fullName = new fwchar_t[count + 1];
				while (*ptr != '\0') {
					fullName[ch ++] = *ptr;
					ptr ++;
				}

				fullName[ch] = L'\0';
		    } else if (!strcmp(curStr, "eexec")) {
				state = PRIVATE_DIR;			
			
				if (isASCII) {
					for (count = 0; count < lenIV * 2; count ++) {
						if (!isascii(ch = getc(font))) {
							error();					
						}					
						curStr[count] = ch;
					}
					decodeASCIILine(curStr, &r, n, count);
				} else {
					for (count = 0; count < 6; count ++) {					
						curStr[count] = getc(font);
					}
					
					if (curStr[0] != (fchar)0x80 || curStr[1] != 0x02) {
						error();
					}
					for (count = 0; count < lenIV; count ++) {
						curStr[count] = getc(font);
					}
					decodeBinaryLine(curStr, &r, n, count);
				}
			}
			break;			
		}
		case PRIVATE_DIR: {
			getNextDecodeLexeme(curStr, font, &r, isASCII);
			
			if (!strcmp(curStr, "/Subrs")) {

				getNextDecodeLexeme(curStr, font, &r, isASCII);
				valueLength = atoi(curStr);
				
				count = 0;
				state = SUBRS_MASSIVE;	 
				getNextDecodeLine(curStr, font, &r, isASCII);
			} else if (!strcmp(curStr, "/CharStrings")) {

				getNextDecodeLexeme(curStr, font, &r, isASCII);
				valueLength = atoi(curStr);		
				
				count = 0;
				state = CHAR_STRING;
				getNextDecodeLine(curStr, font, &r, isASCII);
			}
			break;
		}
		case SUBRS_MASSIVE: {			
			curValue = new EncodedValue();
			getNextDecodeLexeme(curStr, font, &r, isASCII);

			getNextDecodeLexeme(curStr, font, &r, isASCII);
			curValue->number = (ufshort) atoi(curStr);	

			getNextDecodeLexeme(curStr, font, &r, isASCII);
			length = (ufshort) atoi(curStr);
			curValue->length = length - lenIV;

			getNextDecodeLexeme(curStr, font, &r, isASCII);
			
			for (tempShort = 0; tempShort - length < 0; tempShort ++) {
				curStr[tempShort] = decryptNextSimbol(font, &r, isASCII);
			}

			charStringR = DEF_R_CHARSTRING;
			decodeBinaryLine(curStr, &charStringR, lenIV, length);

			curValue->text = new fchar[curValue->length];
			for (tempShort = 0; tempShort - curValue->length < 0; tempShort ++) {
				curValue->text[tempShort] = curStr[tempShort];
			}

			subrsMap[curValue->number] = curValue;

			getNextDecodeLine(curStr, font, &r, isASCII);

			if (++count >= valueLength) {
				state = PRIVATE_DIR;
				count = 0;
			}
			
			break;
		}
		case CHAR_STRING: {
			getNextDecodeLexeme(curStr, font, &r, isASCII);
			tempShort = getUnicode(curStr + 1);

			if (tempShort != FONT_NOT_FOUND_UNICODE_VALUE) {

                glyphCodeMap[count] = tempShort;

				curValue = new EncodedValue(); 

				curValue->number = tempShort;

				getNextDecodeLexeme(curStr, font, &r, isASCII);
				length = (ufshort) atoi(curStr);
				curValue->length = length - lenIV;	

				getNextDecodeLexeme(curStr, font, &r, isASCII);
				for (tempShort = 0; tempShort - length < 0; tempShort ++) {
					curStr[tempShort] = decryptNextSimbol(font, &r, isASCII);
				}

				charStringR = DEF_R_CHARSTRING;
				decodeBinaryLine(curStr, &charStringR, lenIV, length);

				curValue->text = new fchar[curValue->length];
				for (tempShort = 0; tempShort - curValue->length < 0; tempShort ++) {
					curValue->text[tempShort] = curStr[tempShort];
				}
				charStringMap[curValue->number] = curValue;
			} else {
				getNextDecodeLexeme(curStr, font, &r, isASCII);
				length = (ufshort) atoi(curStr);							

				getNextDecodeLexeme(curStr, font, &r, isASCII);
				for (tempShort = 0; tempShort - length < 0; tempShort ++) {
					decryptNextSimbol(font, &r, isASCII);
				}
			}			

			getNextDecodeLine(curStr, font, &r, isASCII);

			if (++count >= valueLength) {
				return;		
			}
			
			break;
		}
	}
	}
}