/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "glk/alan3/sysdep.h"
#include "glk/alan3/alan3.h"
#include "glk/alan3/glkio.h"
#include "glk/alan3/syserr.h"

namespace Glk {
namespace Alan3 {

/* Note to Glk maintainers: 'native' characters are used for output, in this
   case, Glk's Latin-1.  ISO characters are Alan's internal representation,
   stored in the .A3C file, and must be converted to native before printing.
   Glk could just use the ISO routines directly, but its safer to maintain
   its own tables to guard against future changes in either Alan or Glk (ie. a
   move to Unicode).
 */

static const byte spaceCharacters[] = {
	0x0A, /* linefeed */
	0x20, /* space */
	0xA0, /* non-breaking space */
	0x00
};

static const byte lowerCaseCharacters[] = {
	0x61, /* a */  0x62, /* b */  0x63, /* c */  0x64, /* d */
	0x65, /* e */  0x66, /* f */  0x67, /* g */  0x68, /* h */
	0x69, /* i */  0x6A, /* j */  0x6B, /* k */  0x6C, /* l */
	0x6D, /* m */  0x6E, /* n */  0x6F, /* o */  0x70, /* p */
	0x71, /* q */  0x72, /* r */  0x73, /* s */  0x74, /* t */
	0x75, /* u */  0x76, /* v */  0x77, /* w */  0x78, /* x */
	0x79, /* y */  0x7A, /* z */  0xDF, /* ss <small sharp s> */
	0xE0, /* a grave */           0xE1, /* a acute */
	0xE2, /* a circumflex */      0xE3, /* a tilde */
	0xE4, /* a diaeresis */       0xE5, /* a ring */
	0xE6, /* ae */                0xE7, /* c cedilla */
	0xE8, /* e grave */           0xE9, /* e acute */
	0xEA, /* e circumflex */      0xEB, /* e diaeresis */
	0xEC, /* i grave */           0xED, /* i acute */
	0xEE, /* i circumflex */      0xEF, /* i diaeresis */
	0xF0, /* <small eth> */       0xF1, /* n tilde */
	0xF2, /* o grave */           0xF3, /* o acute */
	0xF4, /* o circumflex */      0xF5, /* o tilde */
	0xF6, /* o diaeresis */       0xF8, /* o slash */
	0xF9, /* u grave */           0xFA, /* u acute */
	0xFB, /* u circumflex */      0xFC, /* u diaeresis */
	0xFD, /* y acute */           0xFE, /* <small thorn> */
	0xFF, /* y diaeresis */       0x00
};

/* FIXME: ss <small sharp s> and y diaeresis have no UC analogues
   Are they really considered LC?
 */

static const byte upperCaseCharacters[] = {
	0x41, /* A */  0x42, /* B */  0x43, /* C */  0x44, /* D */
	0x45, /* E */  0x46, /* F */  0x47, /* G */  0x48, /* H */
	0x49, /* I */  0x4A, /* J */  0x4B, /* K */  0x4C, /* L */
	0x4D, /* M */  0x4E, /* N */  0x4F, /* O */  0x50, /* P */
	0x51, /* Q */  0x52, /* R */  0x53, /* S */  0x54, /* T */
	0x55, /* U */  0x56, /* V */  0x57, /* W */  0x58, /* X */
	0x59, /* Y */  0x5A, /* Z */
	0xC0, /* A grave */           0xC1, /* A acute */
	0xC2, /* A circumflex */      0xC3, /* A tilde */
	0xC4, /* A diaeresis */       0xC5, /* A ring */
	0xC6, /* AE */                0xC7, /* C cedilla */
	0xC8, /* E grave */           0xC9, /* E acute */
	0xCA, /* E circumflex */      0xCB, /* E diaeresis */
	0xCC, /* I grave */           0xCD, /* I acute */
	0xCE, /* I circumflex */      0xCF, /* I diaeresis */
	0xD0, /* <capital eth> */     0xD1, /* N tilde */
	0xD2, /* O grave */           0xD3, /* O acute */
	0xD4, /* O circumflex */      0xD5, /* O tilde */
	0xD6, /* O diaeresis */       0xD8, /* O slash */
	0xD9, /* U grave */           0xDA, /* U acute */
	0xDB, /* U circumflex */      0xDC, /* U diaeresis */
	0xDD, /* Y acute */           0xDE, /* <capital thorn> */
	0x00
};


int isSpace(unsigned int c) {
	return (c != '\0' && strchr((const char *)spaceCharacters, c) != nullptr);
}


int isLower(unsigned int c) {
	return (c != '\0' && strchr((const char *)lowerCaseCharacters, c) != nullptr);
}


int isUpper(unsigned int c) {
	return (c != '\0' && strchr((const char *)upperCaseCharacters, c) != nullptr);
}

int isLetter(unsigned int c) {
	return (c != '\0' && (isLower(c) ? !0 : isUpper(c)));
}


int toLower(unsigned int c) {
	return g_vm->glk_char_to_lower(c);
}

int toUpper(unsigned int c) {
	return g_vm->glk_char_to_upper(c);
}

char *strlow(char str[]) {
	char *s;

	for (s = str; *s; s++)
		*s = toLower(*s);
	return (str);
}


char *strupp(char str[]) {
	char *s;

	for (s = str; *s; s++)
		*s = toUpper(*s);
	return (str);
}


/* The following work on ISO characters */

int isLowerCase(unsigned int c) {
	uint i;
	for (i = 0; i < strlen((const char *)lowerCaseCharacters); i++)
		if (((unsigned int)lowerCaseCharacters[i]) == c) return 1;
	return 0;
}


int isUpperCase(unsigned int c) {
	uint i;
	for (i = 0; i < strlen((const char *)upperCaseCharacters); i++)
		if (upperCaseCharacters[i] == c) return 1;
	return 0;
}


int isISOLetter(int c) {
	return (isLowerCase(c) || isUpperCase(c));
}


char IsoToLowerCase(int c) {
	return (isUpperCase(c) ? c + ('a' - 'A') : c);
}


char IsoToUpperCase(int c) {
	return (isLowerCase(c) ? c - ('a' - 'A') : c);
}


char *stringLower(char str[]) {
	char *s;

	for (s = str; *s; s++)
		*s = IsoToLowerCase(*s);
	return (str);
}


char *stringUpper(char str[]) {
	char *s;

	for (s = str; *s; s++)
		*s = IsoToUpperCase(*s);
	return (str);
}

/*----------------------------------------------------------------------*/
int compareStrings(char *str1, char *str2) {
	char *s1 = str1, *s2 = str2;

	while (*s1 != '\0' && *s2 != '\0') {
		if (IsoToLowerCase(*s1) < IsoToLowerCase(*s2)) return -1;
		if (IsoToLowerCase(*s1) > IsoToLowerCase(*s2)) return 1;
		s1++;
		s2++;
	}
	return IsoToLowerCase(*s2) - IsoToLowerCase(*s1);
}


#if 0

/*----------------------------------------------------------------------
  toIso

  Converts the incoming string to ISO character set. The original is
  in the current character set which in the case of the compiler might
  be other than the native.

  */
void toIso(char copy[], /* OUT - Mapped  string */
		   char original[], /* IN - string to convert */
		   int charset) {   /* IN - the current character set */
	static const unsigned char macMap[256]
	= {
		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0A, 0x0E, 0x0F,
		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
		0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
		0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
		0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
		0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
		0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
		0xC4, 0xC5, 0xC7, 0xC9, 0xD1, 0xD6, 0xDC, 0xE1, 0xE0, 0xE2, 0xE4, 0xE3, 0xE5, 0xE7, 0xE9, 0xE8,
		0xEA, 0xEB, 0xED, 0xEC, 0xEE, 0xEF, 0xF1, 0xF3, 0xF2, 0xF4, 0xF6, 0xF5, 0xFA, 0xF9, 0xFB, 0xFC,
		0xB9, 0xB0, 0xA2, 0xA3, 0xA7, 0xB7, 0xB6, 0xDF, 0xAE, 0xA9, 0xB2, 0xB4, 0xA8, 0xD7, 0xC6, 0xD8,
		0xA4, 0xB1, 0xCD, 0xCC, 0xA5, 0xB5, 0xF0, 0xCA, 0xDE, 0xFE, 0xA6, 0xAA, 0xBA, 0xD4, 0xE6, 0xF8,
		0xBF, 0xA1, 0xAC, 0xCE, 0xCF, 0xC8, 0xD0, 0xAB, 0xBB, 0xCB, 0xA0, 0xC0, 0xC3, 0xD5, 0xDD, 0xFD,
		0xAD, 0xAF, 0xDA, 0xD9, 0xB8, 0xB3, 0xF7, 0xC2, 0xFF, 0xBC, 0xBD, 0xBE, 0xC1, 0xD2, 0xD3, 0xDB,
		0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F
	};

	static const unsigned char dosMap[256]
	= {
		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0A, 0x0E, 0x0F,
		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
		0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
		0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
		0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
		0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
		0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
		0xC7, 0xFC, 0xE9, 0xE2, 0xE4, 0xE0, 0xE5, 0xE7, 0xEA, 0xEB, 0xE8, 0xEF, 0xEE, 0xEC, 0xC4, 0xC5,
		0xC9, 0xE6, 0xC6, 0xF4, 0xF6, 0xF2, 0xFB, 0xF9, 0xFF, 0xD6, 0xDC, 0xA2, 0xA3, 0xA5, 0xDE, 0xA6,
		0xE1, 0xED, 0xF3, 0xFA, 0xF1, 0xD1, 0xAA, 0xBA, 0xBF, 0xC0, 0xC1, 0xBD, 0xBC, 0xCF, 0xAB, 0xBB,
		0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
		0xA1, 0xA7, 0xAD, 0xB3, 0xB8, 0xB9, 0xC3, 0xCE, 0xD2, 0xD3, 0xDB, 0xDD, 0xE3, 0xF5, 0xF8, 0xFD,
		0xA9, 0xDF, 0xC8, 0xB6, 0xCA, 0xA4, 0xB5, 0xAE, 0xD5, 0xD0, 0xD4, 0xF0, 0xD7, 0xD8, 0xCB, 0xC2,
		0xBE, 0xB1, 0xD9, 0xDA, 0xCD, 0xCC, 0xF7, 0xA8, 0xB0, 0xB7, 0xAF, 0xAC, 0xFE, 0xB2, 0xB4, 0xA0
	};
	unsigned char *o, *c;

	switch (charset) {
	case 0: /* ISO */
		if (copy != original)
			(void)strcpy(copy, original);
		break;
	case 1:           /* Mac */
		for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++)
			*c = macMap[*o];
		*c = '\0';
		break;

	case 2:           /* Dos */
		for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++)
			*c = dosMap[*o];
		*c = '\0';
		break;

	default:
		break;
	}
}

/*----------------------------------------------------------------------

  fromIso

  Converts a string from global Iso format to native. Only used in
  interpreter so character set is known at compile time.

  */
void fromIso(char copy[], char original[]) {
	if (copy != original)
		(void)strcpy(copy, original);
}


/*----------------------------------------------------------------------
  toNative

  Converts the incoming string to the native character set from any of
  the others. The original is in the current character set which in
  the case of the compiler might be other than the native.
  copy - Mapped  string
  original - string to convert
  charset - the current character set
  */
void toNative(char copy[], char original[], int charset) {
	toIso(copy, original, charset);
	if (NATIVECHARSET != 0)
		fromIso(copy, copy);
}

#endif


/*======================================================================*/
char *baseNameStart(char *fullPathName) {
	const char *delimiters = "\\>]/:";
	int i;

	for (i = strlen(fullPathName) - 1; i > 0; i--)
		if (strchr(delimiters, fullPathName[i]) != nullptr)
			return &fullPathName[i + 1];
	return (fullPathName);
}

} // End of namespace Alan3
} // End of namespace Glk
