/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef UTF8_CHAR_H
#define UTF8_CHAR_H

#include <ctype.h>
#include <string.h>

#include <UnicodeChar.h>


struct UTF8Char {
	char	bytes[4];

	UTF8Char()
	{
		bytes[0] = 0;
	}

	UTF8Char(char c)
	{
		bytes[0] = c;
	}

	UTF8Char(const char* c)
	{
		SetTo(c, ByteCount(*c));
	}

	UTF8Char(const char* c, int32 count)
	{
		SetTo(c, count);
	}

	void SetTo(const char* c, int32 count)
	{
		bytes[0] = c[0];
		if (count > 1) {
			bytes[1] = c[1];
			if (count > 2) {
				bytes[2] = c[2];
				if (count > 3)
					bytes[3] = c[3];
			}
		}
	}

	static int32 ByteCount(char firstChar)
	{
		// Note, this does not recognize invalid chars
		uchar c = firstChar;
		if (c < 0x80)
			return 1;
		if (c < 0xe0)
			return 2;
		return c < 0xf0 ? 3 : 4;
	}

	int32 ByteCount() const
	{
		return ByteCount(bytes[0]);
	}

	bool IsFullWidth() const
	{
		switch (BUnicodeChar::EastAsianWidth(BUnicodeChar::FromUTF8(bytes))) {
			case B_UNICODE_EA_FULLWIDTH:
			case B_UNICODE_EA_WIDE:
				return true;
			default:
				break;
		}
		return false;
	}

	bool IsSpace() const
	{
		return BUnicodeChar::IsSpace(BUnicodeChar::FromUTF8(bytes));
	}

	bool IsAlNum() const
	{
		return BUnicodeChar::IsAlNum(BUnicodeChar::FromUTF8(bytes));
	}

	UTF8Char ToLower() const
	{
		uint32 c = BUnicodeChar::ToLower(BUnicodeChar::FromUTF8(bytes));

		UTF8Char character;
		char* utf8 = character.bytes;
		BUnicodeChar::ToUTF8(c, &utf8);

		return character;
	}

	bool operator==(const UTF8Char& other) const
	{
		int32 byteCount = ByteCount();
		bool equals = bytes[0] == other.bytes[0];
		if (byteCount > 1 && equals) {
			equals = bytes[1] == other.bytes[1];
			if (byteCount > 2 && equals) {
				equals = bytes[2] == other.bytes[2];
				if (byteCount > 3 && equals)
					equals = bytes[3] == other.bytes[3];
			}
		}
		return equals;
	}

	bool operator!=(const UTF8Char& other) const
	{
		return !(*this == other);
	}
};


#endif	// UTF8_CHAR_H