#pragma once
#ifndef Convention_Runtime_Generics_Sequence_hpp
#define Convention_Runtime_Generics_Sequence_hpp

#include"Config.hpp"

namespace Convention
{
	namespace Generics
	{

		template<typename Element,typename ReadValueType = Element&>
		class ISequenceIterator
		{
		public:
			virtual ~ISequenceIterator() {}
			virtual void Next() abstract;
			virtual ReadValueType ReadValue() const abstract;
			virtual decltype(auto) operator++()
			{

			}
			ReadValueType operator++(int) noexcept(noexcept(operator++))
			{

			}
		};

		template<typename Element, typename SequenceIterator = ISequenceIterator<Element>>
		class ISequence
		{
		public:
			using iterator = std::enable_if<std::is_base_of_v<ISequenceIterator<Element>, SequenceIterator>, SequenceIterator>;
			virtual ~ISequence() {}
			virtual iterator begin() abstract;
			virtual iterator end() abstract;
		};

		/**
		* @brief 序列容器枚举
		* @tparam Sequence 序列类型
		* @tparam _Index 索引类型
		* @version BS 0.0.1
		*/
		template<typename Sequence, typename _Index = int>
		class SequenceIterator
		{
		private:
			const Sequence& target;
			_Index index;
		public:
			SequenceIterator(const Sequence& target, _Index index) :__init(target), __init(index) {}
			SequenceIterator(const SequenceIterator& other) : target(other.target), index(other.index) {}
			SequenceIterator& operator=(const SequenceIterator& other)
			{
				target = other.target;
				index = other.index;
				return *this;
			}
			bool operator==(const SequenceIterator& other) noexcept
			{
				return other.index == index;
			}
			bool operator!=(const SequenceIterator& other) noexcept
			{
				return other.index != index;
			}
			SequenceIterator& operator++() noexcept
			{
				++index;
				return *this;
			}
			SequenceIterator operator++(int) noexcept
			{
				++index;
				return SequenceIterator(target, index - 1);
			}
			SequenceIterator& operator--() noexcept
			{
				--index;
				return *this;
			}
			SequenceIterator operator--(int) noexcept
			{
				--index;
				return SequenceIterator(target, index + 1);
			}
		};

		/**
		* @brief 序列容器可枚举类型
		* @tparam Sequence 序列类型
		* @tparam _Index 索引类型
		* @version BS 0.0.1
		*/
		template<typename Sequence, typename _Index = int>
		struct SequenceRange
		{
			using iterator = SequenceIterator<Sequence, _Index>;
			iterator mbegin, mend;
			SequenceRange(const Sequence& target, _Index begin = 0, _Index end = 0ll - 1) :mbegin(target, begin), mend(target, end) {}

			constexpr iterator begin()
			{
				return mbegin;
			}
			constexpr iterator end()
			{
				return mend;
			}
		};


		/**
		* @brief 栈上静态数组
		* @tparam Element 内容物类型
		* @tparam size 元素大小
		* @version BS 0.0.1
		*/
		template<typename Element, size_t size>
		using Array = std::array<Element, size>;

		/**
		* @brief 栈上静态Bool数组
		* @tparam size 元素大小
		* @version BS 0.0.1
		*/
		template<size_t capacity>
		class BoolArray
			: private Array<
			std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>,
			capacity / sizeof(std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>) + (capacity % sizeof(std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>) ? 1 : 0)
			>
		{
		private:
			constexpr static const char* out_of_range_message = "out of range, capacity: ";
			using _MyElementTy = std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>;
			constexpr static size_t _MyCapacity = capacity / sizeof(_MyElementTy) + (capacity % sizeof(_MyElementTy) ? 1 : 0);
			using _Mybase = Array<_MyElementTy, _MyCapacity>;
			constexpr _Mybase& _GetBaseArray() noexcept
			{
				return *this;
			}
			constexpr const _Mybase& _GetBaseArray() const noexcept
			{
				return *this;
			}
		public:
			inline constexpr size_t size() const noexcept
			{
				return capacity;
			}
			int ReadValue(size_t index) const
			{
				if (index < capacity)
				{
					size_t i = index / sizeof(_MyElementTy), offset = index % sizeof(_MyElementTy);
					return _GetBaseArray()[i] & (1ll << offset);
				}
				throw std::out_of_range(StringIndicator::Combine<std::string>(out_of_range_message, capacity));
			}
			bool operator[](int index) const
			{
				return ReadValue(index < 0 ? capacity + index : index);
			}
			void WriteValue(size_t index, bool value)
			{
				if (index < capacity)
				{
					size_t i = index / sizeof(_MyElementTy), offset = index % sizeof(_MyElementTy);
					if (value)
						_GetBaseArray()[i] |= 1ll << offset;
					else
						_GetBaseArray()[i] &= ~(1ll << offset);
				}
				throw std::out_of_range(StringIndicator::Combine<std::string>(out_of_range_message, capacity));
			}
		};

		/**
		* @brief 堆上动态数组
		* @tparam Element 内容物类型
		* @tparam Allocator 内存分配器
		* @version BS 0.0.1
		*/
		template<typename Element, template<typename> class Allocator>
		using Vector = std::vector<Element, Allocator<Element>>;

	}
}

#endif Convention_Runtime_Generics_Sequence_hpp