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

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU 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 General Public License for more details.

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

#ifndef REXY_STRING_BASE_TPP
#define REXY_STRING_BASE_TPP

#include <utility> //move, etc
#include <type_traits> //is_nothrow_invokable, is_nothrow_constructible

#include "utility.hpp" //max, memcpy, strlen
#include "detail/string_appender.hpp"
#include "algorithm.hpp"
#include "compat/to_address.hpp"
#include "string_view.hpp"

#include "compat/string_base.hpp"

namespace rexy{

	template<class Char>
	constexpr auto string_base<Char>::search(const string_base& s)const -> const_iterator{
		return two_way_search(cbegin(), cend(), s.begin(), s.end());
	}
	template<class Char>
	constexpr auto string_base<Char>::search(const_pointer c)const -> const_iterator{
		const auto len = rexy::strlen(c);
		return two_way_search(cbegin(), cend(), c, c + len);
	}
	template<class Char>
	constexpr auto string_base<Char>::search(const string_base& s) -> iterator{
		return two_way_search(begin(), end(), s.begin(), s.end());
	}
	template<class Char>
	constexpr auto string_base<Char>::search(const_pointer c) -> iterator{
		const auto len = rexy::strlen(c);
		return two_way_search(begin(), end(), c, c + len);
	}
	template<class Char>
	template<class Searcher>
	constexpr auto string_base<Char>::search(const string_base& s, const Searcher& searcher)const -> const_iterator{
		return searcher(cbegin(), cend(), s.begin(), s.end());
	}
	template<class Char>
	template<class Searcher>
	constexpr auto string_base<Char>::search(const_pointer c, const Searcher& searcher)const -> const_iterator{
		const auto len = rexy::strlen(c);
		return searcher(cbegin(), cend(), c, c + len);
	}
	template<class Char>
	template<class Searcher>
	constexpr auto string_base<Char>::search(const string_base& s, const Searcher& searcher) -> iterator{
		return searcher(begin(), end(), s.begin(), s.end());
	}
	template<class Char>
	template<class Searcher>
	constexpr auto string_base<Char>::search(const_pointer c, const Searcher& searcher) -> iterator{
		const auto len = rexy::strlen(c);
		return searcher(begin(), end(), c, c + len);
	}


	//allocate string if longer than small string capacity, copy otherwise
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::_copy_construct_string(const_pointer data, size_type len, size_type cap)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(cap > this->get_short_capacity()){
			this->set_islong_flag(true);
			pointer raw = this->set_long_ptr(this->allocate(sizeof(value_type)*(cap+1)));
			if(data)
				rexy::memcpy(raw, data, sizeof(value_type)*len);
			raw[len] = 0;
			this->set_long_length(len);
			this->set_long_capacity(cap);
		}else{
			this->set_islong_flag(false);
			pointer raw = this->set_short_ptr();
			if(data)
				rexy::memcpy(raw, data, sizeof(value_type)*len);
			raw[len] = 0;
			this->set_short_length(len);
			this->set_short_capacity(cap);
		}
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>::basic_string(void)noexcept{}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>::basic_string(rexy::steal<pointer> data)noexcept:
		basic_string(data.value(), data.value() ? rexy::strlen(data.value()) : 0){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>::basic_string(rexy::steal<pointer> data, size_type len)noexcept:
		string_base<Char>(data.value(), len, len){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>::basic_string(rexy::steal<pointer> data, size_type len, size_type cap)noexcept:
		string_base<Char>(data.value(), len, cap){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data, size_type len, size_type cap)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		_copy_construct_string(data, len, cap);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data, size_type len)
		noexcept(is_nothrow_allocator_v<Alloc>):
		basic_string(data, len, len){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data)
		noexcept(is_nothrow_allocator_v<Alloc>):
		basic_string(data, data ? rexy::strlen(data) : 0){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(size_type cap)
		noexcept(is_nothrow_allocator_v<Alloc>):
		basic_string(size_type{0}, cap){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(size_type len, size_type cap)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		_copy_construct_string(nullptr, len, cap);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const basic_string_view<Char>& sv)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		_copy_construct_string(sv.c_str(), sv.length(), sv.length());
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class InputIt>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(InputIt start, InputIt fin)
		noexcept(is_nothrow_allocator_v<Alloc>):
		basic_string(nullptr, size_type{fin - start})
	{
		auto raw = this->get_pointer();
		size_type i = 0;
		for(auto it = start;it != fin;++it,++i){
			raw[i] = *it;
		}
		raw[i] = 0;
	}
	//normal copy and move ctors
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const basic_string& b)
		noexcept(is_nothrow_allocator_v<Alloc>):
		detail::hasallocator<Alloc>(b)
	{
		_copy_construct_string(b.get(), b.length(), b.length());
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>::basic_string(basic_string&& s)noexcept:
		detail::hasallocator<Alloc>(std::move(s)),
		string_base<Char>(std::move(s)){}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const string_base<Char>& b)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		_copy_construct_string(b.get(), b.length(), b.length());
	}

	//dtor
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::~basic_string(void)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(this->islong()){
			this->deallocate(this->get_pointer(), sizeof(value_type)*(this->get_long_capacity()+1));
		}
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const basic_string& s)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(s.length() < this->capacity()){
			rexy::memcpy(this->get_pointer(), s.get_pointer(), sizeof(value_type)*(s.length()+1));
			this->set_length(s.length());
			return *this;
		}else{
			basic_string tmp(s);
			return (*this = std::move(tmp));
		}
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(basic_string&& s)noexcept{
		string_base<Char>::operator=(std::move(s));
		return *this;
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const string_base<Char>& s)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		return (*this = basic_string(s));
	}
	//Copy from c string
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const basic_string_view<Char>& sv)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		return _copy_string(sv.c_str(), sv.length());
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const_pointer c)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		return _copy_string(c, rexy::strlen(c));
	}

	//Replace managed pointer. Frees existing value
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::reset(pointer val)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		reset(val, val ? rexy::strlen(val) : 0);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::reset(pointer val, size_type len)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(this->islong())
			this->deallocate(this->get_long_ptr(),sizeof(value_type)*(this->get_long_capacity()+1));
		this->set_islong_flag(true);
		this->set_long_ptr(val);
		this->set_long_length(len);
		this->set_long_capacity(len);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR bool basic_string<Char,Alloc>::resize(size_type newsize)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(newsize < this->capacity())
			return false;
		if(!this->islong() && newsize < this->get_short_capacity())
			return false;
		return (*this = basic_string(this->get_pointer(), newsize));
	}


	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, size_type insert_count, value_type v)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		struct insert_adapter{
			size_type max;
			value_type val;

			constexpr insert_adapter& operator++(void)noexcept{
				--max;
				return *this;
			}
			constexpr value_type operator*(void)const noexcept{
				return val;
			}

			constexpr bool operator==(const insert_adapter& other)const = default;
			constexpr bool operator!=(const insert_adapter& other)const = default;
		};

		return insert(pos, insert_adapter{insert_count, v}, insert_adapter{0, v});
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, value_type v)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, size_type{1}, v);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const_pointer str)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		const size_type slen = rexy::strlen(str);
		return insert(pos, str, str + slen);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const_pointer str, size_type insert_count)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, str, str + insert_count);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const basic_string& other)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, other.begin(), other.end());
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const basic_string& other, size_type index_str, size_type count)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, other.begin() + index_str, other.begin() + index_str + count);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(const_iterator pos, value_type v)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, size_type{1}, v);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(const_iterator pos, size_type count, value_type v)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos - this->begin(), count, v);
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class InIt>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(const_iterator pos, InIt start, InIt last)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos - this->begin(), std::move(start), std::move(last));
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(const_iterator pos, std::initializer_list<value_type> list)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		return insert(pos, list.begin(), list.end());
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class StringView>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const StringView& sv)noexcept(is_nothrow_allocator_v<Alloc>) ->
		std::enable_if_t<std::is_convertible_v<const StringView&, basic_string_view<value_type>> && !std::is_convertible_v<const StringView&,const_pointer>>
	{
		return insert(pos, sv.begin(), sv.end());
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class StringView>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, const StringView& sv, size_type index_str, size_type count)noexcept(is_nothrow_allocator_v<Alloc>) ->
		std::enable_if_t<std::is_convertible_v<const StringView&, basic_string_view<value_type>> && !std::is_convertible_v<const StringView&,const_pointer>>
	{
		return insert(pos, sv.begin() + index_str, sv.begin() + index_str + count);
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class InIt>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::insert(size_type pos, InIt start, InIt last)noexcept(is_nothrow_allocator_v<Alloc>) -> basic_string&{
		const size_type len = this->length();
		size_type insert_count = 0;
		for(auto it = start;it != last;++it, ++insert_count){}
		resize(rexy::max(pos + insert_count, len + insert_count));

		const size_type move_count = rexy::min<size_type>(0, len - pos);
		const auto ptr = this->get_pointer();

		for(size_type i = move_count+1;i > 0;--i){
			const size_type index = i + pos;
			ptr[index] = ptr[index-1];
		}
		{
			size_type i = 0;
			for(auto it = start;it != last;++it,++i){
				ptr[pos+i] = *it;
			}
		}
		this->set_length(len + insert_count);
		return *this;
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::push_back(value_type data)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		append(&data, 1);
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(const_pointer data, size_type len)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		size_type mylen = this->length();
		size_type mycap = this->capacity();
		pointer raw = this->get_pointer();

		if(mylen+len <= mycap){
			rexy::memcpy(raw+mylen, data, sizeof(value_type)*len);
			this->set_length(mylen+len);
			raw[mylen+len] = 0;
		}else{
			auto newsize = max(mylen+len, mycap*2);
			basic_string tmp(newsize);
			tmp.append(raw, mylen);
			tmp.append(data, len);
			*this = std::move(tmp);
		}
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(const_pointer data)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		if(data)
			append(data, rexy::strlen(data));
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<class InputIt>
	REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(InputIt start, InputIt fin)
		noexcept(is_nothrow_allocator_v<Alloc>)
	{
		size_type append_len = fin - start;

		size_type my_len = this->length();
		size_type my_cap = this->capacity();
		pointer raw = this->get_pointer();

		if(my_len + append_len > my_cap){
			*this = basic_string(raw, my_len, max(my_len+append_len, my_cap*2));
			raw = this->get_pointer();
			my_cap *= 2;
		}

		size_type i = 0;
		for(auto it = start;it != fin;++it,++i){
			raw[my_len + i] = *it;
		}
		this->set_length(my_len + append_len);
		raw[my_len + i] = 0;
	}


	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	template<REXY_ALLOCATOR_CONCEPT A>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::substring(size_type start, size_type end)const -> basic_string<value_type,A>{
		if(start > end || end > this->length())
			return {};
		const size_type newlen = end - start;
		basic_string<value_type,Alloc> tmp(newlen);
		tmp.append(this->get() + start, newlen);
		return tmp;
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::substr(size_type start, size_type end)const -> basic_string{
		return substring<allocator_type>(start, end);
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::release(void)noexcept(is_nothrow_allocator_v<Alloc>) -> pointer{
		if(this->islong()){
			pointer raw = this->get_long_ptr();
			this->set_islong_flag(false);
			this->set_short_ptr();
			this->set_short_length(0);
			return raw;
		}
		size_type len = this->get_short_length();
		pointer raw = this->get_short_ptr();
		pointer retval = this->allocate(sizeof(value_type)*len+1);
		rexy::memcpy(retval, raw, sizeof(value_type)*len);
		retval[len] = 0;
		raw[0] = 0;
		this->set_short_length(0);
		return retval;
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr auto basic_string<Char,Alloc>::create_view(void)const noexcept -> basic_string_view<value_type>{
		const auto ptr = this->get_pointer();
		return basic_string_view<value_type>(ptr, ptr + this->length());
	}
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	constexpr auto basic_string<Char,Alloc>::create_view(const_iterator start, const_iterator fin)const noexcept -> basic_string_view<value_type>{
		return basic_string_view<value_type>(start, fin);
	}

	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::_copy_string(const_pointer s, size_type len)
		noexcept(is_nothrow_allocator_v<Alloc>)
		{
		if(!s || !len)
			return (*this = basic_string(rexy::steal<pointer>(nullptr), 0, 0));
		if(len <= this->length()){
			this->set_length(len);
			pointer raw = this->get_pointer();
			rexy::memcpy(raw, s, sizeof(value_type)*len);
			raw[len] = 0;
			return *this;
		}
		return (*this = basic_string(s, len));
	}


	template<class Left, class Right>
	constexpr auto string_cat_expr<Left,Right>::length(void)const noexcept -> size_type{
		return this->m_l.length() + this->m_r.length();
	}
	template<class Left, class Right>
	template<REXY_ALLOCATOR_CONCEPT Alloc>
	REXY_CPP20_CONSTEXPR string_cat_expr<Left,Right>::operator basic_string<value_type,Alloc>(void)
		noexcept(std::is_nothrow_constructible<basic_string<value_type,Alloc>, typename basic_string<value_type,Alloc>::size_type>::value &&
		         std::is_nothrow_invocable<detail::string_appender<basic_string<value_type,Alloc>>,decltype(*this)>::value)
	{
		size_type len = length();
		basic_string<value_type,Alloc> ret(len);
		detail::string_appender<basic_string<value_type,Alloc>> append(ret);
		append(*this);
		return ret;
	}


} //namespace rexy

#endif