#pragma once
 
#ifndef SPRAWL_STRING_NO_STL_COMPAT
#	include <string>
#	include "../hash/Murmur3.hpp"
#endif
 
#include "StringCommon.hpp"
#include "StringBuilder.hpp"
#include <stdint.h>
#include <unordered_map>
 
#include <atomic>
 
namespace sprawl
{
	class StringLiteral;
 
	class String
	{
	public:
		class Holder
		{
		protected:
			friend class String;
 
			Holder();
			Holder(const char* data);
			Holder(const char* data, size_t length);
			Holder(StringLiteral const& literal);
 
			void IncRef();
			bool DecRef();
 
			static Holder* CreateHolder();
			static void FreeHolder(Holder* holder);
 
			~Holder();
 
			inline size_t GetHash() const
			{
				if(m_hashComputed)
				{
					return m_hash;
				}
 
				m_hash = sprawl::murmur3::Hash( m_data, m_length );
				m_hashComputed = true;
				return m_hash;
			}
 
			static constexpr size_t staticDataSize = SPRAWL_STATIC_STRING_SIZE;
 
			char m_staticData[staticDataSize];
			char* m_dynamicData;
			const char* m_data;
			std::atomic<int> m_refCount;
			size_t m_length;
			mutable size_t m_hash;
			mutable bool m_hashComputed;
		private:
			Holder(Holder const& other);
			Holder& operator=(Holder const& other);
		};
 
		String();
		String(const char* const data);
		String(const char* const data, size_t length);
 
		String(String const& other);
		String(String&& other);
 
#ifndef SPRAWL_STRING_NO_STL_COMPAT
		String(std::string const& stlString);
#endif
 
		String(StringLiteral const& stringLiteral);
 
		~String();
 
		inline size_t GetHash() const
		{
			return m_holder->GetHash();
		}
 
#ifndef SPRAWL_STRING_NO_STL_COMPAT
		std::string toStdString() const;
#endif
 
		const char* c_str() const
		{
			return m_holder->m_data;
		}
 
		size_t length() const
		{
			return m_holder->m_length;
		}
 
		String& operator=(String const& other);
		String& operator=(String&& other);
 
		inline bool operator==(String const& other) const
		{
			return (m_holder == other.m_holder) || ((m_holder->m_length == other.m_holder->m_length) && (SPRAWL_MEMCMP(m_holder->m_data, other.m_holder->m_data, m_holder->m_length) == 0));
		}
 
		bool operator!=(String const& other) const
		{
			return !operator==(other);
		}
 
		sprawl::String operator+(sprawl::String const& other) const;
 
		sprawl::String operator+(const char* other) const;
 
		sprawl::String& operator+=(sprawl::String const& other);
 
		sprawl::String& operator+=(const char* other);
 
		bool empty() const
		{
			return m_holder->m_length == 0;
		}
 
		bool operator<(String const& other) const;
 
		char const& operator[](size_t index) const
		{
			return m_holder->m_data[index];
		}
 
		String GetOwned() const;
 
		template<typename... Params>
		String format(Params const& ...params)
		{
#if !SPRAWL_STRINGBUILDER_FAVOR_SPEED_OVER_MEMORY
			StringBuilder nullBuilder(0);
 
			ExecuteFormat(nullBuilder, params...);
 
			size_t const length = nullBuilder.Size();
 
			StringBuilder builder(length, false);
#else
			size_t const startingLength = m_holder->m_length * 2 + 1;
 
			StringBuilder builder(startingLength, true);
#endif
 
			ExecuteFormat(builder, params...);
 
			return builder.Str();
		}
 
	private:
		template<int idx, typename... Params>
		class FormatHelper;
 
		template<int idx>
		class FormatHelper<idx>
		{
		public:
			void Append(int pos, StringBuilder& builder, char* modifiers)
			{
				(void)(pos);
				(void)(modifiers);
				builder << "< ??? >";
			}
		};
 
		template<int idx, typename T>
		class FormatHelper<idx, T> : public FormatHelper<idx + 1>
		{
		public:
			typedef FormatHelper<idx + 1> Base;
			FormatHelper(T const& val)
				: Base()
				, m_value(val)
			{
				//
			}
 
			void Append(int pos, StringBuilder& builder, char* modifiers)
			{
				if(pos == idx)
				{
					builder.AppendElementToBuffer(m_value, modifiers);
				}
				else
				{
					Base::Append(pos, builder, modifiers);
				}
			}
 
		private:
			T const& m_value;
		};
 
		template<int idx, typename T, typename... Params>
		class FormatHelper<idx, T, Params...> : public FormatHelper<idx + 1, Params...>
		{
		public:
			typedef FormatHelper<idx + 1, Params...> Base;
			FormatHelper(T const& val, Params const& ...values)
				: Base(values...)
				, m_value(val)
			{
				//
			}
 
			void Append(int pos, StringBuilder& builder, char* modifiers)
			{
				if(pos == idx)
				{
					builder.AppendElementToBuffer(m_value, modifiers);
				}
				else
				{
					Base::Append(pos, builder, modifiers);
				}
			}
 
		private:
			T const& m_value;
		};
 
		template<typename... Params>
		void ExecuteFormat(	StringBuilder& builder, Params const& ...params)
		{
			FormatHelper<0, Params...> helper(params...);
 
			int curIdx = -1;
			size_t lastIdx = 0;
 
			bool inBracket = false;
 
			char modifiers[10];
			size_t modifierPos = 0;
			bool inModifiers = false;
 
			size_t const formatLength = m_holder->m_length;
			char const* const data = m_holder->m_data;
 
			for(size_t i = 0; i < formatLength; ++i)
			{
				const char c = data[i];
				if(c == '{')
				{
					if(inBracket)
					{
						builder << '{';
					}
					inBracket = !inBracket;
					continue;
				}
 
				if(inBracket)
				{
					if(c == '}')
					{
						modifiers[modifierPos] = '\0';
 
						if(curIdx == -1)
						{
							helper.Append(lastIdx, builder, modifiers);
							++lastIdx;
						}
						else
						{
							helper.Append(curIdx, builder, modifiers);
							lastIdx = curIdx + 1;
						}
						modifiers[0] = '\0';
						modifierPos = 0;
						curIdx = -1;
						inBracket = false;
						inModifiers = false;
					}
					else if(c == ':' && !inModifiers)
					{
						inModifiers = true;
					}
					else if(inModifiers)
					{
						modifiers[modifierPos++] = c;
					}
					else if(isdigit(c))
					{
						if(curIdx == -1)
						{
							curIdx = c - '0';
						}
						else
						{
							curIdx *= 10;
							curIdx += c - '0';
						}
					}
					else
					{
						builder << '{';
						if(curIdx != -1)
						{
							builder << curIdx;
						}
						builder << c;
						inBracket = false;
					}
					continue;
				}
 
				builder << c;
			}
		}
 
	private:
		Holder* m_holder;
		static Holder ms_emptyHolder;
	};
 
	class StringLiteral
	{
	public:
		template<size_t N>
		StringLiteral(const char (&ptr)[N])
			: m_ptr(ptr)
			, m_length(N-1)
		{
			//
		}
 
		explicit StringLiteral(const char* ptr, size_t length)
			: m_ptr(ptr)
			, m_length(length)
		{
			//
		}
 
		const char* GetPtr() const { return m_ptr; }
		size_t GetLength() const { return m_length; }
		bool operator==(StringLiteral const& other) const { return m_ptr == other.m_ptr; }
		bool operator!=(StringLiteral const& other) const { return m_ptr != other.m_ptr; }
 
	protected:
		friend class String::Holder;
		char const* m_ptr;
		size_t m_length;
	};
	typedef StringLiteral StringRef;
 
	template<typename... Params>
	sprawl::String Format(const char* const text, Params&&... params)
	{
		return sprawl::String(sprawl::StringLiteral(text, strlen(text))).format(std::forward<Params>(params)...);
	}
}
 
#ifndef SPRAWL_STRING_NO_STL_COMPAT
namespace std
{
	template<>
	struct hash<sprawl::String>
	{
		typedef sprawl::String argument_type;
		typedef std::size_t value_type;
 
		inline value_type operator()(argument_type const& str) const
		{
			return str.GetHash();
		}
	};
 
	template<>
	struct hash<sprawl::StringLiteral>
	{
		typedef sprawl::StringLiteral argument_type;
		typedef std::size_t value_type;
 
		inline value_type operator()(argument_type const& str) const
		{
			return sprawl::murmur3::HashPointer(intptr_t(str.GetPtr()));
		}
	};
}
#endif
 
#ifndef _WIN32
#ifndef SPRAWL_NO_FORMAT_LITERAL
namespace sprawl
{
	namespace detail
	{
		class FormatHelper
		{
		public:
			template<size_t N>
			FormatHelper(const char (&ptr)[N])
				: m_str(StringLiteral(ptr))
			{
				//
			}
 
			explicit FormatHelper(const char* ptr, size_t length)
			: m_str(StringLiteral(ptr, length))
			{
				//
			}
 
			template<typename... Params>
			sprawl::String operator()(Params&&... params)
			{
				return m_str.format(std::forward<Params>(params)...);
			}
 
		private:
			String m_str;
		};
	}
}
 
inline sprawl::detail::FormatHelper operator "" _format(const char *ptr, size_t length)
{
	return sprawl::detail::FormatHelper(ptr, length);
}
 
#endif
#endif