#pragma once
#include <memory>
#include <string_view>
#include <cstring>
#include <cstdio>
#include <cstdint>
#ifdef __DEBUG
#include <stdexcept>
#endif

namespace asp {
	template<typename T>
	struct Array {
		std::shared_ptr<T[]> data;
		size_t length = 0;

		constexpr Array(void) noexcept = delete;
		constexpr Array(const size_t& size) noexcept : data(std::shared_ptr<T[]>(new T[size])), length(size) {
#ifdef __DEBUG
			printf("Creating array of size %lu\n", size);
#endif
		}

		constexpr Array(const std::initializer_list<size_t>& other) noexcept : data(std::shared_ptr<T[]>(new T[other.size()])), length(other.size()) {
#ifdef __DEBUG
			printf("Copying array of size %lu\n", other.size());
#endif
			memcpy(data.get(), other.begin(), length * sizeof(T));
		}


		constexpr Array(const Array<T>& other) noexcept : data(std::shared_ptr<T[]>(new T[other.length])), length(other.length) {
#ifdef __DEBUG
			printf("Copying array of size %lu\n", other.length);
#endif
			memcpy(data.get(), other.data.get(), length * sizeof(T));
		}

		constexpr Array(Array&& other) noexcept {
#ifdef __DEBUG
			printf("Moving array of size %lu\n", other.length);
#endif
			data = other.data;
			length = other.length;
			other.data = nullptr;
			other.length = 0;
		}

		constexpr T& operator[](const size_t& index) const {
#ifdef __DEBUG
			if (index > length) {
				fprintf(stderr, "Index %ld out of range in Array of length %ld !\n", index, length);
				throw std::out_of_range("Index out of range !");
			}
#endif
			return data.get()[index];
		}
	};

	template<typename T>
	constexpr int32_t print(const Array<T>& a, const char* const format) noexcept {
		int32_t num_written = 0;
		num_written += printf("[");
		char formatter[256] = { 0 };
		sprintf(formatter, "%s,", format);
		for (size_t i = 0; i < a.length; ++i)
			num_written += printf(formatter, a[i]);
		sprintf(formatter, "%s]\n", format);
		num_written += printf(formatter, a[a.length - 1]);
		return num_written;
	}

	constexpr int32_t print(const Array<uint16_t>& a) noexcept {
		return print(a, "%b");
	}

	constexpr int32_t print(const Array<int32_t>& a) noexcept {
		return print(a, "%i");
	}

	constexpr int32_t print(const Array<uint32_t>& a) noexcept {
		return print(a, "%u");
	}

	constexpr int32_t print(const Array<uint64_t>& a) noexcept {
		return print(a, "%lu");
	}

	constexpr int32_t print(const Array<int16_t>& a) noexcept {
		return print(a, "%i");
	}

	constexpr int32_t print(const std::string_view& s) noexcept {
		return printf("%s\n", s.data());
	}

	constexpr int32_t print(const char* const s) noexcept {
		return printf("%s\n", s);
	}

	template<typename T>
	constexpr T& max(const Array<T>& a) noexcept {
		T& max_el = a[0];
		for (size_t i = 1; i < a.length; ++i)
			if (a[i] > max_el)
				max_el = a[i];
		return max_el;
	}

	template<typename T>
	constexpr T& min(const Array<T>& a) noexcept {
		T& max_el = a[0];
		for (size_t i = 1; i < a.length; ++i)
			if (a[i] < max_el)
				max_el = a[i];
		return max_el;
	}

	template<typename T, typename F>
	constexpr Array<T>& map(Array<T>& a, const F& fnc) noexcept {
		for (size_t i = 0; i < a.length; ++i)
			a[i] = fnc(i, a[i]);
		return a;
	}

	template<typename T, typename F>
	constexpr void foreach(const Array<T>& a, const F& fnc) noexcept {
		for (size_t i = 0; i < a.length; ++i)
			fnc(i, a[i]);
	}

	inline Array<size_t> range(const size_t& n) noexcept {
		Array<size_t> a(n);
		return map(a, [](const size_t& i, const size_t&) -> const size_t& {
			return i;
		});
	}

	template<typename T>
	constexpr void swap(T* const a, T* const b) noexcept {
		const T temp = *a;
		*a = *b;
		*b = temp;
	}

	template<typename T>
	constexpr void bubble_sort(const Array<T>& a) noexcept {
		size_t j = 0;
		for (size_t i = 0; i < a.length; ++i) {
			bool swapped = false;
			for (j = i + 1; j < a.length; ++j)
				if (a[i] > a[j]) {
					swap(&a[i], &a[j]);
					swapped = true;
				}
			if (!swapped)
				break;
		}
	}

	template<typename T>
	Array<size_t> bubble_sort_arg(const Array<T>& a) noexcept {
		Array<size_t> indices = range(a.length);
		size_t j;
		for (size_t i = 0; i < a.length; ++i) {
			bool swapped = false;
			for (j = i + 1; j < a.length; ++j)
				if (a[i] > a[j]) {
					swap(&indices[i], &indices[j]);
					swap(&a[i], &a[j]);
					swapped = true;
				}
			if (!swapped)
				break;
		}
		return indices;
	}

	template<typename T>
	constexpr size_t qs_partition(const Array<T>& a, const size_t& l, const size_t& h) noexcept {
		size_t i = l - 1;
		for (size_t j = l; j <= h; ++j)
			if (a[j] < a[h])
				swap(&a[++i], &a[j]);
		swap(&a[++i], &a[h]);
		return i;
	}

	template<typename T>
	constexpr void quicksort(const Array<T>& a, const size_t& l, const size_t& h) noexcept {
		if (l >= h)
			return;

		const size_t p = qs_partition(a, l, h);
		if (p - 1 <= h)
			quicksort(a, l, p - 1);
		quicksort(a, p + 1, h);
	}

	template<typename T>
	constexpr void quicksort(const Array<T>& a) noexcept {
		quicksort(a, 0, a.length - 1);
	}

	template<typename T>
	constexpr void quicksort_iter(const Array<T>& a, const size_t& l, const size_t& h) noexcept {
		// Create an auxiliary stack

		const size_t total = h - l + 1;
		// push initial values of l and h to stack
		size_t* const stack = new size_t[total]{l, h};

		// initialize top of stack
		size_t top = 1;

		size_t low = l, high = h;

		// Keep popping from stack while is not empty
		while (top <= total) {
			// Pop h and l
			high = stack[top--];
			low = stack[top--];
			if(low >= high)
				break;

			// Set pivot element at its correct position
			// in sorted array
			const size_t p = qs_partition(a, low, high);

			// If there are elements on left side of pivot,
			// then push left side to stack
			if (p - 1 > low && p - 1 < total) {
				stack[++top] = low;
				stack[++top] = p - 1;
			}

			// If there are elements on right side of pivot,
			// then push right side to stack
			if (p + 1 < high) {
				stack[++top] = p + 1;
				stack[++top] = high;
			}
		}

		delete[] stack;
	}

	template<typename T>
	constexpr void quicksort_iter(const Array<T>& a) noexcept {
		quicksort_iter(a, 0, a.length - 1);
	}

	template<typename T>
	constexpr size_t qs_arg_partition(const Array<T>& a, const Array<size_t>& indices, const size_t& l, const size_t& h) noexcept {
		size_t i = l - 1;
		for (size_t j = l; j <= h; ++j)
			if (a[j] < a[h]){
				swap(&a[++i], &a[j]);
				swap(&indices[i], &indices[j]);
			}
		swap(&indices[++i], &indices[h]);
		swap(&a[i], &a[h]);
		return i;
	}

	template<typename T>
	constexpr void quicksort_arg(const Array<T>& a, const Array<size_t>& indices, const size_t& l, const size_t& h) noexcept {
		if (l >= h)
			return;

		const size_t p = qs_arg_partition(a, indices, l, h);
		if (p - 1 <= h)
			quicksort_arg(a, indices, l, p - 1);
		quicksort_arg(a, indices, p + 1, h);
	}

	template<typename T>
	Array<size_t> quicksort_arg(const Array<T>& other, const size_t& l, const size_t& h) noexcept {
		Array<size_t> indices = range(other.length);
		quicksort_arg(other, indices, l, h);
		return indices;
	}

	template<typename T>
	Array<size_t> quicksort_arg(const Array<T>& a) noexcept {
		return quicksort_arg(a, 0, a.length - 1);
	}

	template<typename T>
	constexpr void quicksort_arg_iter(const Array<T>& a, const Array<size_t>& indices, const size_t& l, const size_t& h) noexcept {
		// Create an auxiliary stack
		const size_t total = h - l + 1;
		// push initial values of l and h to stack
		size_t* const stack = new size_t[total]{l,h};

		// initialize top of stack
		size_t top = 1, low = l, high = h;

		// Keep popping from stack while is not empty
		while (top <= total) {
			// Pop h and l
			high = stack[top--];
			low = stack[top--];
			if(low >= high)
				break;

			// Set pivot element at its correct position
			// in sorted array
			const size_t p = qs_arg_partition(a, indices, low, high);

			// If there are elements on left side of pivot,
			// then push left side to stack
			if (p - 1 > low && p - 1 < total) {
				stack[++top] = low;
				stack[++top] = p - 1;
			}

			// If there are elements on right side of pivot,
			// then push right side to stack
			if (p + 1 < high) {
				stack[++top] = p + 1;
				stack[++top] = high;
			}
		}

		delete[] stack;
	}

	template<typename T>
	Array<size_t> quicksort_arg_iter(const Array<T>& a) noexcept {
		Array<size_t> indices = range(a.length);
		quicksort_arg_iter(a, indices, 0, a.length - 1);
		return indices;
	}

	template<typename T>
	struct ArgVal {
		size_t indice;
		T val;

		constexpr ArgVal(void) noexcept = default;
		constexpr ArgVal(const size_t& _i, const T& _v) noexcept : indice(_i), val(_v) {}

		constexpr bool operator>(const ArgVal<T>& other) const noexcept {
			return std::move(val > other.val);
		}
		constexpr bool operator<(const ArgVal<T>& other) const noexcept {
			return std::move(val < other.val);
		}
		constexpr bool operator>=(const ArgVal<T>& other) const noexcept {
			return std::move(val >= other.val);
		}
		constexpr bool operator<=(const ArgVal<T>& other) const noexcept {
			return std::move(val <= other.val);
		}
	};

	template<typename T>
	constexpr void merge(const Array<T>& a, const size_t& l, const size_t& m, const size_t& r) noexcept {

		Array<T> left_arr(m - l + 1);
		memcpy(&left_arr.data[0], &a[l], left_arr.length * sizeof(T));
		Array<T> right_arr(r - m);
		memcpy(&right_arr.data[0], &a[m + 1], right_arr.length * sizeof(T));

		size_t i_a0 = 0, i_a1 = 0, i = l;

		// Merge the temp arrays back size_to array[left..right]
		for (; i_a0 < left_arr.length && i_a1 < right_arr.length; ++i)
			a[i] = left_arr[i_a0] <= right_arr[i_a1] ? left_arr[i_a0++] : right_arr[i_a1++];
		//
		// Copy the remaining elements of left[], if there are any
		const size_t leftover = left_arr.length - i_a0;
		memcpy(&a[i], &left_arr[i_a0], leftover * sizeof(T));
		// Copy the remaining elements of right[], if there are any
		memcpy(&a[i + leftover], &right_arr[i_a1], (right_arr.length - i_a1) * sizeof(T));
	}

	template<typename T>
	constexpr void mergesort(const Array<T>& a, const size_t& l, const size_t& r) noexcept {
		if (l >= r)
			return;

		const size_t m = l + (r - l) / 2;
		mergesort(a, l, m);
		mergesort(a, m + 1, r);
		merge(a, l, m, r);
	}

	template<typename T>
	constexpr void mergesort(const Array<T>& a) noexcept {
		mergesort(a, 0, a.length - 1);
	}

	template<typename T>
	Array<size_t> mergesort_arg(const Array<T>& a, const size_t& l, const size_t& r) noexcept {

		Array<ArgVal<T>> temp_vals(a.length);
		map(temp_vals, [&a](const size_t& i, const ArgVal<T>&) -> const ArgVal<T> {
			return ArgVal<T>(i, a[i]);
		});

		mergesort(temp_vals, l, r);

		Array<size_t> indices(a.length);
		return std::move(map(indices, [&temp_vals](const size_t& i, const size_t&) -> size_t {
			return temp_vals[i].indice;
		}));
	}

	template<typename T>
	Array<size_t> mergesort_arg(const Array<T>& a) noexcept {
		return mergesort_arg(a, 0, a.length - 1);
	}

	template<typename T>
	constexpr void insertion_sort(const Array<T>& a) noexcept {
		size_t j = 0;
		for(size_t i = 1; i < a.length; ++i) {
			T key = a[i];
			for(j = i; j > 0 && a[j - 1] > key; --j)
				a[j] = a[j - 1];
			a[j] = key;
		}
	}

	template<typename T>
	Array<size_t> insertion_argsort(const Array<T>& a) noexcept {
		Array<size_t> indices = range(a.length);
		size_t j = 0;
		for(size_t i = 1; i < a.length; ++i){
			for(j = i; j > 0 && a[indices[j - 1]] > a[indices[i]]; --j)
				indices[j] = indices[j - 1];
			indices[j] = i;
		}
		return indices;
	}

	template<typename T>
	constexpr void counting_sort(const Array<T>& a) noexcept {
		const size_t N = a.length;
		const T M = max(a);

		const T exp = 10;
		const T d = 128;

		Array<T> countArray(M);
		memset(&countArray[0], 0, M * sizeof(T));

		foreach(a, [&countArray](const size_t, const T val) -> void {
			++countArray[val];
		});

		for (T i = 1; i <= M; ++i)
			countArray[i] += countArray[i - 1];

		Array<T> output(N);
		for (size_t i = N - 1; i > 0; --i){
			output[countArray[a[i]] - 1] = a[i];
			--countArray[a[i]];
		}
		memmove(&a[0], &output[0], a.length * sizeof(T));
	}

	template<typename T>
	Array<size_t> counting_sort_arg(const Array<T>& a) noexcept {
		Array<size_t> indices = range(a.length);

		return indices;
	}

	inline void countsort(int a[], int n, int pos){
		int* output = new int[n + 1];
		int max = (a[0] / pos) % 10;
		for (int i = 1; i < n; i++) {
			if (((a[i] / pos) % 10) > max)
				max = a[i];
		}
		int* count = new int[max + 1];
		for (int i = 0; i < max; ++i)
			count[i] = 0;
		for (int i = 0; i < n; i++)
			count[(a[i] / pos) % 10]++;
		for (int i = 1; i < 10; i++)
			count[i] += count[i - 1];
		for (int i = n - 1; i >= 0; i--) {
			output[count[(a[i] / pos) % 10] - 1] = a[i];
			count[(a[i] / pos) % 10]--;
		}
		for (int i = 0; i < n; i++)
			a[i] = output[i];

		delete[] output;
		delete[] count;
	}

	// template<typename T>
	// constexpr void radix_sort_256(T* a, const size_t& n) noexcept {
	// 	//template<typename T>
	// 	//void radix_sort(const Array<int32_t>& a) noexcept {
	// 	if (n <= 1)
	// 		//if (a.length <= 1)
	// 		return;
	//
	// 	T* output = new T[n]; // output array
	// 	size_t* const count = new size_t[256];
	// 	T* originalArr = a; // So we know which was input
	//
	// 	for (size_t shift = 0, s = 0; shift < 4; shift++, s += 8) {
	// 		// Zero the counts
	// 		for (size_t i = 0; i < 256; i++)
	// 			count[i] = 0;
	//
	// 		// Store count of occurrences in count[]
	// 		for (size_t i = 0; i < n; i++)
	// 			count[(a[i] >> s) & 0xff]++;
	//
	// 		// Change count[i] so that count[i] now contains
	// 		// actual position of this digit in output[]
	// 		for (size_t i = 1; i < 256; i++)
	// 			count[i] += count[i - 1];
	//
	// 		// Build the output array
	// 		for (int32_t i = n - 1; i >= 0; i--) {
	// 			// precalculate the offset as it's a few instructions
	// 			const size_t idx = (a[i] >> s) & 0xff;
	//
	// 			// Subtract from the count and store the value
	// 			output[--count[idx]] = a[i];
	// 		}
	//
	// 		// Copy the output array to input[], so that input[]
	// 		// is sorted according to current digit
	//
	// 		// We can just swap the pointers
	// 		swap(a, output);
	// 	}
	//
	// 	// If we switched posize_ters an odd number of times,
	// 	// make sure we copy before returning
	// 	if (originalArr == output) {
	// 		swap(a, output);
	// 		for (size_t i = 0; i < n; i++)
	// 			a[i] = output[i];
	// 	}
	//
	// 	delete[] output, delete[] count;
	// }

	constexpr void radix_sort_256(int32_t a[], int n){
		int max = a[0];
		for (int i = 1; i < n; i++)
			if (a[i] > max)
				max = a[i];
		for (int pos = 1; max / pos > 0; pos *= 10)
			countsort(a, n, pos);
	}

	template<typename T>
	constexpr void radix_sort(const Array<T>& a) noexcept {
		radix_sort_256(a.data.get(), a.length);
	}

	// template<typename T>
	// constexpr Array<size_t> radix_sort_arg(const Array<T>& a) noexcept {
	// 	Array<T> indices = range(a.length);
	//
	// 	return indices;
	// }
};