/* 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 "common/textconsole.h"
#include "ags/lib/allegro/unicode.h"
#include "ags/globals.h"

namespace AGS3 {

/* ugetc: */
int (*ugetc)(const char *s) = utf8_getc;
/* ugetxc: */
int (*ugetx)(char **s) = utf8_getx;
/* ugetxc: */
int (*ugetxc)(const char * const *s) = (int (*)(const char * const *)) utf8_getx;
/* usetc: */
int (*usetc)(char *s, int c) = utf8_setc;
/* uwidth: */
int (*uwidth)(const char *s) = utf8_width;
/* ucwidth: */
int (*ucwidth)(int c) = utf8_cwidth;
/* uisok: */
int (*uisok)(int c) = utf8_isok;

struct UTYPE_INFO {
	int id;
	AL_METHOD(int, u_getc, (const char *s));
	AL_METHOD(int, u_getx, (char **s));
	AL_METHOD(int, u_setc, (char *s, int c));
	AL_METHOD(int, u_width, (const char *s));
	AL_METHOD(int, u_cwidth, (int c));
	AL_METHOD(int, u_isok, (int c));
	int u_width_max;
};

static UTYPE_INFO utypes[] =
{
	{ U_ASCII,    ascii_getc,    ascii_getx,    ascii_setc,    ascii_width,   ascii_cwidth,   ascii_isok,    1    },
	{ U_UTF8,     utf8_getc,     utf8_getx,     utf8_setc,     utf8_width,    utf8_cwidth,    utf8_isok,     4     }
};


/* _find_utype:
 *  Helper for locating a string type description.
 */
static UTYPE_INFO *find_utype(int type) {
	int i;

	if (type == U_CURRENT)
		type = _G(utype);

	for (i = 0; i < (int)(sizeof(utypes) / sizeof(UTYPE_INFO)); i++)
		if (utypes[i].id == type)
			return &utypes[i];

	return nullptr;
}

void set_uformat(int type) {
	UTYPE_INFO *info = find_utype(type);
	assert(info);

	if (info) {
		_G(utype) = info->id;
		ugetc = info->u_getc;
		ugetx = (int (*)(char **)) info->u_getx;
		ugetxc = (int (*)(AL_CONST char * const*)) info->u_getx;
		usetc = info->u_setc;
		uwidth = info->u_width;
		ucwidth = info->u_cwidth;
		uisok = info->u_isok;
	}
}

int get_uformat(void) {
	return _G(utype);
}

size_t ustrsize(const char *s) {
	return strlen(s);
}

static int utf8_validate(int c) {
	if (c < 0 || c > 0x10FFFF || (0xD800 <= c && c <= 0xDFFF))
		return 0xFFFD;
	return c;
}

int utf8_getc(const char *s) {
	int c = *((const unsigned char *)(s++));
	int n, t;

	if (c & 0x80) {
		n = 1;
		while (c & (0x80 >> n))
			n++;

		c &= (1 << (8 - n)) - 1;

		while (--n > 0) {
			t = *((const unsigned char *)(s++));

			if ((!(t & 0x80)) || (t & 0x40))
				return '^';

			c = (c << 6) | (t & 0x3F);
		}
	}

	return utf8_validate(c);
}

int utf8_getx(char **s) {
	int c = *((unsigned char *)((*s)++));
	int n, t;

	if (c & 0x80) {
		n = 1;
		while (c & (0x80 >> n))
			n++;

		c &= (1 << (8 - n)) - 1;

		while (--n > 0) {
			t = *((unsigned char *)((*s)++));

			if ((!(t & 0x80)) || (t & 0x40)) {
				(*s)--;
				return '^';
			}

			c = (c << 6) | (t & 0x3F);
		}
	}

	return utf8_validate(c);
}

int utf8_setc(char *s, int c) {
	int size, bits, b, i;

	c = utf8_validate(c);
	if (c < 128) {
		*s = c;
		return 1;
	}

	bits = 7;
	while (c >= (1 << bits))
		bits++;

	size = 2;
	b = 11;

	while (b < bits) {
		size++;
		b += 5;
	}

	b -= (7 - size);
	s[0] = c >> b;

	for (i = 0; i < size; i++)
		s[0] |= (0x80 >> i);

	for (i = 1; i < size; i++) {
		b -= 6;
		s[i] = 0x80 | ((c >> b) & 0x3F);
	}

	return size;
}

int utf8_width(const char *s) {
	int c = *((const unsigned char *)s);
	int n = 1;

	if (c & 0x80) {
		while (c & (0x80 >> n))
			n++;
	}

	return n;
}

int utf8_cwidth(int c) {
	int size, bits, b;

	c = utf8_validate(c);
	if (c < 128)
		return 1;

	bits = 7;
	while (c >= (1 << bits))
		bits++;

	size = 2;
	b = 11;

	while (b < bits) {
		size++;
		b += 5;
	}

	return size;
}

int utf8_isok(int c) {
	return utf8_validate(c) == c;
}


int ascii_getc(const char *s) {
	return *((const unsigned char *)s);
}

int ascii_getx(char **s) {
	return *((unsigned char *)((*s)++));
}

int ascii_setc(char *s, int c) {
	*s = c;
	return 1;
}

int ascii_width(const char *s) {
	return 1;
}

int ascii_cwidth(int c) {
	return 1;
}

int ascii_isok(int c) {
	return ((c >= 0) && (c <= 255));
}



int ustrlen(const char *s) {
	int c = 0;
	assert(s);

	while (ugetxc(&s))
		c++;

	return c;
}

int utolower(int c) {
	if ((c >= 65 && c <= 90) ||
		(c >= 192 && c <= 214) ||
		(c >= 216 && c <= 222) ||
		(c >= 913 && c <= 929) ||
		(c >= 931 && c <= 939) ||
		(c >= 1040 && c <= 1071))
		return c + 32;
	if ((c >= 393 && c <= 394))
		return c + 205;
	if ((c >= 433 && c <= 434))
		return c + 217;
	if ((c >= 904 && c <= 906))
		return c + 37;
	if ((c >= 910 && c <= 911))
		return c + 63;
	if ((c >= 1025 && c <= 1036) ||
		(c >= 1038 && c <= 1039))
		return c + 80;
	if ((c >= 1329 && c <= 1366) ||
		(c >= 4256 && c <= 4293))
		return c + 48;
	if ((c >= 7944 && c <= 7951) ||
		(c >= 7960 && c <= 7965) ||
		(c >= 7976 && c <= 7983) ||
		(c >= 7992 && c <= 7999) ||
		(c >= 8008 && c <= 8013) ||
		(c >= 8040 && c <= 8047) ||
		(c >= 8072 && c <= 8079) ||
		(c >= 8088 && c <= 8095) ||
		(c >= 8104 && c <= 8111) ||
		(c >= 8120 && c <= 8121) ||
		(c >= 8152 && c <= 8153) ||
		(c >= 8168 && c <= 8169))
		return c + -8;
	if ((c >= 8122 && c <= 8123))
		return c + -74;
	if ((c >= 8136 && c <= 8139))
		return c + -86;
	if ((c >= 8154 && c <= 8155))
		return c + -100;
	if ((c >= 8170 && c <= 8171))
		return c + -112;
	if ((c >= 8184 && c <= 8185))
		return c + -128;
	if ((c >= 8186 && c <= 8187))
		return c + -126;
	if ((c >= 8544 && c <= 8559))
		return c + 16;
	if ((c >= 9398 && c <= 9423))
		return c + 26;

	switch (c) {
	case 256:
	case 258:
	case 260:
	case 262:
	case 264:
	case 266:
	case 268:
	case 270:
	case 272:
	case 274:
	case 276:
	case 278:
	case 280:
	case 282:
	case 284:
	case 286:
	case 288:
	case 290:
	case 292:
	case 294:
	case 296:
	case 298:
	case 300:
	case 302:
	case 306:
	case 308:
	case 310:
	case 313:
	case 315:
	case 317:
	case 319:
	case 321:
	case 323:
	case 325:
	case 327:
	case 330:
	case 332:
	case 334:
	case 336:
	case 338:
	case 340:
	case 342:
	case 344:
	case 346:
	case 348:
	case 350:
	case 352:
	case 354:
	case 356:
	case 358:
	case 360:
	case 362:
	case 364:
	case 366:
	case 368:
	case 370:
	case 372:
	case 374:
	case 377:
	case 379:
	case 381:
	case 386:
	case 388:
	case 391:
	case 395:
	case 401:
	case 408:
	case 416:
	case 418:
	case 420:
	case 423:
	case 428:
	case 431:
	case 435:
	case 437:
	case 440:
	case 444:
	case 453:
	case 456:
	case 459:
	case 461:
	case 463:
	case 465:
	case 467:
	case 469:
	case 471:
	case 473:
	case 475:
	case 478:
	case 480:
	case 482:
	case 484:
	case 486:
	case 488:
	case 490:
	case 492:
	case 494:
	case 498:
	case 500:
	case 506:
	case 508:
	case 510:
	case 512:
	case 514:
	case 516:
	case 518:
	case 520:
	case 522:
	case 524:
	case 526:
	case 528:
	case 530:
	case 532:
	case 534:
	case 994:
	case 996:
	case 998:
	case 1000:
	case 1002:
	case 1004:
	case 1006:
	case 1120:
	case 1122:
	case 1124:
	case 1126:
	case 1128:
	case 1130:
	case 1132:
	case 1134:
	case 1136:
	case 1138:
	case 1140:
	case 1142:
	case 1144:
	case 1146:
	case 1148:
	case 1150:
	case 1152:
	case 1168:
	case 1170:
	case 1172:
	case 1174:
	case 1176:
	case 1178:
	case 1180:
	case 1182:
	case 1184:
	case 1186:
	case 1188:
	case 1190:
	case 1192:
	case 1194:
	case 1196:
	case 1198:
	case 1200:
	case 1202:
	case 1204:
	case 1206:
	case 1208:
	case 1210:
	case 1212:
	case 1214:
	case 1217:
	case 1219:
	case 1223:
	case 1227:
	case 1232:
	case 1234:
	case 1236:
	case 1238:
	case 1240:
	case 1242:
	case 1244:
	case 1246:
	case 1248:
	case 1250:
	case 1252:
	case 1254:
	case 1256:
	case 1258:
	case 1262:
	case 1264:
	case 1266:
	case 1268:
	case 1272:
	case 7680:
	case 7682:
	case 7684:
	case 7686:
	case 7688:
	case 7690:
	case 7692:
	case 7694:
	case 7696:
	case 7698:
	case 7700:
	case 7702:
	case 7704:
	case 7706:
	case 7708:
	case 7710:
	case 7712:
	case 7714:
	case 7716:
	case 7718:
	case 7720:
	case 7722:
	case 7724:
	case 7726:
	case 7728:
	case 7730:
	case 7732:
	case 7734:
	case 7736:
	case 7738:
	case 7740:
	case 7742:
	case 7744:
	case 7746:
	case 7748:
	case 7750:
	case 7752:
	case 7754:
	case 7756:
	case 7758:
	case 7760:
	case 7762:
	case 7764:
	case 7766:
	case 7768:
	case 7770:
	case 7772:
	case 7774:
	case 7776:
	case 7778:
	case 7780:
	case 7782:
	case 7784:
	case 7786:
	case 7788:
	case 7790:
	case 7792:
	case 7794:
	case 7796:
	case 7798:
	case 7800:
	case 7802:
	case 7804:
	case 7806:
	case 7808:
	case 7810:
	case 7812:
	case 7814:
	case 7816:
	case 7818:
	case 7820:
	case 7822:
	case 7824:
	case 7826:
	case 7828:
	case 7840:
	case 7842:
	case 7844:
	case 7846:
	case 7848:
	case 7850:
	case 7852:
	case 7854:
	case 7856:
	case 7858:
	case 7860:
	case 7862:
	case 7864:
	case 7866:
	case 7868:
	case 7870:
	case 7872:
	case 7874:
	case 7876:
	case 7878:
	case 7880:
	case 7882:
	case 7884:
	case 7886:
	case 7888:
	case 7890:
	case 7892:
	case 7894:
	case 7896:
	case 7898:
	case 7900:
	case 7902:
	case 7904:
	case 7906:
	case 7908:
	case 7910:
	case 7912:
	case 7914:
	case 7916:
	case 7918:
	case 7920:
	case 7922:
	case 7924:
	case 7926:
	case 7928:
		return c + 1;
	case 304:
		return c + -199;
	case 376:
		return c + -121;
	case 385:
		return c + 210;
	case 390:
		return c + 206;
	case 398:
		return c + 79;
	case 399:
		return c + 202;
	case 400:
		return c + 203;
	case 403:
		return c + 205;
	case 404:
		return c + 207;
	case 406:
	case 412:
		return c + 211;
	case 407:
		return c + 209;
	case 413:
		return c + 213;
	case 415:
		return c + 214;
	case 422:
	case 425:
	case 430:
		return c + 218;
	case 439:
		return c + 219;
	case 452:
	case 455:
	case 458:
	case 497:
		return c + 2;
	case 902:
		return c + 38;
	case 908:
		return c + 64;
	case 8025:
	case 8027:
	case 8029:
	case 8031:
		return c + -8;
	case 8124:
	case 8140:
	case 8188:
		return c + -9;
	case 8172:
		return c + -7;
	default:
		return c;
	}
}

int utoupper(int c) {
	if ((c >= 97 && c <= 122) ||
		(c >= 224 && c <= 246) ||
		(c >= 248 && c <= 254) ||
		(c >= 945 && c <= 961) ||
		(c >= 963 && c <= 971) ||
		(c >= 1072 && c <= 1103))
		return c + -32;
	if ((c >= 598 && c <= 599))
		return c + -205;
	if ((c >= 650 && c <= 651))
		return c + -217;
	if ((c >= 941 && c <= 943))
		return c + -37;
	if ((c >= 973 && c <= 974))
		return c + -63;
	if ((c >= 1105 && c <= 1116) ||
		(c >= 1118 && c <= 1119))
		return c + -80;
	if ((c >= 1377 && c <= 1414))
		return c + -48;
	if ((c >= 7936 && c <= 7943) ||
		(c >= 7952 && c <= 7957) ||
		(c >= 7968 && c <= 7975) ||
		(c >= 7984 && c <= 7991) ||
		(c >= 8000 && c <= 8005) ||
		(c >= 8032 && c <= 8039) ||
		(c >= 8064 && c <= 8071) ||
		(c >= 8080 && c <= 8087) ||
		(c >= 8096 && c <= 8103) ||
		(c >= 8112 && c <= 8113) ||
		(c >= 8144 && c <= 8145) ||
		(c >= 8160 && c <= 8161))
		return c + 8;
	if ((c >= 8048 && c <= 8049))
		return c + 74;
	if ((c >= 8050 && c <= 8053))
		return c + 86;
	if ((c >= 8054 && c <= 8055))
		return c + 100;
	if ((c >= 8056 && c <= 8057))
		return c + 128;
	if ((c >= 8058 && c <= 8059))
		return c + 112;
	if ((c >= 8060 && c <= 8061))
		return c + 126;
	if ((c >= 8560 && c <= 8575))
		return c + -16;
	if ((c >= 9424 && c <= 9449))
		return c + -26;

	switch (c) {
	case 255:
		return c + 121;
	case 257:
	case 259:
	case 261:
	case 263:
	case 265:
	case 267:
	case 269:
	case 271:
	case 273:
	case 275:
	case 277:
	case 279:
	case 281:
	case 283:
	case 285:
	case 287:
	case 289:
	case 291:
	case 293:
	case 295:
	case 297:
	case 299:
	case 301:
	case 303:
	case 307:
	case 309:
	case 311:
	case 314:
	case 316:
	case 318:
	case 320:
	case 322:
	case 324:
	case 326:
	case 328:
	case 331:
	case 333:
	case 335:
	case 337:
	case 339:
	case 341:
	case 343:
	case 345:
	case 347:
	case 349:
	case 351:
	case 353:
	case 355:
	case 357:
	case 359:
	case 361:
	case 363:
	case 365:
	case 367:
	case 369:
	case 371:
	case 373:
	case 375:
	case 378:
	case 380:
	case 382:
	case 387:
	case 389:
	case 392:
	case 396:
	case 402:
	case 409:
	case 417:
	case 419:
	case 421:
	case 424:
	case 429:
	case 432:
	case 436:
	case 438:
	case 441:
	case 445:
	case 453:
	case 456:
	case 459:
	case 462:
	case 464:
	case 466:
	case 468:
	case 470:
	case 472:
	case 474:
	case 476:
	case 479:
	case 481:
	case 483:
	case 485:
	case 487:
	case 489:
	case 491:
	case 493:
	case 495:
	case 498:
	case 501:
	case 507:
	case 509:
	case 511:
	case 513:
	case 515:
	case 517:
	case 519:
	case 521:
	case 523:
	case 525:
	case 527:
	case 529:
	case 531:
	case 533:
	case 535:
	case 995:
	case 997:
	case 999:
	case 1001:
	case 1003:
	case 1005:
	case 1007:
	case 1121:
	case 1123:
	case 1125:
	case 1127:
	case 1129:
	case 1131:
	case 1133:
	case 1135:
	case 1137:
	case 1139:
	case 1141:
	case 1143:
	case 1145:
	case 1147:
	case 1149:
	case 1151:
	case 1153:
	case 1169:
	case 1171:
	case 1173:
	case 1175:
	case 1177:
	case 1179:
	case 1181:
	case 1183:
	case 1185:
	case 1187:
	case 1189:
	case 1191:
	case 1193:
	case 1195:
	case 1197:
	case 1199:
	case 1201:
	case 1203:
	case 1205:
	case 1207:
	case 1209:
	case 1211:
	case 1213:
	case 1215:
	case 1218:
	case 1220:
	case 1224:
	case 1228:
	case 1233:
	case 1235:
	case 1237:
	case 1239:
	case 1241:
	case 1243:
	case 1245:
	case 1247:
	case 1249:
	case 1251:
	case 1253:
	case 1255:
	case 1257:
	case 1259:
	case 1263:
	case 1265:
	case 1267:
	case 1269:
	case 1273:
	case 7681:
	case 7683:
	case 7685:
	case 7687:
	case 7689:
	case 7691:
	case 7693:
	case 7695:
	case 7697:
	case 7699:
	case 7701:
	case 7703:
	case 7705:
	case 7707:
	case 7709:
	case 7711:
	case 7713:
	case 7715:
	case 7717:
	case 7719:
	case 7721:
	case 7723:
	case 7725:
	case 7727:
	case 7729:
	case 7731:
	case 7733:
	case 7735:
	case 7737:
	case 7739:
	case 7741:
	case 7743:
	case 7745:
	case 7747:
	case 7749:
	case 7751:
	case 7753:
	case 7755:
	case 7757:
	case 7759:
	case 7761:
	case 7763:
	case 7765:
	case 7767:
	case 7769:
	case 7771:
	case 7773:
	case 7775:
	case 7777:
	case 7779:
	case 7781:
	case 7783:
	case 7785:
	case 7787:
	case 7789:
	case 7791:
	case 7793:
	case 7795:
	case 7797:
	case 7799:
	case 7801:
	case 7803:
	case 7805:
	case 7807:
	case 7809:
	case 7811:
	case 7813:
	case 7815:
	case 7817:
	case 7819:
	case 7821:
	case 7823:
	case 7825:
	case 7827:
	case 7829:
	case 7841:
	case 7843:
	case 7845:
	case 7847:
	case 7849:
	case 7851:
	case 7853:
	case 7855:
	case 7857:
	case 7859:
	case 7861:
	case 7863:
	case 7865:
	case 7867:
	case 7869:
	case 7871:
	case 7873:
	case 7875:
	case 7877:
	case 7879:
	case 7881:
	case 7883:
	case 7885:
	case 7887:
	case 7889:
	case 7891:
	case 7893:
	case 7895:
	case 7897:
	case 7899:
	case 7901:
	case 7903:
	case 7905:
	case 7907:
	case 7909:
	case 7911:
	case 7913:
	case 7915:
	case 7917:
	case 7919:
	case 7921:
	case 7923:
	case 7925:
	case 7927:
	case 7929:
		return c + -1;
	case 305:
		return c + -232;
	case 383:
		return c + -300;
	case 454:
	case 457:
	case 460:
	case 499:
		return c + -2;
	case 477:
	case 1010:
		return c + -79;
	case 595:
		return c + -210;
	case 596:
		return c + -206;
	case 601:
		return c + -202;
	case 603:
		return c + -203;
	case 608:
		return c + -205;
	case 611:
		return c + -207;
	case 616:
		return c + -209;
	case 617:
	case 623:
		return c + -211;
	case 626:
		return c + -213;
	case 629:
		return c + -214;
	case 640:
	case 643:
	case 648:
		return c + -218;
	case 658:
		return c + -219;
	case 837:
		return c + 84;
	case 940:
		return c + -38;
	case 962:
		return c + -31;
	case 972:
		return c + -64;
	case 976:
		return c + -62;
	case 977:
		return c + -57;
	case 981:
		return c + -47;
	case 982:
		return c + -54;
	case 1008:
		return c + -86;
	case 1009:
		return c + -80;
	case 7835:
		return c + -59;
	case 8017:
	case 8019:
	case 8021:
	case 8023:
		return c + 8;
	case 8115:
	case 8131:
	case 8179:
		return c + 9;
	case 8126:
		return c + -7205;
	case 8165:
		return c + 7;
	default:
		return c;
	}
}

int ustrcmp(const char *s1, const char *s2) {
	int c1, c2;
	assert(s1);
	assert(s2);

	for (;;) {
		c1 = ugetxc(&s1);
		c2 = ugetxc(&s2);

		if (c1 != c2)
			return c1 - c2;

		if (!c1)
			return 0;
	}
}

int ustrncmp(const char *s1, const char *s2, int n) {
	int c1, c2;
	assert(s1);
	assert(s2);

	if (n <= 0)
		return 0;

	for (;;) {
		c1 = ugetxc(&s1);
		c2 = ugetxc(&s2);

		if (c1 != c2)
			return c1 - c2;

		if ((!c1) || (--n <= 0))
			return 0;
	}
}

int ustricmp(const char *s1, const char *s2) {
	int c1, c2;
	assert(s1);
	assert(s2);

	for (;;) {
		c1 = utolower(ugetxc(&s1));
		c2 = utolower(ugetxc(&s2));

		if (c1 != c2)
			return c1 - c2;

		if (!c1)
			return 0;
	}
}

int ustrnicmp(const char *s1, const char *s2, int n) {
	int c1, c2;
	assert(s1);
	assert(s2);

	if (n <= 0)
		return 0;

	for (;;) {
		c1 = utolower(ugetxc(&s1));
		c2 = utolower(ugetxc(&s2));

		if (c1 != c2)
			return c1 - c2;

		if ((!c1) || (--n <= 0))
			return 0;
	}
}

int uoffset(const char *s, int index) {
	const char *orig = s;
	const char *last;
	assert(s);

	if (index < 0)
		index += ustrlen(s);

	while (index-- > 0) {
		last = s;
		if (!ugetxc(&s)) {
			s = last;
			break;
		}
	}

	return (intptr_t)s - (intptr_t)orig;
}

int ugetat(const char *s, int index) {
	assert(s);
	return ugetc(s + uoffset(s, index));
}

char *ustrlwr(char *s) {
	int pos = 0;
	int c, lc;
	assert(s);

	while ((c = ugetc(s + pos)) != 0) {
		lc = utolower(c);

		if (lc != c)
			usetat(s + pos, 0, lc);

		pos += uwidth(s + pos);
	}

	return s;
}

char *ustrupr(char *s) {
	int pos = 0;
	int c, uc;
	assert(s);

	while ((c = ugetc(s + pos)) != 0) {
		uc = utoupper(c);

		if (uc != c)
			usetat(s + pos, 0, uc);

		pos += uwidth(s + pos);
	}

	return s;
}

const char *ustrstr(const char *s1, const char *s2) {
	int len;
	assert(s1);
	assert(s2);

	len = ustrlen(s2);
	while (ugetc(s1)) {
		if (ustrncmp(s1, s2, len) == 0)
			return s1;

		s1 += uwidth(s1);
	}

	return nullptr;
}

int usetat(char *s, int index, int c) {
	int oldw, neww;
	assert(s);

	s += uoffset(s, index);

	oldw = uwidth(s);
	neww = ucwidth(c);

	if (oldw != neww)
		memmove(s + neww, s + oldw, ustrsizez(s + oldw));

	usetc(s, c);

	return neww - oldw;
}

int ustrsizez(const char *s) {
	const char *orig = s;
	assert(s);

	do {
	} while (ugetxc(&s) != 0);

	return (intptr_t)s - (intptr_t)orig;
}

const char *setlocale(int type, const char *language) {
	const char *locale = "C";
	// TODO: If needed for alfont
	return locale;
}

int need_uconvert(const char *s, int type, int newtype) {
	// TODO: need_uconvert
	return 0;
}

int uvszprintf(char *buf, int size, const char *format, va_list args) {
	error("TODO: uvszprintf");
	return 0;
}

} // namespace AGS3