// SPDX-License-Identifier: GPL-2.0+

  /*
   *  charset conversion utils
   *
   *  Copyright (c) 2017 Rob Clark

   */

  #include <common.h>

  #include <charset.h>

  #include <capitalization.h>

  #include <malloc.h>

  static struct capitalization_table capitalization_table[] =
  #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
  	UNICODE_CAPITALIZATION_TABLE;
  #elif CONFIG_FAT_DEFAULT_CODEPAGE == 1250
  	CP1250_CAPITALIZATION_TABLE;
  #else
  	CP437_CAPITALIZATION_TABLE;
  #endif

  /**
   * get_code() - read Unicode code point from UTF-8 stream
   *
   * @read_u8:	- stream reader
   * @src:	- string buffer passed to stream reader, optional
   * Return:	- Unicode code point
   */
  static int get_code(u8 (*read_u8)(void *data), void *data)

  {

  	s32 ch = 0;

  	ch = read_u8(data);
  	if (!ch)

  		return 0;

  	if (ch >= 0xc2 && ch <= 0xf4) {
  		int code = 0;
  
  		if (ch >= 0xe0) {
  			if (ch >= 0xf0) {

  				/* 0xf0 - 0xf4 */

  				ch &= 0x07;
  				code = ch << 18;
  				ch = read_u8(data);
  				if (ch < 0x80 || ch > 0xbf)
  					goto error;
  				ch &= 0x3f;

  			} else {
  				/* 0xe0 - 0xef */

  				ch &= 0x0f;

  			}

  			code += ch << 12;

  			if ((code >= 0xD800 && code <= 0xDFFF) ||
  			    code >= 0x110000)

  				goto error;
  			ch = read_u8(data);
  			if (ch < 0x80 || ch > 0xbf)
  				goto error;

  		}
  		/* 0xc0 - 0xdf or continuation byte (0x80 - 0xbf) */

  		ch &= 0x3f;
  		code += ch << 6;
  		ch = read_u8(data);
  		if (ch < 0x80 || ch > 0xbf)
  			goto error;
  		ch &= 0x3f;
  		ch += code;
  	} else if (ch >= 0x80) {
  		goto error;

  	}

  	return ch;
  error:
  	return '?';
  }
  
  /**
   * read_string() - read byte from character string
   *
   * @data:	- pointer to string
   * Return:	- byte read
   *
   * The string pointer is incremented if it does not point to '\0'.
   */
  static u8 read_string(void *data)
  
  {
  	const char **src = (const char **)data;
  	u8 c;
  
  	if (!src || !*src || !**src)
  		return 0;
  	c = **src;

  	++*src;

  	return c;
  }
  
  /**
   * read_console() - read byte from console
   *

   * @data	- not used, needed to match interface
   * Return:	- byte read or 0 on error

   */
  static u8 read_console(void *data)
  {

  	int ch;
  
  	ch = getc();
  	if (ch < 0)
  		ch = 0;
  	return ch;

  }
  
  int console_read_unicode(s32 *code)
  {
  	if (!tstc()) {
  		/* No input available */
  		return 1;
  	}
  
  	/* Read Unicode code */
  	*code = get_code(read_console, NULL);
  	return 0;
  }
  
  s32 utf8_get(const char **src)
  {
  	return get_code(read_string, src);

  }
  
  int utf8_put(s32 code, char **dst)
  {
  	if (!dst || !*dst)
  		return -1;
  	if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
  		return -1;
  	if (code <= 0x007F) {
  		**dst = code;
  	} else {
  		if (code <= 0x07FF) {
  			**dst = code >> 6 | 0xC0;
  		} else {
  			if (code < 0x10000) {
  				**dst = code >> 12 | 0xE0;
  			} else {
  				**dst = code >> 18 | 0xF0;
  				++*dst;
  				**dst = (code >> 12 & 0x3F) | 0x80;
  			}
  			++*dst;
  			**dst = (code >> 6 & 0x3F) | 0x80;
  		}
  		++*dst;
  		**dst = (code & 0x3F) | 0x80;
  	}
  	++*dst;
  	return 0;
  }
  
  size_t utf8_utf16_strnlen(const char *src, size_t count)
  {
  	size_t len = 0;
  
  	for (; *src && count; --count)  {
  		s32 code = utf8_get(&src);
  
  		if (!code)
  			break;
  		if (code < 0) {
  			/* Reserve space for a replacement character */
  			len += 1;
  		} else if (code < 0x10000) {
  			len += 1;
  		} else {
  			len += 2;
  		}
  	}
  	return len;
  }
  
  int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count)
  {
  	if (!src || !dst || !*dst)
  		return -1;
  
  	for (; count && *src; --count) {
  		s32 code = utf8_get(&src);
  
  		if (code < 0)
  			code = '?';
  		utf16_put(code, dst);
  	}
  	**dst = 0;
  	return 0;
  }
  
  s32 utf16_get(const u16 **src)
  {
  	s32 code, code2;
  
  	if (!src || !*src)
  		return -1;
  	if (!**src)
  		return 0;
  	code = **src;
  	++*src;
  	if (code >= 0xDC00 && code <= 0xDFFF)
  		return -1;
  	if (code >= 0xD800 && code <= 0xDBFF) {
  		if (!**src)
  			return -1;
  		code &= 0x3ff;
  		code <<= 10;
  		code += 0x10000;
  		code2 = **src;
  		++*src;
  		if (code2 <= 0xDC00 || code2 >= 0xDFFF)
  			return -1;
  		code2 &= 0x3ff;
  		code += code2;
  	}
  	return code;
  }
  
  int utf16_put(s32 code, u16 **dst)
  {
  	if (!dst || !*dst)
  		return -1;
  	if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
  		return -1;
  	if (code < 0x10000) {
  		**dst = code;
  	} else {
  		code -= 0x10000;
  		**dst = code >> 10 | 0xD800;
  		++*dst;
  		**dst = (code & 0x3ff) | 0xDC00;
  	}
  	++*dst;
  	return 0;
  }
  
  size_t utf16_strnlen(const u16 *src, size_t count)
  {
  	size_t len = 0;
  
  	for (; *src && count; --count)  {
  		s32 code = utf16_get(&src);
  
  		if (!code)
  			break;
  		/*
  		 * In case of an illegal sequence still reserve space for a
  		 * replacement character.
  		 */
  		++len;
  	}
  	return len;
  }
  
  size_t utf16_utf8_strnlen(const u16 *src, size_t count)
  {
  	size_t len = 0;
  
  	for (; *src && count; --count)  {
  		s32 code = utf16_get(&src);
  
  		if (!code)
  			break;
  		if (code < 0)
  			/* Reserve space for a replacement character */
  			len += 1;
  		else if (code < 0x80)
  			len += 1;
  		else if (code < 0x800)
  			len += 2;
  		else if (code < 0x10000)
  			len += 3;
  		else
  			len += 4;
  	}
  	return len;
  }
  
  int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count)
  {
  	if (!src || !dst || !*dst)
  		return -1;
  
  	for (; count && *src; --count) {
  		s32 code = utf16_get(&src);
  
  		if (code < 0)
  			code = '?';
  		utf8_put(code, dst);
  	}
  	**dst = 0;
  	return 0;
  }

  s32 utf_to_lower(const s32 code)
  {
  	struct capitalization_table *pos = capitalization_table;
  	s32 ret = code;
  
  	if (code <= 0x7f) {
  		if (code >= 'A' && code <= 'Z')
  			ret += 0x20;
  		return ret;
  	}
  	for (; pos->upper; ++pos) {
  		if (pos->upper == code) {
  			ret = pos->lower;
  			break;
  		}
  	}
  	return ret;
  }
  
  s32 utf_to_upper(const s32 code)
  {
  	struct capitalization_table *pos = capitalization_table;
  	s32 ret = code;
  
  	if (code <= 0x7f) {
  		if (code >= 'a' && code <= 'z')
  			ret -= 0x20;
  		return ret;
  	}
  	for (; pos->lower; ++pos) {
  		if (pos->lower == code) {
  			ret = pos->upper;
  			break;
  		}
  	}
  	return ret;
  }

  /*
   * u16_strncmp() - compare two u16 string
   *
   * @s1:		first string to compare
   * @s2:		second string to compare
   * @n:		maximum number of u16 to compare
   * Return:	0  if the first n u16 are the same in s1 and s2
   *		< 0 if the first different u16 in s1 is less than the
   *		corresponding u16 in s2
   *		> 0 if the first different u16 in s1 is greater than the
   *		corresponding u16 in s2
   */
  int u16_strncmp(const u16 *s1, const u16 *s2, size_t n)
  {
  	int ret = 0;
  
  	for (; n; --n, ++s1, ++s2) {
  		ret = *s1 - *s2;
  		if (ret || !*s1)
  			break;
  	}
  
  	return ret;
  }

  size_t u16_strlen(const void *in)

  {

  	const char *pos = in;
  	size_t ret;
  
  	for (; pos[0] || pos[1]; pos += 2)
  		;
  	ret = pos - (char *)in;
  	ret >>= 1;
  	return ret;

  }

  size_t u16_strnlen(const u16 *in, size_t count)

  {
  	size_t i;
  	for (i = 0; count-- && in[i]; i++);
  	return i;
  }

  u16 *u16_strcpy(u16 *dest, const u16 *src)
  {
  	u16 *tmp = dest;
  
  	for (;; dest++, src++) {
  		*dest = *src;
  		if (!*src)
  			break;
  	}
  
  	return tmp;
  }

  u16 *u16_strdup(const void *src)

  {
  	u16 *new;

  	size_t len;

  
  	if (!src)
  		return NULL;

  	len = (u16_strlen(src) + 1) * sizeof(u16);
  	new = malloc(len);

  	if (!new)
  		return NULL;

  	memcpy(new, src, len);

  
  	return new;
  }

  /* Convert UTF-16 to UTF-8.  */
  uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
  {
  	uint32_t code_high = 0;
  
  	while (size--) {
  		uint32_t code = *src++;
  
  		if (code_high) {
  			if (code >= 0xDC00 && code <= 0xDFFF) {
  				/* Surrogate pair.  */
  				code = ((code_high - 0xD800) << 10) + (code - 0xDC00) + 0x10000;
  
  				*dest++ = (code >> 18) | 0xF0;
  				*dest++ = ((code >> 12) & 0x3F) | 0x80;
  				*dest++ = ((code >> 6) & 0x3F) | 0x80;
  				*dest++ = (code & 0x3F) | 0x80;
  			} else {
  				/* Error...  */
  				*dest++ = '?';
  				/* *src may be valid. Don't eat it.  */
  				src--;
  			}
  
  			code_high = 0;
  		} else {
  			if (code <= 0x007F) {
  				*dest++ = code;
  			} else if (code <= 0x07FF) {
  				*dest++ = (code >> 6) | 0xC0;
  				*dest++ = (code & 0x3F) | 0x80;
  			} else if (code >= 0xD800 && code <= 0xDBFF) {
  				code_high = code;
  				continue;
  			} else if (code >= 0xDC00 && code <= 0xDFFF) {
  				/* Error... */
  				*dest++ = '?';
  			} else if (code < 0x10000) {
  				*dest++ = (code >> 12) | 0xE0;
  				*dest++ = ((code >> 6) & 0x3F) | 0x80;
  				*dest++ = (code & 0x3F) | 0x80;
  			} else {
  				*dest++ = (code >> 18) | 0xF0;
  				*dest++ = ((code >> 12) & 0x3F) | 0x80;
  				*dest++ = ((code >> 6) & 0x3F) | 0x80;
  				*dest++ = (code & 0x3F) | 0x80;
  			}
  		}
  	}
  
  	return dest;
  }