/*
	This file is part of Fennix Kernel.

	Fennix Kernel is free software: you can redistribute it and/or
	modify it under the terms of the GNU General Public License as
	published by the Free Software Foundation, either version 3 of
	the License, or (at your option) any later version.

	Fennix Kernel is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/

#pragma once
#include <utility>

namespace std
{
	template <typename InputIt, typename OutputIt>
	OutputIt copy(InputIt first, InputIt last, OutputIt result)
	{
		while (first != last)
		{
			*result = *first;
			++result;
			++first;
		}
		return result;
	}

	template <typename T>
	void swap(T &a, T &b)
	{
		T temp = move(a);
		a = move(b);
		b = move(temp);
	}

	template <typename T>
	constexpr const T &min(const T &a, const T &b)
	{
		return (a < b) ? a : b;
	}

	template <typename T>
	constexpr const T &max(const T &a, const T &b)
	{
		return (a > b) ? a : b;
	}

	template <typename T>
	constexpr const T &clamp(const T &v, const T &lo, const T &hi)
	{
		return std::max(lo, std::min(v, hi));
	}

	template <class T, class Compare>
	constexpr const T &clamp(const T &v, const T &lo, const T &hi, Compare comp)
	{
		return comp(v, lo) ? lo : comp(hi, v) ? hi
											  : v;
	}

	template <class InputIt, class T>
	constexpr InputIt find(InputIt first, InputIt last, const T &value)
	{
		for (; first != last; ++first)
			if (*first == value)
				return first;

		return last;
	}

	template <class InputIt, class UnaryPredicate>
	constexpr InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
	{
		for (; first != last; ++first)
			if (p(*first))
				return first;

		return last;
	}

	template <class InputIt, class UnaryPredicate>
	constexpr InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
	{
		for (; first != last; ++first)
			if (!q(*first))
				return first;

		return last;
	}

	template <class ForwardIt, class T>
	ForwardIt remove(ForwardIt first, ForwardIt last, const T &value)
	{
		first = std::find(first, last, value);
		if (first != last)
			for (ForwardIt i = first; ++i != last;)
				if (!(*i == value))
					*first++ = std::move(*i);
		return first;
	}

	template <class ForwardIt, class UnaryPredicate>
	ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPredicate p)
	{
		first = std::find_if(first, last, p);
		if (first != last)
			for (ForwardIt i = first; ++i != last;)
				if (!p(*i))
					*first++ = std::move(*i);
		return first;
	}

	template <class ForwardIt, class T>
	void fill(ForwardIt first, ForwardIt last, const T &value)
	{
		for (; first != last; ++first)
			*first = value;
	}
}