redef class Char

	# Returns a sequence with the UTF-8 bytes of `self`
	#
	# ~~~
	# assert 'a'.bytes == [0x61]
	# assert 'ま'.bytes == [0xE3, 0x81, 0xBE]
	# ~~~
	fun bytes: SequenceRead[Int] do return to_s.bytes

	# Is `self` an UTF-16 surrogate pair ?
	fun is_surrogate: Bool do
		var cp = code_point
		return cp >= 0xD800 and cp <= 0xDFFF
	end

	# Is `self` a UTF-16 high surrogate ?
	fun is_hi_surrogate: Bool do
		var cp = code_point
		return cp >= 0xD800 and cp <= 0xDBFF
	end

	# Is `self` a UTF-16 low surrogate ?
	fun is_lo_surrogate: Bool do
		var cp = code_point
		return cp >= 0xDC00 and cp <= 0xDFFF
	end

	# Length of `self` in a UTF-8 String
	fun u8char_len: Int do
		var c = self.code_point
		if c < 0x80 then return 1
		if c <= 0x7FF then return 2
		if c <= 0xFFFF then return 3
		if c <= 0x10FFFF then return 4
		# Bad character format
		return 1
	end

	# ~~~
	# assert 'x'.to_s    == "x"
	# ~~~
	redef fun to_s do
		var ln = u8char_len
		var ns = new CString(ln + 1)
		u8char_tos(ns, ln)
		return ns.to_s_unsafe(ln, copy=false, clean=false)
	end

	# Returns `self` escaped to UTF-16
	#
	# i.e. Represents `self`.`code_point` using UTF-16 codets escaped
	# with a `\u`
	#
	# ~~~
	# assert 'A'.escape_to_utf16 == "\\u0041"
	# assert 'è'.escape_to_utf16 == "\\u00e8"
	# assert 'あ'.escape_to_utf16 == "\\u3042"
	# assert '𐏓'.escape_to_utf16 == "\\ud800\\udfd3"
	# ~~~
	fun escape_to_utf16: String do
		var cp = code_point
		var buf: Buffer
		if cp < 0xD800 or (cp >= 0xE000 and cp <= 0xFFFF) then
			buf = new Buffer.with_cap(6)
			buf.append("\\u0000")
			var hx = cp.to_hex
			var outid = 5
			for i in hx.chars.reverse_iterator do
				buf[outid] = i
				outid -= 1
			end
		else
			buf = new Buffer.with_cap(12)
			buf.append("\\u0000\\u0000")
			var lo = (((cp - 0x10000) & 0x3FF) + 0xDC00).to_hex
			var hi = ((((cp - 0x10000) & 0xFFC00) >> 10) + 0xD800).to_hex
			var out = 2
			for i in hi do
				buf[out] = i
				out += 1
			end
			out = 8
			for i in lo do
				buf[out] = i
				out += 1
			end
		end
		return buf.to_s
	end

	private fun u8char_tos(r: CString, len: Int) `{
		r[len] = '\0';
		switch(len){
			case 1:
				r[0] = self;
				break;
			case 2:
				r[0] = 0xC0 | ((self & 0x7C0) >> 6);
				r[1] = 0x80 | (self & 0x3F);
				break;
			case 3:
				r[0] = 0xE0 | ((self & 0xF000) >> 12);
				r[1] = 0x80 | ((self & 0xFC0) >> 6);
				r[2] = 0x80 | (self & 0x3F);
				break;
			case 4:
				r[0] = 0xF0 | ((self & 0x1C0000) >> 18);
				r[1] = 0x80 | ((self & 0x3F000) >> 12);
				r[2] = 0x80 | ((self & 0xFC0) >> 6);
				r[3] = 0x80 | (self & 0x3F);
				break;
		}
	`}

	# Returns true if the char is a numerical digit
	#
	# ~~~
	# assert '0'.is_numeric
	# assert '9'.is_numeric
	# assert not 'a'.is_numeric
	# assert not '?'.is_numeric
	# ~~~
	#
	# FIXME: Works on ASCII-range only
	fun is_numeric: Bool
	do
		return self >= '0' and self <= '9'
	end

	# Returns true if the char is an alpha digit
	#
	# ~~~
	# assert 'a'.is_alpha
	# assert 'Z'.is_alpha
	# assert not '0'.is_alpha
	# assert not '?'.is_alpha
	# ~~~
	#
	# FIXME: Works on ASCII-range only
	fun is_alpha: Bool
	do
		return (self >= 'a' and self <= 'z') or (self >= 'A' and self <= 'Z')
	end

	# Is `self` an hexadecimal digit ?
	#
	# ~~~
	# assert 'A'.is_hexdigit
	# assert not 'G'.is_hexdigit
	# assert 'a'.is_hexdigit
	# assert not 'g'.is_hexdigit
	# assert '5'.is_hexdigit
	# ~~~
	fun is_hexdigit: Bool do return (self >= '0' and self <= '9') or (self >= 'A' and self <= 'F') or
					(self >= 'a' and self <= 'f')

	# Returns true if the char is an alpha or a numeric digit
	#
	# ~~~
	# assert 'a'.is_alphanumeric
	# assert 'Z'.is_alphanumeric
	# assert '0'.is_alphanumeric
	# assert '9'.is_alphanumeric
	# assert not '?'.is_alphanumeric
	# ~~~
	#
	# FIXME: Works on ASCII-range only
	fun is_alphanumeric: Bool
	do
		return self.is_numeric or self.is_alpha
	end

	# Returns `self` to its int value
	#
	# REQUIRE: `is_hexdigit`
	fun from_hex: Int do
		if self >= '0' and self <= '9' then return code_point - 0x30
		if self >= 'A' and self <= 'F' then return code_point - 0x37
		if self >= 'a' and self <= 'f' then return code_point - 0x57
		# Happens if self is not a hexdigit
		assert self.is_hexdigit
		# To make flow analysis happy
		abort
	end
end

redef class Char
	super Pattern

	redef fun search_index_in(s, from)
	do
		var stop = s.length
		while from < stop do
			if s[from] == self then return from
			from += 1
		end
		return -1
	end

	redef fun search_in(s, from)
	do
		var pos = search_index_in(s, from)
		if pos < 0 then
			return null
		else
			return new Match(s.to_s, pos, 1)
		end
	end
end

redef class Char
	# Is `self` a valid Base64 character ?
	fun is_base64_char: Bool do
		if code_point >= 127 then return false
		return code_point.is_base64_char
	end
end

redef class Char
	# Rotates self of `x`
	#
	# NOTE: works on letters only
	#
	#     assert 'x'.rot(6) == 'd'
	#     assert 'T'.rot(15) == 'I'
	#     assert '1'.rot(10) == '1'
	#     assert '$'.rot(10) == '$'
	#     assert 'z'.rot(-2) == 'x'
	fun rot(x: Int): Char do
		if not is_letter then return self
		x = x % 26
		if x < 0 then x += 26
		var up = false
		var val = code_point
		if is_upper then
			up = true
			val += 32
		end
		val += x
		if val > 122 then val -= 26
		if up then val -= 32
		return val.code_point
	end
end

redef class Char super DirectSerializable end

redef class Char
	redef fun accept_json_serializer(v)
	do
		if v.plain_json then
			to_s.accept_json_serializer v
		else
			v.stream.write "\{\"__kind\": \"char\", \"__val\": "
			to_s.accept_json_serializer v
			v.stream.write "\}"
		end
	end
end

redef class Char
	redef fun accept_inspect_serializer(v)
	do
		v.stream.write "'"
		v.stream.write to_s.escape_to_nit
		v.stream.write "'"
	end
end

redef class Char
	# Is `self` a valid number start ?
	private fun is_json_num_start: Bool do
		if self == '-' then return true
		if self.is_numeric then return true
		return false
	end

	# Is `self` a valid JSON separator ?
	private fun is_json_separator: Bool do
		if self == ':' then return true
		if self == ',' then return true
		if self == '{' then return true
		if self == '}' then return true
		if self == '[' then return true
		if self == ']' then return true
		if self == '"' then return true
		if self.is_whitespace then return true
		return false
	end
end

redef class Char
	redef fun accept_msgpack_serializer(v)
	do
		if v.plain_msgpack then
			# Write as a string
			v.stream.write_msgpack_fixstr to_s
		else
			# Write as ext
			var bytes = to_s.to_bytes
			v.stream.write_msgpack_ext(v.ext_typ_char, bytes)
		end
	end
end

redef class Char
	redef fun add_to_bundle(bundle, key)
	do
		bundle.put_char(key, self)
	end
end