#pragma once

#include <tuple>

#include "Iterator.Base.tlh"


//-----------------------------------------------------------------------------
//			Zip_Iterator
//
//		注意:
//			返回的 tuple 的数据类型应该是直接类型, 不能是引用类型
//			(比如应该是 tuple <int, DString>, 不应该是 tuple <int &, DString &>)
//			所以这里 data_type = value_type
//-----------------------------------------------------------------------------
namespace Iterator
{
	template <typename IteratorA, typename IteratorB>
	class Zip_Iterator2 : public __CoreIterator
	{
		typedef  __CoreIterator  inherited;

	public:
		using IterType     = typename IteratorA::IterType;

		using value_type_A = typename IteratorA::value_type;
		using value_type_B = typename IteratorB::value_type;

		using data_type_A  = typename IteratorA::data_type;
		using data_type_B  = typename IteratorB::data_type;

		using value_type = std::tuple <value_type_A, value_type_B>;
//		using data_type  = std::tuple <data_type_A, data_type_B>;
		using data_type  = value_type;
		using deref_type = value_type;

	public:
		Zip_Iterator2 () = delete;

		Zip_Iterator2 (IteratorA & a, IteratorB & b) :
			m_IterA (a),
			m_IterB (b),
			inherited (a)
		{
		}

		Zip_Iterator2 (const Zip_Iterator2 & from) :
			m_IterA (from.m_IterA),
			m_IterB (from.m_IterB),
			inherited (from.m_IterA)
		{
		}

		Zip_Iterator2 (Zip_Iterator2 && from) :
			m_IterA (from.m_IterA),
			m_IterB (from.m_IterB),
			inherited (from.m_IterA)
		{
		}

	public:
		inline virtual void Next () override
		{
			if (! IsEmpty ())
			{
				m_IterA.Next ();
				m_IterB.Next ();
				inherited::Next ();
			}
		}

		inline data_type Current ()     { return value_type (m_IterA.Current (), m_IterB.Current ()); }
		inline data_type operator () () { return Current (); }
		inline data_type operator *  () { return Current (); }

		inline virtual bool IsEmpty  () const override
		{
			if (inherited::IsEmpty ())
				return true;
			return (m_IterA.IsEmpty () || m_IterB.IsEmpty ());
		}

		inline void Skip (int delta)
		{
			for (;! IsEmpty () && delta > 0; delta --)
				Next ();
		}

	public:
		inline IterType stdBegin ()   { return m_IterA.stdBegin (); }
		inline IterType stdCurrent () { return m_IterA.stdCurrent (); }
		inline IterType stdEnd ()     { return m_IterA.stdEnd (); }

	private:
		IteratorA  m_IterA;
		IteratorB  m_IterB;
	};
};




namespace Iterator
{
	template <typename IteratorA, typename IteratorB, typename IteratorC>
	class Zip_Iterator3 : public __CoreIterator
	{
		typedef  __CoreIterator  inherited;

	public:
		using IterType     = typename IteratorA::IterType;

		using value_type_A = typename IteratorA::value_type;
		using value_type_B = typename IteratorB::value_type;
		using value_type_C = typename IteratorC::value_type;

		using data_type_A  = typename IteratorA::data_type;
		using data_type_B  = typename IteratorB::data_type;
		using data_type_C  = typename IteratorC::data_type;

		using value_type = std::tuple <value_type_A, value_type_B, value_type_C>;
		using data_type  = value_type;
		using deref_type = value_type;

	public:
		Zip_Iterator3 () = delete;

		Zip_Iterator3 (IteratorA & a, IteratorB & b, IteratorC & c) :
			m_IterA (a),
			m_IterB (b),
			m_IterC (c),
			inherited (a)
		{
		}

		Zip_Iterator3 (const Zip_Iterator3 & from) :
			m_IterA (from.m_IterA),
			m_IterB (from.m_IterB),
			m_IterC (from.m_IterC),
			inherited (from.m_IterA)
		{
		}

		Zip_Iterator3 (Zip_Iterator3 && from) :
			m_IterA (from.m_IterA),
			m_IterB (from.m_IterB),
			m_IterC (from.m_IterC),
			inherited (from.m_IterA)
		{
		}

	public:
		inline virtual void Next () override
		{
			if (! IsEmpty ())
			{
				m_IterA.Next ();
				m_IterB.Next ();
				m_IterC.Next ();
				inherited::Next ();
			}
		}

		inline data_type Current ()     
		{
			return value_type (m_IterA.Current (), m_IterB.Current (), m_IterC.Current ());
		}
	
		inline data_type operator () () { return Current (); }
		inline data_type operator *  () { return Current (); }

		inline virtual bool IsEmpty  () const override
		{
			if (inherited::IsEmpty ())
				return true;
			return (m_IterA.IsEmpty () || m_IterB.IsEmpty () || m_IterC.IsEmpty ());
		}

		inline void Skip (int delta)
		{
			for (;! IsEmpty () && delta > 0; delta --)
				Next ();
		}

	public:
		inline IterType stdBegin ()   { return m_IterA.astdBegin (); }
		inline IterType stdCurrent () { return m_IterA.bstdCurrent (); }
		inline IterType stdEnd ()     { return m_IterA.cstdEnd (); }

	private:
		IteratorA  m_IterA;
		IteratorB  m_IterB;
		IteratorC  m_IterC;
	};

};