#pragma once

#include <utility>

#include <common.h>

namespace util {
	enum class bound 
	{
		Inclusive = 0,
		Exclusive
	};

	struct bounds
	{	
		bound low, high;
	};
	constexpr inline const bounds default_bounds { bound::Inclusive, bound::Exclusive };

	template<typename T, bounds B = default_bounds>
	struct range
	{
		constexpr static inline const bounds Bounds = B;
		using type = T;
		//constexpr inline range(T start, T end) : start(start), end(end){}
		constexpr inline range(T&& start, T&& end) : start(std::move(start)), end(std::move(end)){}
		constexpr inline range(const T& start, const T& end) : start(start), end(end){}

		constexpr inline range(range<T>&& move) : start(std::move(move.start)), end(std::move(move.end)) {}
		constexpr inline range(const range<T>& copy) : start(copy.start), end(copy.end){}

		constexpr inline ~range() {}

		constexpr inline auto length() const { return end-start; }

		constexpr inline auto length(const T& from) const { return from - start; }

		constexpr inline bool negative() const { return length() < 0; }	

		constexpr inline range<T>& normalise() {
			if(negative()) std::swap(start, end);
			return *this;
		}

		template<usize I>
			requires (I < 2)
		constexpr inline T& get() { return I ? end : start; }
		template<usize I>
			requires (I < 2)
		constexpr inline const T& get() const { return I ? end : start; }

		constexpr inline bool contains(const T& value) const
		{
			return	(Bounds.low == bound::Exclusive
					? value >  start
					: value >= start) &&
				(Bounds.high == bound::Exclusive 
					? value <  end
					: value <= end);
		}

		constexpr inline void clamp(T& value) const
		{
			if constexpr(Bounds.low == bound::Exclusive) {
				if (value <= start) value = start + 1;
			} else  if (value <  start) value = start;
			if constexpr(Bounds.high == bound::Exclusive) {
				if (value >= end)   value = end   - 1;
			} else  if (value >  end)   value = end;
		}

		// Scale the `value` from this range to another one (of a compatable type).
		template<typename U>
		constexpr inline auto scale(const range<U>& to, T value)
		{
			clamp(value);
			const auto diff = length(value);
			const f64 fract = f64(diff) / f64(length());
			const auto diff2 = typename range<U>::type(fract * f64(to.length()));
			
			return to.start + diff2;
		}
		constexpr inline auto scale(const range<T>& to, T value) { return scale<T>(to, value); }

		T start, end;
	}; 
}

// -- old
#if 0

namespace util{
enum class bound
{
	Inclusive,
	Exclusive,
};
template<typename T> struct range;

using bounds = range<bound>;

constexpr static inline const bounds default_bounds();

template<typename T>
struct range final
{
	using type = T;
	//constexpr inline range(T start, T end) : start(start), end(end){}
	constexpr inline range(T&& start, T&& end) : start(std::move(start)), end(std::move(end)){}
	constexpr inline range(const T& start, const T& end) : start(start), end(end){}

	constexpr inline range(range<T>&& move) : start(std::move(move.start)), end(std::move(move.end)) {}
	constexpr inline range(const range<T>& copy) : start(copy.start), end(copy.end){}

	constexpr inline ~range() {}

	constexpr inline auto length() const { return end-start; }

	constexpr inline auto length(const T& from) const { return from - start; }

	constexpr inline bool negative() const { return length() < 0; }	

	constexpr inline range<T>& normalise() {
		if(negative()) std::swap(start, end);
		return *this;
	}

	template<usize I>
		requires (I < 2)
	constexpr inline T& get() { return I ? end : start; }
	template<usize I>
		requires (I < 2)
	constexpr inline const T& get() const { return I ? end : start; }

	template<bounds Bounds = default_bounds()>
	constexpr inline bool contains(const T& value) const
	{
		return	(Bounds.get<0>() == bound::Exclusive
				? value >  start
				: value >= start) &&
			(Bounds.get<1>() == bound::Exclusive 
				? value <  end
				: value <= end);
	}

	template<bounds Bounds = default_bounds()>
	constexpr inline void clamp(T& value) const
	{
		if constexpr(Bounds.get<0>() == bound::Exclusive) {
			if (value <= start) value = start + 1;
		} else  if (value <  start) value = start;
		if constexpr(Bounds.get<1>() == bound::Exclusive) {
			if (value >= end)   value = end   - 1;
		} else  if (value >  end)   value = end;
	}

	// Scale the `value` from this range to another one (of a compatable type).
	template<bounds Bounds = default_bounds()>
	constexpr inline auto scale(const range<auto>& to, T value)
	{
		clamp<Bounds>(value);
		const auto diff = length(value);
		const f64 fract = f64(diff) / f64(length());
		const auto diff2 = decltype(to)::type(fract * f64(to.length()));
		
		return to.start + diff2;
	}
	template<bounds Bounds>
	constexpr inline auto scale(const range<T>& to, T value);	

	T start, end;
};

constexpr static inline const bounds default_bounds() { return { bound::Inclusive, bound::Exclusive }; }
}
#endif