//
//  impl.hpp
//  iterator
//
//  Created by Sam Jaffe on 2/21/17.
//

#pragma once

#include "base.hpp"
#include "flatten_layer.hpp"
#include "layer.hpp"
#include "traits.hpp"

namespace iterator::recursive {
  template <typename Iterator, typeclass = typeclass_t<Iterator>::value>
  class impl;

  /**
   * A bounded_impl where N == Max is always a terminal node.
   */
  template <typename Iterator, std::size_t N, std::size_t Max,
            typeclass = std::conditional_t<N == Max, typeclass_t<void>,
                                           typeclass_t<Iterator>>::value>
  class bounded_impl;

  /**
   * @class impl
   * @brief The default (terminal) implementation of an unbounded recursive
   * iterator.
   *
   * @see base
   * @tparam Iterator The iterator type being processed, such as
   * std::vector<int>::iterator
   */
  template <typename Iterator>
  class impl<Iterator, typeclass::TERMINAL> : public base<Iterator> {
  public:
    using super = base<Iterator>;

  public:
    using super::super;
    impl() = default;

  protected:
    void next() { super::operator++(); }
    void assign(super eat) { static_cast<super &>(*this) = eat; }
  };

  /**
   * @class impl
   *
   * An SFINAE specialization of bounded_impl for
   * non-associative container types.
   * @see layer
   */
  template <typename Iterator>
  class impl<Iterator, typeclass::CONTAINER>
      : public layer<Iterator, impl<value<Iterator>>> {
  public:
    using next_layer = impl<value<Iterator>>;
    using super = layer<Iterator, next_layer>;

  public:
    /**
     * A special override of operator* that allows collections like
     * std::vector<std::vector<std::map<K, V>>> still use the value/reference
     * type of the map. Works only for nested collections with one associative
     * container at the bottom level.
     */
    auto operator*() const -> decltype(*(next_layer &)(*this)) {
      return next_layer::operator*();
    }
    using super::super;
    impl() = default;
  };

  /**
   * @class impl
   *
   * An SFINAE specialization of bounded_impl for
   * associative container types.
   * @see flatten_iterator_layer
   */
  template <typename Iterator>
  class impl<Iterator, typeclass::ASSOCIATIVE_CONTAINER>
      : public flatten_layer<Iterator, impl<mapped<Iterator>>> {
  public:
    using next_layer = impl<mapped<Iterator>>;
    using super = flatten_layer<Iterator, next_layer>;

  public:
    using super::super;
    impl() = default;
  };

  /**
   * @class bounded_impl
   * @brief The default (terminal) implementation of a recursive iterator up to
   * Max levels deep.
   *
   * @see base
   * @tparam Iterator The iterator type being processed, such as
   * std::vector<int>::iterator
   * @tparam N The current layer of depth, starts at 1.
   * @tparam Max The maximum recursive depth to dive down, in case you need to
   * process some sub-collection in a specific manner.
   */
  template <typename Iterator, std::size_t N, std::size_t Max>
  class bounded_impl<Iterator, N, Max, typeclass::TERMINAL>
      : public base<Iterator> {
  public:
    using super = base<Iterator>;

  public:
    using super::super;
    bounded_impl() = default;

  protected:
    void next() { super::operator++(); }
    void assign(super eat) { static_cast<super &>(*this) = eat; }
  };

  /**
   * @class bounded_impl
   *
   * An SFINAE specialization of bounded_impl for
   * non-associative container types.
   * @see layer
   */
  template <typename Iterator, std::size_t N, std::size_t Max>
  class bounded_impl<Iterator, N, Max, typeclass::CONTAINER>
      : public layer<Iterator, bounded_impl<value<Iterator>, N + 1, Max>> {
  public:
    using next_layer = bounded_impl<value<Iterator>, N + 1, Max>;
    using super = layer<Iterator, next_layer>;

  public:
    /**
     * A special override of operator* that allows collections like
     * std::vector<std::vector<std::map<K, V>>> still use the value/reference
     * type of the map. Works only for nested collections with one associative
     * container at the bottom/Max level.
     */
    auto operator*() const -> decltype(*(next_layer &)(*this)) {
      return next_layer::operator*();
    }
    using super::super;
    bounded_impl() = default;
  };

  /**
   * @class bounded_impl
   *
   * An SFINAE specialization of bounded_impl for
   * associative container types.
   * @see flatten_iterator_layer
   */
  template <typename Iterator, std::size_t N, std::size_t Max>
  class bounded_impl<Iterator, N, Max, typeclass::ASSOCIATIVE_CONTAINER>
      : public flatten_layer<Iterator,
                             bounded_impl<mapped<Iterator>, N + 1, Max>> {
  public:
    using next_layer = bounded_impl<mapped<Iterator>, N + 1, Max>;
    using super = flatten_layer<Iterator, next_layer>;

  public:
    using super::super;
    bounded_impl() = default;
  };
}