/**
	This file is a part of rexy's general purpose library
	Copyright (C) 2020 rexy712

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

	This program 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 Affero General Public License for more details.

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

#ifndef REXY_STRING_BASE_HPP
#define REXY_STRING_BASE_HPP

#include <type_traits> //is_same, integral_contant, enable_if, etc
#include <utility> //forward
#include <cstdlib> //size_t

#include "steal.hpp"
#include "cx/utility.hpp"
#include "traits.hpp"

namespace rexy{

	class string_expr{};

	//Base of all RAII strings. Its use is allowing passing of rexy strings to functions without knowing the exact type
	class string_base : public string_expr
	{
	protected:
		size_t m_length = 0;
		size_t m_cap = 0;
		char* m_data = nullptr;

	protected:
		constexpr string_base(void) = default;
		constexpr string_base(size_t len):
			m_cap(len){}
		//Initialize without copying
		constexpr string_base(char* data, size_t len):
			m_cap(len), m_data(data){}
		constexpr string_base(char* data, size_t len, size_t cap):
			m_length(len), m_cap(cap), m_data(data){}
		//Copy ctor (do nothing)
		constexpr string_base(const string_base&){}
		~string_base(void) = default;

	public:
		//Stop managing stored pointer. Does not free.
		constexpr char* release(void){return cx::exchange(m_data, nullptr);}

		//Length of string not including null terminator
		constexpr size_t length(void)const{return m_length;}
		constexpr size_t capacity(void)const{return m_cap;}
		//direct access to managed pointer
		constexpr char* get(void){return m_data;}
		constexpr const char* get(void)const{return m_data;}
		constexpr operator char*(void){return m_data;}
		constexpr operator const char*(void)const{return m_data;}
		//true if m_data is not null
		constexpr bool valid(void)const{return m_data;}

		constexpr char& operator[](size_t i){return m_data[i];}
		constexpr const char& operator[](size_t i)const{return m_data[i];}
	};


	//Supplies all functions that string_base can't implement
	template<class Allocator>
	class string_intermediary : public string_base
	{
	public:
		using allocator_type = Allocator;

	public:
		constexpr string_intermediary(void);
		constexpr string_intermediary(rexy::steal<char*> data, size_t len);
		constexpr string_intermediary(rexy::steal<char*> data, size_t len, size_t cap);
		[[deprecated]] constexpr string_intermediary(char* data, size_t len);
		string_intermediary(const char* data, size_t len);
		[[deprecated]] constexpr string_intermediary(char* data, size_t len, size_t cap);
		string_intermediary(const char* data);
		constexpr string_intermediary(rexy::steal<char*>);
		string_intermediary(size_t len);
		string_intermediary(size_t len, size_t cap);

		//normal copy and move ctors
		string_intermediary(const string_intermediary& b);
		constexpr string_intermediary(string_intermediary&& s);

		string_intermediary(const string_base& b);

		//dtor
		~string_intermediary(void);

		string_intermediary& operator=(const string_intermediary& s);
		constexpr string_intermediary& operator=(string_intermediary&& s);
		//Copy from c string
		string_intermediary& operator=(const char* c);
		//Copy from other string_base
		string_intermediary& operator=(const string_base& s);

		//Replace managed pointer. Frees existing value
		void reset(char* val = nullptr);
		void reset(char* val, size_t len);
		bool resize(size_t newsize);
		void append(const char* data, size_t len);
		void append(const char* data);
		void append(const string_base& s);

	private:
		string_intermediary& _copy_string(const char* s, size_t len);
	};

	//Like an expression template but not really
	template<class Left, class Right>
	class string_cat_expr : public string_expr
	{
	private:
		Left m_l;
		Right m_r;

	public:
		template<class T, class U>
		constexpr string_cat_expr(T&& l, U&& r);
		constexpr string_cat_expr(string_cat_expr&& s);

		constexpr size_t length(void)const;
		template<class Alloc>
		operator string_intermediary<Alloc>(void);
		constexpr const Left& left(void)const;
		constexpr const Right& right(void)const;
	};
	template<class Left, class Right>
	string_cat_expr(Left&, Right&) -> string_cat_expr<Left&,Right&>;

	template<class Left, class Right>
	string_cat_expr(Left&&,Right&&) -> string_cat_expr<Left,Right>;

	template<class Left, class Right>
	string_cat_expr(Left&,Right&&) -> string_cat_expr<Left&,Right>;

	template<class Left, class Right>
	string_cat_expr(Left&&,Right&) -> string_cat_expr<Left,Right&>;

	class static_string : public string_base
	{
	public:
		constexpr static_string(void) = default;
		constexpr static_string(const char* str, size_t len);
		constexpr static_string(const char* c);
		constexpr static_string(const static_string& s);
		constexpr static_string(static_string&& s);
		~static_string(void) = default;

		constexpr static_string& operator=(const char* c);
		constexpr static_string& operator=(const static_string& s);
		constexpr static_string& operator=(static_string&&);
	};


	namespace detail{
		template<class T>
		struct is_string{
			static constexpr bool value = rexy::is_type<T,string_expr>::value;
		};
		template<class T>
		struct is_concrete_string{
			static constexpr bool value = rexy::is_type<T,string_base>::value;
		};

		template<class... Ts>
		using enable_if_string = std::enable_if_t<(is_string<Ts>::value && ...),int>;
		template<class... Ts>
		using enable_if_concrete_string = std::enable_if_t<(is_concrete_string<Ts>::value && ...),int>;
		template<class... Ts>
		using enable_if_expr_string = std::enable_if_t<(rexy::is_template_type<Ts,string_cat_expr>::value && ...),int>;

		template<class Targ>
		struct string_appender
		{
		private:
			Targ& m_targ;
		public:
			constexpr string_appender(Targ& t);
			template<class L, class R>
			constexpr void operator()(const string_cat_expr<L,R>& str);
			template<class Str, std::enable_if_t<!rexy::is_template_type<Str,string_cat_expr>::value,int> =  0>
			constexpr void operator()(Str&& str);
		};
	} //namespace detail

	template<class Str1, class Str2, detail::enable_if_concrete_string<Str1,Str2> = 0>
	constexpr bool operator==(Str1&& left, Str2&& right){
		return left.valid() && right.valid() && left.length() == right.length() && !cx::strcmp(left.get(), right.get());
	}
	template<class Str1, class Str2, detail::enable_if_concrete_string<Str1,Str2> = 0>
	constexpr bool operator!=(Str1&& left, Str2&& right){
		return !(left == right);
	}

	template<class Left, class Right, detail::enable_if_string<Left,Right> = 0>
	constexpr auto operator+(Left&& l, Right&& r){
		return string_cat_expr(std::forward<Left>(l), std::forward<Right>(r));
	}
	template<class Right, detail::enable_if_string<Right> = 0>
	constexpr auto operator+(const char* left, Right&& right){
		return string_cat_expr(rexy::static_string(left), std::forward<Right>(right));
	}

	template<class Left, detail::enable_if_string<Left> = 0>
	constexpr auto operator+(Left&& left, const char* right){
		return rexy::string_cat_expr(std::forward<Left>(left), rexy::static_string(right));
	}

	template<class Left, class Right, detail::enable_if_concrete_string<Left> = 0, detail::enable_if_string<Right> = 0>
	decltype(auto) operator+=(Left& l, Right&& r){
		return l = (l + std::forward<Right>(r));
	}
	template<class Left, detail::enable_if_concrete_string<Left> = 0>
	decltype(auto) operator+=(Left& l, const char* r){
		return l = (l + r);
	}
}

#include "string_base.tpp"

namespace{
	constexpr inline rexy::static_string operator"" _ss(const char* str, size_t len){
		return rexy::static_string(str, len);
	}
}

#ifdef REXY_BINARY_HPP
#include "detail/binary_string_conv.hpp"
#endif

#ifdef REXY_CX_HASH_HPP
#include "cx/string_hash.hpp"
#endif

#endif