/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   ReverseIterator.hpp                                :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2020/04/27 09:33:16 by charles           #+#    #+#             */
/*   Updated: 2020/04/27 11:32:22 by charles          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef REVERSEITERATOR_HPP
# define REVERSEITERATOR_HPP

namespace ft
{
    template <typename Iterator>
    class ReverseIterator
    {
    public:
        typedef Iterator                           iterator_type;
        typedef typename iterator_type::value_type value_type;
        typedef int                                difference_type;

        ReverseIterator() : m_it(iterator_type())                {}
        ReverseIterator(const ReverseIterator& other)            { *this = other; }
        ReverseIterator& operator=(const ReverseIterator& other) { m_it = other.m_it; return *this; }
        ~ReverseIterator()                                       {}

        explicit ReverseIterator(iterator_type it) : m_it(it)    {}

        iterator_type base() const                     { return m_it; }

        value_type& operator*()                        { return (m_it--).operator*(); }
        value_type* operator->()                       { return &(operator*());       }

        ReverseIterator operator+(difference_type n)   { m_it - n; return *this; }
        ReverseIterator operator-(difference_type n)   { m_it + n; return *this; }

        ReverseIterator& operator++()    { --m_it; return *this;                      }
        ReverseIterator& operator--()    { --m_it; return *this;                      }
        ReverseIterator  operator++(int) { ReverseIterator copy(*this); m_it++; return copy; }
        ReverseIterator  operator--(int) { ReverseIterator copy(*this); m_it--; return copy; }

        ReverseIterator& operator+=(difference_type n) { return m_it -= n; }
        ReverseIterator& operator-=(difference_type n) { return m_it += n; }

        value_type& operator[](difference_type n)      { return m_it[-n - 1]; }

        bool operator==(const ReverseIterator& other) const { return m_it == other.m_it; }
        bool operator!=(const ReverseIterator& other) const { return m_it != other.m_it; }

        bool operator<(const ReverseIterator& other)  const { return m_it < other.m_it;  }
        bool operator>(const ReverseIterator& other)  const { return m_it > other.m_it;  }
        bool operator<=(const ReverseIterator& other) const { return m_it <= other.m_it; }
        bool operator>=(const ReverseIterator& other) const { return m_it >= other.m_it; }

    private:
        iterator_type m_it;
    };
}

template <typename Iterator>
ft::ReverseIterator<Iterator> operator+(
    typename ft::ReverseIterator<Iterator>::difference_type n,
    const ft::ReverseIterator<Iterator>& rev_it)
{
    return rev_it + n;
}

template <typename Iterator>
typename ft::ReverseIterator<Iterator>::difference_type  operator-(
    const ft::ReverseIterator<Iterator>& lhs,
    const ft::ReverseIterator<Iterator>& rhs)
{
    return lhs.base() - rhs.base();
}

#endif