#ifndef INCLUDE_GUARD_ADJACENT_DIFFERENCE_HH
#define INCLUDE_GUARD_ADJACENT_DIFFERENCE_HH

#include <functional>
#include <iterator>
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/optional/optional.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range_ex/transform.hpp>
#include <boost/static_assert.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/is_class.hpp>


template <typename SinglePassIterator,
    typename BinaryFunction = std::minus<typename std::iterator_traits<SinglePassIterator>::value_type> >
struct adjacent_difference_iterator :
    boost::iterator_adaptor<
        adjacent_difference_iterator<SinglePassIterator, BinaryFunction>,
        SinglePassIterator>
{

private:

    BOOST_CLASS_REQUIRE(SinglePassIterator, boost_concepts, SinglePassIteratorConcept);

    friend class boost::iterator_core_access;

    typename adjacent_difference_iterator::iterator_adaptor_::reference
    dereference() const
    {
        if (previous)
        {
            return binary_op(*this->base(), *previous);
        }
        else
        {
            return *this->base();
        }
    }

    void increment()
    {
        previous = *this->base();
        ++this->base_reference();
    }

    boost::optional<typename adjacent_difference_iterator::iterator_adaptor_::value_type> previous;
    BinaryFunction binary_op;

public:

    adjacent_difference_iterator()
    {
    }

    explicit adjacent_difference_iterator(SinglePassIterator const &iterator) :
        adjacent_difference_iterator::iterator_adaptor_(iterator)
    {
        BOOST_STATIC_ASSERT(boost::is_class<BinaryFunction>::value);
    }

    adjacent_difference_iterator(SinglePassIterator const &iterator, BinaryFunction binary_op) :
        adjacent_difference_iterator::iterator_adaptor_(iterator),
        binary_op(binary_op)
    {
    }

    BinaryFunction functor() const
    {
        return binary_op;
    }

};


template <typename SinglePassIterator>
adjacent_difference_iterator<SinglePassIterator>
make_adjacent_difference_iterator(SinglePassIterator iterator)
{
    return adjacent_difference_iterator<SinglePassIterator>(iterator);
}

template <typename SinglePassIterator, typename BinaryFunction>
adjacent_difference_iterator<SinglePassIterator, BinaryFunction>
make_adjacent_difference_iterator(SinglePassIterator iterator, BinaryFunction binary_op)
{
    return adjacent_difference_iterator<SinglePassIterator, BinaryFunction>(iterator, binary_op);
}


template <typename SinglePassRange,
    typename BinaryFunction = std::minus<typename boost::range_value<SinglePassRange>::type> >
struct adjacent_difference_range :
    boost::iterator_range<adjacent_difference_iterator<
        typename boost::range_result_iterator<SinglePassRange>::type, BinaryFunction> >
{

    typedef typename boost::range_result_iterator<SinglePassRange>::type base_iterator;
    typedef adjacent_difference_iterator<base_iterator, BinaryFunction> iterator;
    typedef boost::iterator_range<iterator> base_range;

    explicit adjacent_difference_range(SinglePassRange &range) :
        base_range(
            make_adjacent_difference_iterator(boost::begin(range)),
            make_adjacent_difference_iterator(boost::end(range)))
    {
    }

    adjacent_difference_range(SinglePassRange &range, BinaryFunction binary_op) :
        base_range(
            make_adjacent_difference_iterator(boost::begin(range), binary_op),
            make_adjacent_difference_iterator(boost::end(range), binary_op))
    {
    }

};


template <typename SinglePassRange>
adjacent_difference_range<SinglePassRange>
make_adjacent_difference_range(SinglePassRange &range)
{
    return adjacent_difference_range<SinglePassRange>(range);
}
template <typename SinglePassRange>
adjacent_difference_range<SinglePassRange const>
make_adjacent_difference_range(SinglePassRange const &range)
{
    return adjacent_difference_range<SinglePassRange const>(range);
}

template <typename SinglePassRange, typename BinaryFunction>
adjacent_difference_range<SinglePassRange, BinaryFunction>
make_adjacent_difference_range(SinglePassRange &range, BinaryFunction binary_op)
{
    return adjacent_difference_range<SinglePassRange, BinaryFunction>(range, binary_op);
}
template <typename SinglePassRange, typename BinaryFunction>
adjacent_difference_range<SinglePassRange const, BinaryFunction>
make_adjacent_difference_range(SinglePassRange const &range, BinaryFunction binary_op)
{
    return adjacent_difference_range<SinglePassRange const, BinaryFunction>(range, binary_op);
}


namespace detail
{

template <size_t length>
struct adjacent_difference_range_adaptor_overload;

template <>
struct adjacent_difference_range_adaptor_overload<0>
{
    template <typename Range, typename Args>
    struct apply
    {
        BOOST_STATIC_ASSERT((boost::tuples::length<Args>::value == 0));
        typedef adjacent_difference_range<Range> type;
    };
    template <typename Range, typename Args>
    static typename apply<Range, Args>::type
    make_range(Range &range, Args const &args)
    {
        return make_adjacent_difference_range(range);
    }
};

template <>
struct adjacent_difference_range_adaptor_overload<1>
{
    template <typename Range, typename Args>
    struct apply
    {
        BOOST_STATIC_ASSERT((boost::tuples::length<Args>::value == 1));
        typedef adjacent_difference_range<Range,
            typename boost::tuples::element<0, Args>::type> type;
    };
    template <typename Range, typename Args>
    static typename apply<Range, Args>::type
    make_range(Range &range, Args const &args)
    {
        return make_adjacent_difference_range(range, boost::tuples::get<0>(args));
    }
};

struct adjacent_difference_range_adaptor
{

    template <typename Range, typename Args>
    struct apply
    {
        typedef typename adjacent_difference_range_adaptor_overload<
            boost::tuples::length<Args>::value>::template apply<Range, Args>::type type;
    };

    template <typename Range, typename Args>
    static typename apply<Range, Args>::type
    make_range(Range &range, Args const &args)
    {
        return adjacent_difference_range_adaptor_overload<
            boost::tuples::length<Args>::value>::make_range(range, args);
    }

};

}   // namespace detail


boost::range_adaptor<detail::adjacent_difference_range_adaptor> const adjacent_difference;


#endif  // !INCLUDE_GUARD_ADJACENT_DIFFERENCE_HH