/**
	This file is a part of rexy's general purpose library
	Copyright (C) 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_CONCEPTS_STRING_HPP
#define REXY_CONCEPTS_STRING_HPP

#include <type_traits> //decay
#include <concepts> //convertible_to
#include <utility> //as_const

#include "../traits.hpp"

namespace rexy{

	template<class Left, class Right>
	class string_cat_expr;
	template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
	class basic_string;
	template<class Char>
	class basic_string_view;

	template<class T>
	struct is_basic_string{
		template<class Char, class Alloc>
		static std::true_type check(const basic_string<Char,Alloc>*);
		static std::false_type check(...);

		static constexpr bool value = decltype(check(std::declval<std::remove_cvref_t<T>*>()))::value;
	};

	template<class T>
	struct is_basic_string_view{
		template<class Char>
		static std::true_type check(const basic_string_view<Char>*);
		static std::false_type check(...);

		static constexpr bool value = decltype(check(std::declval<std::remove_cvref_t<T>*>()))::value;
	};

	template<class T>
	struct is_basic_string_expr{
		template<class Left, class Right>
		static std::true_type check(const string_cat_expr<Left,Right>*);
		static std::false_type check(...);

		static constexpr bool value = decltype(check(std::declval<std::remove_cvref_t<T>*>()))::value;
	};

	template<class T>
	concept BasicString = requires(const T& a){
		requires(is_basic_string<T>::value || is_basic_string_view<T>::value);
		{std::as_const(a).length()} -> std::convertible_to<typename std::decay_t<T>::size_type>;
		{std::as_const(a).c_str()} -> std::convertible_to<typename std::decay_t<T>::const_pointer>;
		{std::as_const(a)[0]} -> std::convertible_to<typename std::decay_t<T>::const_reference>;
		{std::as_const(a).begin()} -> std::convertible_to<typename std::decay_t<T>::const_iterator>;
		{std::as_const(a).end()} -> std::convertible_to<typename std::decay_t<T>::const_iterator>;
	};
	template<class T>
	concept StringExpr = is_basic_string_expr<T>::value;
	template<class T>
	concept String = BasicString<T> || StringExpr<T>;

	template<class T>
	struct is_string{
		static constexpr bool value = BasicString<T>;
	};
	template<class T>
	static constexpr bool is_string_v = is_string<T>::value;
	template<class... Ts>
	struct are_strings{
		static constexpr bool value = (BasicString<Ts> && ...);
	};
	template<class... Ts>
	static constexpr bool are_strings_v = are_strings<Ts...>::value;
	template<class T>
	struct is_string_expr{
		static constexpr bool value = StringExpr<T>;
	};
	template<class T>
	static constexpr bool is_string_expr_v = is_string_expr<T>::value;
	template<class... Ts>
	struct are_string_expr{
		static constexpr bool value = (StringExpr<Ts> && ...);
	};
	template<class... Ts>
	static constexpr bool are_string_expr_v = are_string_expr<Ts...>::value;

}

#endif