redef class Collection[E]
	# Build a new array from a collection
	fun to_a: Array[E]
	do
		var res = new Array[E].with_capacity(length)
		res.add_all(self)
		return res
	end
end

redef class Collection[ E ]
	# Return a random element form the collection
	# There must be at least one element in the collection
	#
	# ~~~
	# var x = [1,2,3].rand
	# assert x == 1 or x == 2 or x == 3
	# ~~~
	fun rand: E
	do
		if is_empty then abort
		var rand_index = length.rand

		for e in self do
			if rand_index == 0 then return e
			rand_index -= 1
		end
		abort
	end

	# Return a new array made of elements in a random order.
	#
	# ~~~
	# var a = [1,2,1].to_shuffle
	# assert a == [1,1,2] or a == [1,2,1] or a == [2,1,1]
	# ~~~
	fun to_shuffle: Array[E]
	do
		var res = self.to_a
		res.shuffle
		return res
	end

	# Return a new array made of (at most) `length` elements randomly chosen.
	#
	# ~~~
	# var a = [1,2,1].sample(2)
	# assert a == [1,1] or a == [1,2] or a == [2,1]
	# ~~~
	#
	# If there is not enough elements, then the result only contains them in a random order.
	# See `to_shuffle`.
	#
	# ENSURE `result.length == self.length.min(length)`
	#
	# Note: the default implementation uses the Reservoir Algorithm
	fun sample(length: Int): Array[E]
	do
		if length >= self.length then return to_shuffle

		var res = new Array[E].with_capacity(length)
		var it = iterator
		for i in [0..length[ do
			res[i] = it.item
			it.next
		end
		res.shuffle
		for i in [length+1..self.length] do
			var j = i.rand
			if j < length then
				res[j] = it.item
			end
			it.next
		end
		return res
	end
end

redef class Collection[E]
	# String representation of the content of the collection.
	#
	# The standard representation is the list of elements separated with commas.
	#
	# ~~~
	# assert [1,2,3].to_s == "[1,2,3]"
	# assert [1..3].to_s  == "[1,2,3]"
	# assert (new Array[Int]).to_s == "[]" # empty collection
	# ~~~
	#
	# Subclasses may return a more specific string representation.
	redef fun to_s
	do
		return "[" + join(",") + "]"
	end

	# Concatenate elements without separators
	#
	# ~~~
	# assert [1,2,3].plain_to_s == "123"
	# assert [11..13].plain_to_s  == "111213"
	# assert (new Array[Int]).plain_to_s == "" # empty collection
	# ~~~
	fun plain_to_s: String
	do
		var s = new Buffer
		for e in self do if e != null then s.append(e.to_s)
		return s.to_s
	end

	# Concatenate and separate each elements with `separator`.
	#
	# Only concatenate if `separator == null`.
	#
	# ~~~
	# assert [1, 2, 3].join(":")    == "1:2:3"
	# assert [1..3].join(":")       == "1:2:3"
	# assert [1..3].join            == "123"
	# ~~~
	#
	# if `last_separator` is given, then it is used to separate the last element.
	#
	# ~~~
	# assert [1, 2, 3, 4].join(", ", " and ")    == "1, 2, 3 and 4"
	# ~~~
	fun join(separator: nullable Text, last_separator: nullable Text): String
	do
		if is_empty then return ""

		var s = new Buffer # Result

		# Concat first item
		var i = iterator
		var e = i.item
		if e != null then s.append(e.to_s)

		if last_separator == null then last_separator = separator

		# Concat other items
		i.next
		while i.is_ok do
			e = i.item
			i.next
			if i.is_ok then
				if separator != null then s.append(separator)
			else
				if last_separator != null then s.append(last_separator)
			end
			if e != null then s.append(e.to_s)
		end
		return s.to_s
	end
end

redef class Collection[E]
	# Cartesian product, over `r` times `self`.
	#
	# See `CartesianCollection` for details.
	#
	# FIXME: Cannot be used if RTA is enabled. So `niti` or `--erasure` only.
	fun product(r: Int): Collection[SequenceRead[E]]
	do
		return new CartesianCollection[E]([self]*r)
	end

	# All `r`-length permutations on self (all possible ordering) without repeated elements.
	#
	# See `CartesianCollection` for details.
	#
	# FIXME: Cannot be used if RTA is enabled. So `niti` or `--erasure` only.
	fun permutations(r: Int): Collection[SequenceRead[E]]
	do
		var res = new CombinationCollection[E](self, r)
		res.are_sorted = false
		res.are_unique = true
		return res
	end

	# All `r`-length combinations on self (in same order) without repeated elements.
	#
	# See `CartesianCollection` for details.
	#
	# FIXME: Cannot be used if RTA is enabled. So `niti` or `--erasure` only.
	fun combinations(r: Int): Collection[SequenceRead[E]]
	do
		var res = new CombinationCollection[E](self, r)
		res.are_sorted = true
		res.are_unique = true
		return res
	end

	# All `r`-length combination on self (in same order) with repeated elements.
	#
	# See `CartesianCollection` for details.
	#
	# FIXME: Cannot be used if RTA is enabled. So `niti` or `--erasure` only.
	fun combinations_with_replacement(r: Int): Collection[SequenceRead[E]]
	do
		var res = new CombinationCollection[E](self, r)
		res.are_sorted = true
		res.are_unique = false
		return res
	end
end

redef class Collection[E]
	# Convert Collection[String] to CURLSList
	fun to_curlslist: CURLSList
	do
		assert collectionItemType: self isa Collection[String] else
			print "Collection item must be strings."
		end
		if is_empty then return new CURLSList
		var primList = new CURLSList.with_str(self.first)
		var is_first = true
		for s in self do
			if not is_first then primList.append(s)
			is_first = false
		end
		return primList
	end
end

redef class Collection[E]
	# Type of the concurrent variant of this collection
	type CONCURRENT: ConcurrentCollection[E]

	# Wraps `self` in a thread-safe collection
	fun to_concurrent: CONCURRENT is abstract
end

redef class Collection[E]
	# Create and fill up a counter with the elements of `self.
	#
	# ~~~
	# var cpt = "abaa".chars.to_counter
	# assert cpt['a'] == 3
	# assert cpt['b'] == 1
	# assert cpt.length == 2
	# assert cpt.sum == 4
	# ~~~
	fun to_counter: Counter[E]
	do
		var res = new Counter[E]
		res.inc_all(self)
		return res
	end
end

redef class Collection[E]
	# Utility to serialize a normal Json array
	private fun serialize_to_pure_json(v: JsonSerializer)
	do
		v.stream.write "["
		var is_first = true
		for e in self do
			if is_first then
				is_first = false
			else
				v.stream.write ","
				if v.pretty_json then v.stream.write " "
			end

			if not v.try_to_serialize(e) then
				assert e != null # null would have been serialized
				v.warn("element of type {e.class_name} is not serializable.")
				v.stream.write "null"
			end
		end
		v.stream.write "]"
	end
end

redef class Collection[E]
	private fun serialize_as_inspect(v: InspectSerializer)
	do
		v.stream.write "["
		var is_first = true
		for e in self do
			if is_first then
				is_first = false
			else
				v.stream.write ", "
			end

			if not v.try_to_serialize(e) then
				assert e != null
				v.stream.write e.inspect
			end
		end
		v.stream.write "]"
	end
end