# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Services for byte streams and arrays
module bytes

import kernel
import collection::array
intrude import text::flat

# Any kind of entity which can be searched for in a Sequence of Byte
interface BytePattern
	# Return the first occurence of `self` in `b`, or -1 if not found
	fun first_index_in(b: SequenceRead[Int]): Int do return first_index_in_from(b, 0)

	# Return the first occurence of `self` in `b` starting at `from`, or -1 if not found
	fun first_index_in_from(b: SequenceRead[Int], from: Int): Int is abstract

	# Return the last occurence of `self` in `b`, or -1 if not found
	fun last_index_in(b: SequenceRead[Int]): Int do return last_index_in_from(b, b.length - 1)

	# Return the last occurence of `self` in `b`, or -1 if not found
	fun last_index_in_from(b: SequenceRead[Int], from: Int): Int is abstract

	# Returns the indexes of all the occurences of `self` in `b`
	fun search_all_in(b: SequenceRead[Int]): SequenceRead[Int] is abstract

	# Length of the pattern
	fun pattern_length: Int is abstract

	# Appends `self` to `b`
	fun append_to(b: Sequence[Int]) is abstract

	# Is `self` a prefix for `b` ?
	fun is_prefix(b: SequenceRead[Int]): Bool is abstract

	# Is `self` a suffix for `b` ?
	fun is_suffix(b: SequenceRead[Int]): Bool is abstract
end

redef class Int
	super BytePattern

	# Write self as a string into `ns` at position `pos`
	private fun add_digest_at(ns: CString, pos: Int) do
		var tmp = (0xF0 & self) >> 4
		ns[pos] = if tmp >= 0x0A then tmp + 0x37 else tmp + 0x30
		tmp = 0x0F & self
		ns[pos + 1] = if tmp >= 0x0A then tmp + 0x37 else tmp + 0x30
	end

	# Is `self` a valid hexadecimal digit (in ASCII)
	#
	# ~~~nit
	# intrude import core::bytes
	# assert not u'/'.is_valid_hexdigit
	# assert u'0'.is_valid_hexdigit
	# assert u'9'.is_valid_hexdigit
	# assert not u':'.is_valid_hexdigit
	# assert not u'@'.is_valid_hexdigit
	# assert u'A'.is_valid_hexdigit
	# assert u'F'.is_valid_hexdigit
	# assert not u'G'.is_valid_hexdigit
	# assert not u'`'.is_valid_hexdigit
	# assert u'a'.is_valid_hexdigit
	# assert u'f'.is_valid_hexdigit
	# assert not u'g'.is_valid_hexdigit
	# ~~~
	private fun is_valid_hexdigit: Bool do
		return (self >= 0x30 and self <= 0x39) or
		       (self >= 0x41 and self <= 0x46) or
		       (self >= 0x61 and self <= 0x66)
	end

	# `self` as a hexdigit to its byte value
	#
	# ~~~nit
	# intrude import core::bytes
	# assert 0x39.hexdigit_to_byteval == 0x09
	# assert 0x43.hexdigit_to_byteval == 0x0C
	# ~~~
	#
	# REQUIRE: `self.is_valid_hexdigit`
	private fun hexdigit_to_byteval: Int do
		if self >= 0x30 and self <= 0x39 then
			return self - 0x30
		else if self >= 0x41 and self <= 0x46 then
			return self - 0x37
		else if self >= 0x61 and self <= 0x66 then
			return self - 0x57
		end
		# Happens only if the requirement is not met.
		# i.e. this abort is here to please the compiler
		abort
	end

	redef fun first_index_in_from(b, from) do
		for i in [from .. b.length[ do if b[i] == self then return i
		return -1
	end

	redef fun last_index_in_from(b, from) do
		for i in [0 .. from].step(-1) do if b[i] == self then return i
		return -1
	end

	redef fun search_all_in(b) do
		var ret = new Array[Int]
		var pos = 0
		loop
			pos = first_index_in_from(b, pos)
			if pos == -1 then return ret
			ret.add pos
			pos += 1
		end
	end

	redef fun pattern_length do return 1

	redef fun append_to(b) do b.push self

	#     assert u'b'.is_suffix("baqsdb".to_bytes)
	#     assert not u'b'.is_suffix("baqsd".to_bytes)
	redef fun is_suffix(b) do return b.length != 0 and b.last == self

	#     assert u'b'.is_prefix("baqsdb".to_bytes)
	#     assert not u'b'.is_prefix("aqsdb".to_bytes)
	redef fun is_prefix(b) do return b.length != 0 and b.first == self

	# A signed big-endian representation of `self`
	#
	# ~~~
	# assert     1.to_bytes.hexdigest ==     "01"
	# assert   255.to_bytes.hexdigest ==     "FF"
	# assert   256.to_bytes.hexdigest ==   "0100"
	# assert 65535.to_bytes.hexdigest ==   "FFFF"
	# assert 65536.to_bytes.hexdigest == "010000"
	# ~~~
	#
	# Negative values are converted to their two's complement.
	# Be careful as the result can be ambiguous.
	#
	# ~~~
	# assert     (-1).to_bytes.hexdigest ==     "FF"
	# assert    (-32).to_bytes.hexdigest ==     "E0"
	# assert   (-512).to_bytes.hexdigest ==   "FE00"
	# assert (-65794).to_bytes.hexdigest == "FEFEFE"
	# ~~~
	#
	# Optionally, set `n_bytes` to the desired number of bytes in the output.
	# This setting can disambiguate the result between positive and negative
	# integers. Be careful with this parameter as the result may overflow.
	#
	# ~~~
	# assert        1.to_bytes(2).hexdigest ==     "0001"
	# assert    65535.to_bytes(2).hexdigest ==     "FFFF"
	# assert     (-1).to_bytes(2).hexdigest ==     "FFFF"
	# assert   (-512).to_bytes(4).hexdigest == "FFFFFE00"
	# assert 0x123456.to_bytes(2).hexdigest ==     "3456"
	# ~~~
	#
	# For 0, a Bytes object with single nul byte is returned (instead of an empty Bytes object).
	#
	# ~~~
	# assert 0.to_bytes.hexdigest == "00"
	# ~~~
	#
	# For positive integers, `Bytes::to_i` can reverse the operation.
	#
	# ~~~
	# assert 1234.to_bytes.to_i == 1234
	# ~~~
	#
	# Require self >= 0
	fun to_bytes(n_bytes: nullable Int): Bytes do

		# If 0, force using at least one byte
		if self == 0 and n_bytes == null then n_bytes = 1

		# Compute the len (log256)
		var len = 1
		var max = 256
		var s = self.abs
		while s >= max do
			len += 1
			max *= 256
		end

		# Two's complement
		s = self
		if self < 0 then
			var ff = 0
			for j in [0..len[ do
				ff *= 0x100
				ff += 0xFF
			end

			s = ((-self) ^ ff) + 1
		end

		# Cut long values
		if n_bytes != null and len > n_bytes then len = n_bytes

		# Allocate the buffer
		var cap = n_bytes or else len
		var res = new Bytes.with_capacity(cap)

		var filler = if self < 0 then 0xFF else 0
		for i in [0..cap[ do res[i] = filler

		# Fill it starting with the end
		var i = cap
		var sum = s
		while i > cap - len do
			i -= 1
			res[i] = sum % 256
			sum /= 256
		end

		return res
	end
end

# A buffer containing Byte-manipulation facilities
#
# Uses Copy-On-Write when persisted
class Bytes
	super AbstractArray[Int]
	super BytePattern

	# A CString being a char*, it can be used as underlying representation here.
	var items: CString

	# Number of bytes in the array
	redef var length

	# Capacity of the array
	private var capacity: Int

	# Has this buffer been persisted (to_s'd)?
	#
	# Used for Copy-On-Write
	private var persisted = false

	#     var b = new Bytes.empty
	#     assert b.to_s == ""
	init empty do
		var ns = new CString(0)
		init(ns, 0, 0)
	end

	# Init a `Bytes` with capacity `cap`
	init with_capacity(cap: Int) do
		var ns = new CString(cap)
		init(ns, 0, cap)
	end

	redef fun pattern_length do return length

	redef fun is_empty do return length == 0

	#     var b = new Bytes.empty
	#     b.add 101
	#     assert b[0] == 101
	redef fun [](i) do
		assert i >= 0
		assert i < length
		return items[i]
	end

	# Returns a copy of `self`
	fun clone: Bytes do
		var b = new Bytes.with_capacity(length)
		b.append(self)
		return b
	end

	# Trims off the whitespaces at the beginning and the end of `self`
	#
	#     var b = "102041426E6F1020" .hexdigest_to_bytes
	#     assert b.trim.hexdigest == "41426E6F"
	#
	# NOTE: A whitespace is defined here as a byte whose value is <= 0x20
	fun trim: Bytes do
		var st = 0
		while st < length do
			if self[st] > 0x20 then break
			st += 1
		end
		if st >= length then return new Bytes.empty
		var ed = length - 1
		while ed > 0 do
			if self[ed] > 0x20 then break
			ed -= 1
		end
		return slice(st, ed - st + 1)
	end

	# Copy a subset of `self` starting at `from` and of `count` bytes
	#
	#     var b = "abcd".to_bytes
	#     assert b.slice(1, 2).hexdigest == "6263"
	#     assert b.slice(-1, 2).hexdigest == "61"
	#     assert b.slice(1, 0).hexdigest == ""
	#     assert b.slice(2, 5).hexdigest == "6364"
	fun slice(from, count: Int): Bytes do
		if count <= 0 then return new Bytes.empty

		if from < 0 then
			count += from
			if count < 0 then count = 0
			from = 0
		end

		if (count + from) > length then count = length - from
		if count <= 0 then return new Bytes.empty

		var ret = new Bytes.with_capacity(count)

		ret.append_ns(items.fast_cstring(from), count)
		return ret
	end

	# Copy of `self` starting at `from`
	#
	#     var b = "abcd".to_bytes
	#     assert b.slice_from(1).hexdigest  == "626364"
	#     assert b.slice_from(-1).hexdigest == "61626364"
	#     assert b.slice_from(2).hexdigest  == "6364"
	fun slice_from(from: Int): Bytes do
		if from >= length then return new Bytes.empty
		if from < 0 then from = 0
		return slice(from, length)
	end

	# Reverse the byte array in place
	#
	#     var b = "abcd".to_bytes
	#     b.reverse
	#     assert b.to_s == "dcba"
	fun reverse
	do
		var l = length
		for i in [0..l/2[ do
			var tmp = self[i]
			self[i] = self[l-i-1]
			self[l-i-1] = tmp
		end
	end

	# Returns self as an hexadecimal digest.
	#
	# Also known as plain hexdump or postscript hexdump.
	#
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.hexdigest == "61626364"
	# assert b.hexdigest.hexdigest_to_bytes == b
	# ~~~
	fun hexdigest: String do
		var elen = length * 2
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			self[i].add_digest_at(ns, oi)
			i += 1
			oi += 2
		end
		return new FlatString.full(ns, elen, 0, elen)
	end

	# Return self as a C hexadecimal digest where bytes are prefixed by `\x`
	#
	# The output is compatible with literal stream of bytes for most languages
	# including C and Nit.
	#
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.chexdigest == "\\x61\\x62\\x63\\x64"
	# assert b.chexdigest.unescape_to_bytes == b
	# ~~~
	fun chexdigest: String do
		var elen = length * 4
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			ns[oi] = u'\\'
			ns[oi+1] = u'x'
			self[i].add_digest_at(ns, oi+2)
			i += 1
			oi += 4
		end
		return new FlatString.full(ns, elen, 0, elen)
	end


	# Returns self as a stream of bits (0 and 1)
	#
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.binarydigest == "01100001011000100110001101100100"
	# assert b.binarydigest.binarydigest_to_bytes == b
	# ~~~
	fun binarydigest: String do
		var elen = length * 8
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			var c = self[i]
			var b = 128
			while b > 0 do
				if c & b == 0 then
					ns[oi] = u'0'
				else
					ns[oi] = u'1'
				end
				oi += 1
				b = b >> 1
			end
			i += 1
		end
		return new FlatString.full(ns, elen, 0, elen)
	end

	# Interprets `self` as a big-endian integer (unsigned by default)
	#
	# ~~~
	# var b = "0102".hexdigest_to_bytes
	# assert b.to_i == 258
	#
	# assert   "01".hexdigest_to_bytes.to_i == 1
	# assert   "FF".hexdigest_to_bytes.to_i == 255
	# assert "0000".hexdigest_to_bytes.to_i == 0
	# ~~~
	#
	# If `self.is_empty`, 0 is returned.
	#
	# ~~~
	# assert "".hexdigest_to_bytes.to_i == 0
	# ~~~
	#
	# If `signed == true`, the bytes are read as a signed integer.
	# As usual, the sign bit is the left most bit, no matter the
	# `length` of `self`.
	#
	# ~~~
	# assert     "01".hexdigest_to_bytes.to_i(true) ==      1
	# assert     "FF".hexdigest_to_bytes.to_i(true) ==     -1
	# assert   "00FF".hexdigest_to_bytes.to_i(true) ==    255
	# assert     "E0".hexdigest_to_bytes.to_i(true) ==    -32
	# assert   "FE00".hexdigest_to_bytes.to_i(true) ==   -512
	# assert "FEFEFE".hexdigest_to_bytes.to_i(true) == -65794
	# ~~~
	#
	# `Int::to_bytes` is a loosely reverse method.
	#
	# ~~~
	# assert b.to_i.to_bytes == b
	# assert (b.to_i + 1).to_bytes.hexdigest == "0103"
	# assert "0001".hexdigest_to_bytes.to_i.to_bytes.hexdigest == "01"
	#
	# assert (-32).to_bytes.to_i(true) == -32
	# ~~~
	#
	# Warning: `Int` might overflow for bytes with more than 60 bits.
	fun to_i(signed: nullable Bool): Int do
		var res = 0
		var i = 0
		while i < length do
			res *= 256
			res += self[i].to_i
			i += 1
		end

		# Two's complement is `signed`
		if signed == true and not_empty and first > 0x80 then
			var ff = 0
			for j in [0..length[ do
				ff *= 0x100
				ff += 0xFF
			end

			res = -((res ^ ff) + 1)
		end

		return res
	end

	#     var b = new Bytes.with_capacity(1)
	#     b[0] = 101
	#     assert b.to_s == "e"
	redef fun []=(i, v) do
		if persisted then regen
		assert i >= 0
		assert i <= length
		if i == length then add(v)
		items[i] = v
	end

	#     var b = new Bytes.empty
	#     b.add 101
	#     assert b.to_s == "e"
	redef fun add(c) do
		if persisted then regen
		if length >= capacity then
			enlarge(length)
		end
		items[length] = c
		length += 1
	end

	# Adds the UTF-8 representation of `c` to `self`
	#
	#     var b = new Bytes.empty
	#     b.add_char('A')
	#     b.add_char('キ')
	#     assert b.hexdigest == "41E382AD"
	fun add_char(c: Char) do
		if persisted then regen
		var cln = c.u8char_len
		var ln = length
		enlarge(ln + cln)
		items.set_char_at(length, c)
		length += cln
	end

	redef fun has(c)
	do
		if not c isa Int then return false
		return super(c&255)
	end

	#     var b = new Bytes.empty
	#     b.append([104, 101, 108, 108, 111])
	#     assert b.to_s == "hello"
	redef fun append(arr) do
		if arr isa Bytes then
			append_ns(arr.items, arr.length)
		else
			for i in arr do add i
		end
	end

	#     var b = new Bytes.empty
	#     b.append([0x41, 0x41, 0x18])
	#     b.pop
	#     assert b.to_s == "AA"
	redef fun pop do
		assert length >= 1
		length -= 1
		return items[length]
	end

	redef fun clear do length = 0

	# Regenerates the buffer, necessary when it was persisted
	private fun regen do
		var nns = new CString(capacity)
		items.copy_to(nns, length, 0, 0)
		persisted = false
	end

	# Appends the `ln` first bytes of `ns` to self
	fun append_ns(ns: CString, ln: Int) do
		if persisted then regen
		var nlen = length + ln
		if nlen > capacity then enlarge(nlen)
		ns.copy_to(items, ln, 0, length)
		length += ln
	end

	# Appends `ln` bytes from `ns` starting at index `from` to self
	fun append_ns_from(ns: CString, ln, from: Int) do
		if persisted then regen
		var nlen = length + ln
		if nlen > capacity then enlarge(nlen)
		ns.copy_to(items, ln, from, length)
		length += ln
	end

	# Appends the bytes of `str` to `self`
	fun append_text(str: Text) do str.append_to_bytes self

	redef fun append_to(b) do b.append self

	redef fun enlarge(sz) do
		if capacity >= sz then return
		persisted = false
		if capacity < 16 then capacity = 16
		while capacity < sz do capacity = capacity * 2 + 2
		var ns = new CString(capacity)
		items.copy_to(ns, length, 0, 0)
		items = ns
	end

	redef fun to_s do
		persisted = true
		var b = self
		var r = b.items.to_s_unsafe(length, copy=false)
		if r != items then persisted = false
		return r
	end

	redef fun iterator do return new BytesIterator.with_buffer(self)

	redef fun first_index_in_from(b, from) do
		if is_empty then return -1
		var fst = self[0]
		var bpos = fst.first_index_in_from(self, from)
		for i in [0 .. length[ do
			if self[i] != b[bpos] then return first_index_in_from(b, bpos + 1)
			bpos += 1
		end
		return bpos
	end

	redef fun last_index_in_from(b, from) do
		if is_empty then return -1
		var lst = self[length - 1]
		var bpos = lst.last_index_in_from(b, from)
		for i in [0 .. length[.step(-1) do
			if self[i] != b[bpos] then return last_index_in_from(b, bpos - 1)
			bpos -= 1
		end
		return bpos
	end

	redef fun search_all_in(b) do
		var ret = new Array[Int]
		var pos = first_index_in_from(b, 0)
		if pos == -1 then return ret
		pos = pos + 1
		ret.add pos
		loop
			pos = first_index_in_from(b, pos)
			if pos == -1 then return ret
			ret.add pos
			pos += length
		end
	end

	# Splits the content on self when encountering `b`
	#
	#     var a = "String is string".to_bytes.split_with(u's')
	#     assert a.length == 3
	#     assert a[0].hexdigest == "537472696E672069"
	#     assert a[1].hexdigest == "20"
	#     assert a[2].hexdigest == "7472696E67"
	fun split_with(b: BytePattern): Array[Bytes] do
		var fst = b.search_all_in(self)
		if fst.is_empty then return [clone]
		var retarr = new Array[Bytes]
		var prev = 0
		for i in fst do
			retarr.add(slice(prev, i - prev))
			prev = i + b.pattern_length
		end
		retarr.add slice_from(prev)
		return retarr
	end

	# Splits `self` in two parts at the first occurence of `b`
	#
	#     var a = "String is string".to_bytes.split_once_on(u's')
	#     assert a[0].hexdigest == "537472696E672069"
	#     assert a[1].hexdigest == "20737472696E67"
	fun split_once_on(b: BytePattern): Array[Bytes] do
		var spl = b.first_index_in(self)
		if spl == -1 then return [clone]
		var ret = new Array[Bytes].with_capacity(2)
		ret.add(slice(0, spl))
		ret.add(slice_from(spl + b.pattern_length))
		return ret
	end

	# Replaces all the occurences of `this` in `self` by `by`
	#
	#     var b = "String is string".to_bytes.replace(0x20, 0x41)
	#     assert b.hexdigest == "537472696E6741697341737472696E67"
	fun replace(pattern: BytePattern, bytes: BytePattern): Bytes do
		if is_empty then return new Bytes.empty
		var pos = pattern.search_all_in(self)
		if pos.is_empty then return clone
		var ret = new Bytes.with_capacity(length)
		var prev = 0
		for i in pos do
			ret.append_ns(items.fast_cstring(prev), i - prev)
			bytes.append_to ret
			prev = i + pattern.pattern_length
		end
		ret.append(slice_from(pos.last + pattern.pattern_length))
		return ret
	end

	# Decode `self` from percent (or URL) encoding to a clear string
	#
	# Invalid '%' are not decoded.
	#
	#     assert "aBc09-._~".to_bytes.from_percent_encoding == "aBc09-._~".to_bytes
	#     assert "%25%28%29%3c%20%3e".to_bytes.from_percent_encoding == "%()< >".to_bytes
	#     assert ".com%2fpost%3fe%3dasdf%26f%3d123".to_bytes.from_percent_encoding == ".com/post?e=asdf&f=123".to_bytes
	#     assert "%25%28%29%3C%20%3E".to_bytes.from_percent_encoding == "%()< >".to_bytes
	#     assert "incomplete %".to_bytes.from_percent_encoding == "incomplete %".to_bytes
	#     assert "invalid % usage".to_bytes.from_percent_encoding == "invalid % usage".to_bytes
	#     assert "%c3%a9%e3%81%82%e3%81%84%e3%81%86".to_bytes.from_percent_encoding == "éあいう".to_bytes
	#     assert "%1 %A %C3%A9A9".to_bytes.from_percent_encoding == "%1 %A éA9".to_bytes
	fun from_percent_encoding: Bytes do
		var tmp = new Bytes.with_capacity(length)
		var pos = 0
		while pos < length do
			var b = self[pos]
			if b != u'%' then
				tmp.add b
				pos += 1
				continue
			end
			if length - pos < 2 then
				tmp.add u'%'
				pos += 1
				continue
			end
			var bn = self[pos + 1]
			var bnn = self[pos + 2]
			if not bn.is_valid_hexdigit or not bnn.is_valid_hexdigit then
				tmp.add u'%'
				pos += 1
				continue
			end
			tmp.add((bn.hexdigit_to_byteval << 4) + bnn.hexdigit_to_byteval)
			pos += 3
		end
		return tmp
	end

	# Is `b` a prefix of `self` ?
	fun has_prefix(b: BytePattern): Bool do return b.is_prefix(self)

	# Is `b` a suffix of `self` ?
	fun has_suffix(b: BytePattern): Bool do return b.is_suffix(self)

	redef fun is_suffix(b) do
		if length > b.length then return false
		var j = b.length - 1
		var i = length - 1
		while i > 0 do
			if self[i] != b[j] then return false
			i -= 1
			j -= 1
		end
		return true
	end

	redef fun is_prefix(b) do
		if length > b.length then return false
		for i in [0 .. length[ do if self[i] != b[i] then return false
		return true
	end
end

private class BytesIterator
	super IndexedIterator[Int]

	var tgt: CString

	redef var index

	var max: Int

	init with_buffer(b: Bytes) do init(b.items, 0, b.length)

	redef fun is_ok do return index < max

	redef fun next do index += 1

	redef fun item do return tgt[index]
end

redef class Text
	# Returns a mutable copy of `self`'s bytes
	#
	# ~~~nit
	# assert "String".to_bytes isa Bytes
	# assert "String".to_bytes == [83, 116, 114, 105, 110, 103]
	# ~~~
	fun to_bytes: Bytes do
		var b = new Bytes.with_capacity(byte_length)
		append_to_bytes b
		return b
	end

	# Is `self` a valid hexdigest ?
	#
	#     assert "0B1d3F".is_valid_hexdigest
	#     assert not "5G".is_valid_hexdigest
	fun is_valid_hexdigest: Bool do
		for i in bytes do if not i.is_valid_hexdigit then return false
		return true
	end

	# Appends `self.bytes` to `b`
	fun append_to_bytes(b: Bytes) do
		for s in substrings do
			var from = if s isa FlatString then s.first_byte else 0
			b.append_ns_from(s.items, s.byte_length, from)
		end
	end

	# Returns a new `Bytes` instance with the digest as content
	#
	#     assert "0B1F4D".hexdigest_to_bytes == [0x0B, 0x1F, 0x4D]
	#     assert "0B1F4D".hexdigest_to_bytes.hexdigest == "0B1F4D"
	#
	# Characters that are not hexadecimal digits are ignored.
	#
	#     assert "z0B1 F4\nD".hexdigest_to_bytes.hexdigest == "0B1F4D"
	#     assert "\\x0b1 \\xf4d".hexdigest_to_bytes.hexdigest == "0B1F4D"
	#
	# When the number of hexadecimal digit is not even, then a leading 0 is
	# implicitly considered to fill the left byte (the most significant one).
	#
	#     assert "1".hexdigest_to_bytes.hexdigest == "01"
	#     assert "FFF".hexdigest_to_bytes.hexdigest == "0FFF"
	#
	# `Bytes::hexdigest` is a loosely reverse method since its
	# results contain only pairs of uppercase hexadecimal digits.
	#
	#     assert "ABCD".hexdigest_to_bytes.hexdigest == "ABCD"
	#     assert "a b c".hexdigest_to_bytes.hexdigest == "0ABC"
	fun hexdigest_to_bytes: Bytes do
		var b = bytes
		var max = byte_length

		var dlength = 0 # Number of hex digits
		var pos = 0
		while pos < max do
			var c = b[pos]
			if c.is_valid_hexdigit then dlength += 1
			pos += 1
		end

		# Allocate the result buffer
		var ret = new Bytes.with_capacity((dlength+1) / 2)

		var i = (dlength+1) % 2 # current hex digit (1=high, 0=low)
		var byte = 0 # current accumulated byte value

		pos = 0
		while pos < max do
			var c = b[pos]
			if c.is_valid_hexdigit then
				byte = byte << 4 | c.hexdigit_to_byteval
				i -= 1
				if i < 0 then
					# Last digit known: store and restart
					ret.add byte
					i = 1
					byte = 0
				end
			end
			pos += 1
		end
		return ret
	end

	# Gets the hexdigest of the bytes of `self`
	#
	#     assert "&lt;STRING&#47;&rt;".hexdigest == "266C743B535452494E47262334373B2672743B"
	fun hexdigest: String do
		var ln = byte_length
		var outns = new CString(ln * 2)
		var oi = 0
		for i in [0 .. ln[ do
			bytes[i].add_digest_at(outns, oi)
			oi += 2
		end
		return new FlatString.with_infos(outns, ln * 2, 0)
	end

	# Return a `Bytes` instance where Nit escape sequences are transformed.
	#
	#     assert "B\\n\\x41\\u0103D3".unescape_to_bytes.hexdigest == "420A41F0908F93"
	#
	# `Bytes::chexdigest` is a loosely reverse methods since its result is only made
	# of `"\x??"` escape sequences.
	#
	#     assert "\\x41\\x42\\x43".unescape_to_bytes.chexdigest == "\\x41\\x42\\x43"
	#     assert "B\\n\\x41\\u0103D3".unescape_to_bytes.chexdigest == "\\x42\\x0A\\x41\\xF0\\x90\\x8F\\x93"
	fun unescape_to_bytes: Bytes do
		var res = new Bytes.with_capacity(self.byte_length)
		var was_slash = false
		var i = 0
		while i < length do
			var c = self[i]
			if not was_slash then
				if c == '\\' then
					was_slash = true
				else
					res.add_char(c)
				end
				i += 1
				continue
			end
			was_slash = false
			if c == 'n' then
				res.add_char('\n')
			else if c == 'r' then
				res.add_char('\r')
			else if c == 't' then
				res.add_char('\t')
			else if c == '0' then
				res.add_char('\0')
			else if c == 'x' or c == 'X' then
				var hx = substring(i + 1, 2)
				if hx.is_hex then
					res.add hx.to_hex
				else
					res.add_char(c)
				end
				i += 2
			else if c == 'u' or c == 'U' then
				var hx = substring(i + 1, 6)
				if hx.is_hex then
					res.add_char(hx.to_hex.code_point)
				else
					res.add_char(c)
				end
				i += 6
			else
				res.add_char(c)
			end
			i += 1
		end
		return res
	end

	# Return a `Bytes` by reading 0 and 1.
	#
	#     assert "1010101100001101".binarydigest_to_bytes.hexdigest == "AB0D"
	#
	# Note that characters that are neither 0 or 1 are just ignored.
	#
	#     assert "a1B01 010\n1100あ001101".binarydigest_to_bytes.hexdigest == "AB0D"
	#     assert "hello".binarydigest_to_bytes.is_empty
	#
	# When the number of bits is not divisible by 8, then leading 0 are
	# implicitly considered to fill the left byte (the most significant one).
	#
	#     assert "1".binarydigest_to_bytes.hexdigest == "01"
	#     assert "1111111".binarydigest_to_bytes.hexdigest == "7F"
	#     assert "1000110100".binarydigest_to_bytes.hexdigest == "0234"
	#
	# `Bytes::binarydigest` is a loosely reverse method since its
	# results contain only 1 and 0 by blocks of 8.
	#
	#     assert "1010101100001101".binarydigest_to_bytes.binarydigest == "1010101100001101"
	#     assert "1".binarydigest_to_bytes.binarydigest == "00000001"
	fun binarydigest_to_bytes: Bytes
	do
		var b = bytes
		var max = byte_length

		# Count bits
		var bitlen = 0
		var pos = 0
		while pos < max do
			var c = b[pos]
			pos += 1
			if c == u'0' or c == u'1' then bitlen += 1
		end

		# Allocate (and take care of the padding)
		var ret = new Bytes.with_capacity((bitlen+7) / 8)

		var i = (bitlen+7) % 8 # current bit (7th=128, 0th=1)
		var byte = 0 # current accumulated byte value

		pos = 0
		while pos < max do
			var c = b[pos]
			pos += 1
			if c == u'0' then
				byte = byte << 1
			else if c == u'1' then
				byte = byte << 1 | 1
			else
				continue
			end

			i -= 1
			if i < 0 then
				# Last bit known: store and restart
				ret.add byte
				i = 7
				byte = 0
			end
		end
		return ret
	end
end

redef class FlatText
	redef fun append_to_bytes(b) do
		var from = if self isa FlatString then first_byte else 0
		if isset _items then b.append_ns_from(items, byte_length, from)
	end
end

redef class CString
	# Creates a new `Bytes` object from `self` with `len` as length
	#
	# If `len` is null, strlen will determine the length of the Bytes
	fun to_bytes(len: nullable Int): Bytes do
		if len == null then len = cstring_length
		return new Bytes(self, len, len)
	end

	# Creates a new `Bytes` object from a copy of `self` with `len` as length
	#
	# If `len` is null, strlen will determine the length of the Bytes
	fun to_bytes_with_copy(len: nullable Int): Bytes do
		if len == null then len = cstring_length
		var nns = new CString(len)
		copy_to(nns, len, 0, 0)
		return new Bytes(nns, len, len)
	end
end

# Joins an array of bytes `arr` separated by `sep`
#
#     assert join_bytes(["String".to_bytes, "is".to_bytes, "string".to_bytes], u' ').hexdigest == "537472696E6720697320737472696E67"
fun join_bytes(arr: Array[Bytes], sep: nullable BytePattern): Bytes do
	if arr.is_empty then return new Bytes.empty
	sep = sep or else new Bytes.empty
	var endln = sep.pattern_length * (arr.length - 1)
	for i in arr do endln += i.length
	var ret = new Bytes.with_capacity(endln)
	ret.append(arr.first)
	for i in  [1 .. arr.length[ do
		sep.append_to(ret)
		ret.append arr[i]
	end
	return ret
end