export function to(value) {
	return Array.isArray(value) ? value : [ value ];
}



export function insert(array, item, index) {
	console.assert(Array.isArray(array), array);
	console.assert(index >= 0 && index <= array.length, index);

	array.splice(index, 0, item);
}



export function insertSorted(array, item, comparator) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof comparator === "function", comparator);

	let index = array.findIndex((existing, i) => comparator(existing, i, array, item) === -1);
	if (index === -1)
		index = array.length;
	insert(array, item, index);
}



export function insertUniqueSorted(array, item, comparator) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof comparator === "function", comparator);

	let index = array.findIndex((existing, i) => item === existing || comparator(existing, i, array, item) === -1);
	if (array[index] === item)
		return false;

	if (index === -1)
		index = array.length;
	insert(array, item, index);
	return true;
}



export function filterOut(array, predicate) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof predicate === "function", predicate);

	let original = array.splice(0, array.length);
	let matched = [];
	for (let i = 0; i < original.length; ++i)
		(predicate(original[i], i) ? matched : array).push(original[i]);
	return matched;
}



export function first(array) {
	console.assert(Array.isArray(array), array);

	return array[0];
}



export function last(array) {
	console.assert(Array.isArray(array), array);

	return array[array.length - 1];
}



export function min(array, comparator) {
	return array[minIndex(array, comparator)];
}



export function minIndex(array, comparator) {
	comparator ||= function defaultComparator(a, b) {
		return a - b;
	};

	let minIndex = -1;
	for (let i = 0; i < array.length; ++i) {
		if (minIndex === -1 || comparator(array[minIndex], array[i]) > 0)
			minIndex = i;
	}
	return minIndex;
}



export function max(array, comparator) {
	return array[maxIndex(array, comparator)];
}



export function maxIndex(array, comparator) {
	comparator ||= function defaultComparator(a, b) {
		return a - b;
	};

	let maxIndex = -1;
	for (let i = 0; i < array.length; ++i) {
		if (maxIndex === -1 || comparator(array[maxIndex], array[i]) < 0)
			maxIndex = i;
	}
	return maxIndex;
}



export function removeAll(array, item) {
	removeAllMatching(array, (existing) => existing === item);
}



export function removeAllMatching(array, predicate) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof predicate === "function", predicate);

	for (let i = 0; i < array.length; ++i) {
		if (predicate(array[i], i, array))
			array.splice(i--, 1);
	}
}



export function takeAllMatching(array, predicate) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof predicate === "function", predicate);

	let removed = [ ];
	for (let i = 0; i < array.length; ++i) {
		let item = array[i];
		if (predicate(item, i, array)) {
			array.splice(i--, 1);
			removed.push(item);
		}
	}
	return removed;
}



export function takeFirstMatching(array, predicate) {
	console.assert(Array.isArray(array), array);
	console.assert(typeof predicate === "function", predicate);

	for (let i = 0; i < array.length; ++i) {
		let item = array[i];
		if (predicate(item, i, array)) {
			array.splice(i--, 1);
			return item;
		}
	}
}



export function shuffle(array) {
	console.assert(Array.isArray(array), array);

	let shuffled = [];
	while (array.length)
		shuffled.push(array.splice(Math.floor(Math.random() * array.length), 1)[0]);
	return shuffled;
}