//
//  either_stream.hpp
//  optional.stream
//
//  Created by Sam Jaffe on 1/28/17.
//

#pragma once

#include <type_traits>
#include <variant>

template <typename T, typename E> using either = std::variant<T, E>;

namespace stream {
  template <typename, typename> class either_stream;
}

namespace stream::traits {

  template <typename Either> struct either_traits;
  template <typename T, typename E> struct either_traits<::either<T, E>> {
    using stream_type = either_stream<T, E>;
    using value_type = T;
    using error_type = E;
  };

  template <typename Either>
  using either_stream_t = typename either_traits<Either>::stream_type;
  template <typename Either>
  using either_value_t = typename either_traits<Either>::value_type;

}

namespace stream {

  template <typename T, typename E> class either_stream {
  private:
    template <typename F, typename T2 = T>
    using map_f = decltype(std::declval<F>()(std::declval<T2>()));

    template <typename F, typename T2 = T>
    using flatmap_f = traits::either_value_t<map_f<F, T2>>;

    template <typename FT, typename FE>
    inline static constexpr bool is_consumer_v =
        std::is_void_v<map_f<FT, T>> && std::is_void_v<map_f<FE, E>>;

  private:
    ::either<T, E> value_;

  public:
    either_stream(E const & v) : value_(v) {}
    either_stream(E && v) : value_(std::forward<E>(v)) {}

    either_stream(T const & v) : value_(v) {}
    either_stream(T && v) : value_(std::forward<T>(v)) {}
    either_stream(::either<T, E> const & v) : value_(v) {}
    either_stream(::either<T, E> && v)
        : value_(std::forward<::either<T, E>>(v)) {}

    template <typename F> either_stream<map_f<F>, E> map(F && fun) const {
      if (value_.index() == 0) {
        return fun(std::get<0>(value_));
      } else {
        return std::get<1>(value_);
      }
    }

    template <typename F>
    either_stream<flatmap_f<F>, E> flatmap(F && fun) const {
      if (value_.index() == 0) {
        return fun(std::get<0>(value_));
      } else {
        return std::get<1>(value_);
      }
    }

    template <typename FT, typename FE>
    auto match(FT && left, FE && right)
        -> std::common_type_t<map_f<FT, T>, map_f<FE, E>> {
      if (value_.index() == 0) {
        return left(std::get<0>(value_));
      } else {
        return right(std::get<1>(value_));
      }
    }

    ::either<T, E> const & value() const { return value_; }
  };

}

namespace stream::either {

  /**
   * Construct a stream from the given type while explicitly providing both the
   * type and the error class
   */
  template <typename T, typename E>
  either_stream<T, E> make_stream(T const & opt) {
    return {{opt}};
  }

  /**
   * Construct a stream from the given type where the real type is an inferred
   * property
   */
  template <typename E, typename T>
  either_stream<T, E> make_stream(T const & opt) {
    return {{opt}};
  }

  /**
   * Construct a stream with the given either-type as a template parameter.
   */
  template <typename E>
  auto make_stream(traits::either_value_t<E> const & opt) {
    return traits::either_stream_t<E>{opt};
  }

}