// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
#ifndef DUNE_PDELAB_BACKEND_ISTL_VECTORITERATOR_HH
#define DUNE_PDELAB_BACKEND_ISTL_VECTORITERATOR_HH

#include <iterator>
#include <cassert>

#include <dune/common/nullptr.hh>
#include <dune/common/tuples.hh>
#include <dune/pdelab/backend/istl/tags.hh>

namespace Dune {

  namespace PDELab {

    namespace istl {

      namespace impl {

        template<typename T, bool is_const, typename Tag, typename... Iterators>
        struct _extract_iterators;

        template<typename T, typename... Iterators>
        struct _extract_iterators<T,true,tags::block_vector,Iterators...>
          : public _extract_iterators<typename T::block_type,
                                      true,
                                      typename tags::container<typename T::block_type>::type::base_tag,
                                      Iterators..., typename T::const_iterator
                                      >
        {};

        template<typename T, typename... Iterators>
        struct _extract_iterators<T,false,tags::block_vector,Iterators...>
          : public _extract_iterators<typename T::block_type,
                                      false,
                                      typename tags::container<typename T::block_type>::type::base_tag,
                                      Iterators..., typename T::iterator
                                      >
        {};

        template<typename T, typename... Iterators>
        struct _extract_iterators<T,true,tags::field_vector,Iterators...>
        {
          typedef tuple<Iterators...,typename T::const_iterator> type;
        };

        template<typename T, typename... Iterators>
        struct _extract_iterators<T,false,tags::field_vector,Iterators...>
        {
          typedef tuple<Iterators...,typename T::iterator> type;
        };


        template<typename T, typename... Iterators>
        struct _extract_iterators<T,true,tags::dynamic_vector,Iterators...>
        {
          typedef tuple<Iterators...,typename T::const_iterator> type;
        };

        template<typename T, typename... Iterators>
        struct _extract_iterators<T,false,tags::dynamic_vector,Iterators...>
        {
          typedef tuple<Iterators...,typename T::iterator> type;
        };


        template<typename V>
        struct extract_iterators
          : public _extract_iterators<V,false,typename tags::container<V>::type::base_tag>
        {};

        template<typename V>
        struct extract_iterators<const V>
          : public _extract_iterators<V,true,typename tags::container<V>::type::base_tag>
        {};


        template<typename V>
        struct vector_iterator_base
          : public std::iterator<std::forward_iterator_tag,
                                 typename V::field_type,
                                 typename std::ptrdiff_t,
                                 typename V::field_type*,
                                 typename V::field_type&
                                 >
        {
          typedef V vector;
          typedef V& vector_reference;
          typedef typename tags::container<V>::type::base_tag vector_tag;
          static const bool is_const = false;
        };

        template<typename V>
        struct vector_iterator_base<const V>
          : public std::iterator<std::forward_iterator_tag,
                                 typename V::field_type,
                                 typename std::ptrdiff_t,
                                 const typename V::field_type*,
                                 const typename V::field_type&
                                 >
        {
          typedef V vector;
          typedef const V& vector_reference;
          typedef typename tags::container<V>::type::base_tag vector_tag;
          static const bool is_const = true;
        };

      }

      template<typename V>
      class vector_iterator
        : public impl::vector_iterator_base<V>
      {

        typedef impl::vector_iterator_base<V> BaseT;
        typedef typename BaseT::vector vector;
        typedef typename BaseT::vector_reference vector_reference;
        typedef typename BaseT::vector_tag vector_tag;
        typedef typename impl::extract_iterators<V>::type Iterators;
        static const bool is_const = BaseT::is_const;

        template<typename>
        friend class vector_iterator;

      public:

        vector_iterator(vector_reference vector, bool at_end)
          : _at_end(at_end)
          , _current(nullptr)
        {
          if (!_at_end)
            if (!start(vector_tag(),level<0>(),vector))
              _at_end = true;
        }


        // Copy constructor from iterator to const_iterator
        // We disable this one if the two types are identical to avoid hiding
        // the default copy constructor
        template<typename W>
        vector_iterator(const vector_iterator<W>& r, typename enable_if<is_const && !is_same<V,W>::value && is_same<vector,W>::value,void*>::type = nullptr)
          : _at_end(r._at_end)
          , _current(r._current)
          , _iterators(r._iterators)
          , _end(r._end)
        {}


        // Assignment operator from iterator to const_iterator
        // We disable this one if the two types are identical to avoid hiding
        // the default assignment operator
        template<typename W>
        typename enable_if<
          is_const && !is_same<vector,W>::value && is_same<vector,W>::value,
          vector_iterator&
          >::type
        operator=(const vector_iterator<W>& r)
        {
          _at_end = r._at_end;
          _current =r._current;
          _iterators = r._iterators;
          _end = r._end;
          return *this;
        }


        typename BaseT::pointer operator->() const
        {
          assert(!_at_end);
          return _current;
        }

        typename BaseT::reference operator*() const
        {
          assert(!_at_end);
          return *_current;
        }

        vector_iterator& operator++()
        {
          increment();
          return *this;
        }

        vector_iterator operator++(int)
        {
          vector_iterator tmp(*this);
          increment();
          return tmp;
        }

        template<typename W>
        typename enable_if<
          is_same<vector,typename vector_iterator<W>::vector>::value,
          bool
          >::type
        operator==(const vector_iterator<W>& r) const
        {
          if (!_at_end)
            {
              if (r._at_end)
                return false;
              return _current == r._current;
            }
          else
            return r._at_end;
        }

        template<typename W>
        typename enable_if<
          is_same<vector,typename vector_iterator<W>::vector>::value,
          bool
          >::type
        operator!=(const vector_iterator<W>& r) const
        {
          return !operator==(r);
        }

      private:

        template<std::size_t l>
        struct level
          : public integral_constant<std::size_t,l>
        {};

        void increment()
        {
          assert(!_at_end);
          if (!advance(vector_tag(),level<0>()))
            _at_end = true;
        }

        template<std::size_t l, typename Block>
        bool start_leaf(level<l>, Block& block)
        {
          typedef typename tuple_element<l,Iterators>::type iterator;
          iterator& it = get<l>(_iterators);
          iterator& end = get<l>(_end);

          it = block.begin();
          end = block.end();

          if (it == end)
            return false;

          _current = &(*it);

          return true;
        }

        template<std::size_t l, typename Block>
        bool start(tags::field_vector_n, level<l>, Block& block)
        {
          return start_leaf(level<l>(),block);
        }

        template<std::size_t l, typename Block>
        bool start(tags::dynamic_vector, level<l>, Block& block)
        {
          return start_leaf(level<l>(),block);
        }

        template<std::size_t l, typename Block>
        bool start(tags::field_vector_1, level<l>, Block& block)
        {
          _current = &(block[0]);
          return true;
        }


        template<std::size_t l, typename Block>
        bool start(tags::block_vector, level<l>, Block& block)
        {
          typedef typename tuple_element<l,Iterators>::type iterator;
          iterator& it = get<l>(_iterators);
          iterator& end = get<l>(_end);

          it = block.begin();
          end = block.end();

          while (it != end)
            {
              if (start(container_tag(*it),level<l+1>(),*it))
                return true;

              ++it;
            }

          return false;
        }


        template<std::size_t l>
        bool advance_leaf(level<l>)
        {
          typedef typename tuple_element<l,Iterators>::type iterator;
          iterator& it = get<l>(_iterators);
          const iterator& end = get<l>(_end);

          ++it;

          if (it == end)
            return false;

          _current = &(*it);

          return true;
        }

        template<std::size_t l>
        bool advance(tags::field_vector_n, level<l>)
        {
          return advance_leaf(level<l>());
        }

        template<std::size_t l>
        bool advance(tags::dynamic_vector, level<l>)
        {
          return advance_leaf(level<l>());
        }

        template<std::size_t l>
        bool advance(tags::field_vector_1, level<l>)
        {
          return false;
        }


        template<std::size_t l>
        bool advance(tags::block_vector, level<l>)
        {
          typedef typename tuple_element<l,Iterators>::type iterator;
          iterator& it = get<l>(_iterators);
          iterator& end = get<l>(_end);

          if (advance(container_tag(*it),level<l+1>()))
            return true;

          ++it;

          while (it != end)
            {
              if (start(container_tag(*it),level<l+1>(),*it))
                return true;

              ++it;
            }

          return false;
        }


        bool _at_end;
        typename BaseT::pointer _current;
        Iterators _iterators;
        Iterators _end;

      };

    } // namespace istl
  } // namespace PDELab
} // namespace Dune



#endif // DUNE_PDELAB_BACKEND_ISTL_VECTORITERATOR_HH
