#pragma once

#include <boost/iterator/iterator_facade.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/variant.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/static_visitor.hpp>

template <typename reference>
struct DereferenceVisitor : public boost::static_visitor<reference>
{
	template <typename T>
	reference operator()(T Iterator) const
	{
		return *Iterator;
	}
};

struct IncrementVisitor : public boost::static_visitor<void>
{
	template <typename T>
	void operator()(T &Value) const
	{
		++Value;
	}
};

struct DecrementVisitor : public boost::static_visitor<void>
{
	template <typename T>
	void operator()(T &Value) const
	{
		--Value;
	}
};

template <class TIterator1, class TIterator2, class TValue = typename boost::iterator_value<TIterator1>::type >
class ConcatIterator : public boost::iterator_facade<ConcatIterator<TIterator1, TIterator2, TValue>, TValue, boost::bidirectional_traversal_tag>
{
public:
	template <class TIterator>
	ConcatIterator(TIterator It, size_t Range /* 0 for the first range, 1 for the second range */, TIterator1 End1, TIterator2 Begin2) :
		It(It), Range(Range), End1(End1), Begin2(Begin2)
	{
		Stabilize();
	}

private:
	void Stabilize()
	{
		if ((Range == 0) && (It == End1))
		{
			It = Begin2;
			Range = 1;
		}
	}

public:
	reference dereference() const
	{
		return boost::apply_visitor(DereferenceVisitor<reference>(), It);
	}

	void increment()
	{
		boost::apply_visitor(IncrementVisitor(), It);
		if ((Range == 0) && (It == End1))
		{
			It = Begin2;
			Range = 1;
		}
	}

	void decrement()
	{
		if ((Range == 1) && (It == Begin2))
		{
			It = End1;
			Range = 0;
		}
		boost::apply_visitor(DecrementVisitor(), It);
	}

	bool equal(const ConcatIterator& lhs) const
	{
		return (Range == lhs.Range) && (It == lhs.It);
	}

private:
	size_t Range;
	boost::variant<TIterator1, TIterator2> It, End1, Begin2;
};

template <class TRange1, class TRange2>
boost::iterator_range<ConcatIterator<typename TRange1::iterator, typename TRange2::iterator> >
Concatenate(TRange1 &Range1, TRange2 &Range2)
{
	typedef ConcatIterator<typename TRange1::iterator, typename TRange2::iterator> TIterator;
	return boost::make_iterator_range(
		TIterator(Range1.begin(), 0, Range1.end(), Range2.begin()),
		TIterator(Range2.end  (), 1, Range1.end(), Range2.begin()));
}

template <class TRange1, class TRange2>
boost::iterator_range<ConcatIterator<typename TRange1::const_iterator, typename TRange2::const_iterator> >
Concatenate(TRange1 const &Range1, TRange2 const &Range2)
{
	typedef ConcatIterator<typename TRange1::const_iterator, typename TRange2::const_iterator> TIterator;
	return boost::make_iterator_range(
		TIterator(Range1.begin(), 0, Range1.end(), Range2.begin()),
		TIterator(Range2.end  (), 1, Range1.end(), Range2.begin()));
}