#pragma once
// NOLINTBEGIN(readability-identifier-naming)

#include <type_traits>

#ifdef __cpp_lib_expected
#if __cpp_lib_expected >= 202211L
#include <expected>

namespace jvalidate::detail {
using std::expected;
using std::unexpected;
inline constexpr std::unexpect_t unexpect{};
}
#endif
#else
#include <initializer_list>
#include <optional>
#include <utility>
#include <variant>

#include <jvalidate/detail/expect.h>

namespace jvalidate::detail {
inline constexpr struct unexpect_t {
} unexpect{};

template <typename E> class unexpected {
public:
  template <typename Err = E>
    requires(not std::same_as<E, unexpected<E>>)
  constexpr explicit unexpected(Err && err) : error_(std::forward<Err>(err)) {}
  template <typename... Args>
  constexpr explicit unexpected(std::in_place_t, Args &&... args)
      : error_{std::forward<Args>(args)...} {}
  template <typename U, typename... Args>
  constexpr explicit unexpected(std::in_place_t, std::initializer_list<U> init, Args &&... args)
      : error_{init, std::forward<Args>(args)...} {}

  constexpr const E & error() const & noexcept { return error_; }
  constexpr E & error() & noexcept { return error_; }
  constexpr E && error() && noexcept { return std::move(error_); }

  constexpr void swap(unexpected & other) noexcept(std::is_nothrow_swappable_v<E>) {
    using std::swap;
    swap(error(), other.error());
  }

  template <typename E2>
  friend constexpr bool operator==(unexpected const & lhs, unexpected<E2> const & rhs) {
    return lhs.error() == rhs.error();
  }

  friend constexpr void swap(unexpected & lhs, unexpected & rhs) noexcept(noexcept(lhs.swap(rhs))) {
    return lhs.swap(rhs);
  }

private:
  E error_;
};

template <typename E> unexpected(E) -> unexpected<E>;

template <typename E> class bad_expected_access;
template <> class bad_expected_access<void> : public std::exception {
public:
  char const * what() const noexcept override { return "unexpected"; }
};

template <typename E> class bad_expected_access : public bad_expected_access<void> {
public:
  explicit bad_expected_access(E error) : error_(std::move(error)) {}

  constexpr const E & error() const & noexcept { return error_; }
  constexpr E & error() & noexcept { return error_; }
  constexpr E && error() && noexcept { return std::move(error_); }

private:
  E error_;
};

template <typename T, typename E> class expected {
public:
  using value_type = T;
  using error_type = E;
  using unexpected_type = unexpected<E>;
  template <typename U> using rebind = expected<U, error_type>;

public:
  constexpr expected() = default;

  template <typename U, typename G>
  constexpr explicit(!std::is_convertible_v<const U &, T> && !std::is_convertible_v<const G &, E>)
      expected(expected<U, G> const & other) {
    if (other.has_value()) {
      value_.template emplace<0>(*other);
    } else {
      value_.template emplace<1>(other.error());
    }
  }

  template <typename U, typename G>
  constexpr explicit(!std::is_convertible_v<U, T> && !std::is_convertible_v<G, E>)
      expected(expected<U, G> && other) {
    if (other.has_value()) {
      value_.template emplace<0>(*std::move(other));
    } else {
      value_.template emplace<1>(std::move(other).error());
    }
  }

  template <typename U = std::remove_cv_t<T>>
    requires(not std::same_as<U, expected<T, E>>)
  constexpr explicit(!std::is_convertible_v<U, T>) expected(U && val)
      : value_(std::in_place_index<0>, std::forward<U>(val)) {}

  template <typename G>
  constexpr explicit(!std::is_convertible_v<const G &, E>) expected(unexpected<G> const & exp)
      : value_(std::in_place_index<1>, exp.error()) {}

  template <typename G>
  constexpr explicit(!std::is_convertible_v<G, E>) expected(unexpected<G> && exp)
      : value_(std::in_place_index<1>, std::move(exp).error()) {}

  template <typename... Args>
  constexpr explicit expected(std::in_place_t, Args &&... args)
      : value_(std::in_place_index<0>, std::forward<Args>(args)...) {}

  template <typename U, typename... Args>
  constexpr explicit expected(std::in_place_t, std::initializer_list<U> init, Args &&... args)
      : value_(std::in_place_index<0>, init, std::forward<Args>(args)...) {}

  template <typename... Args>
  constexpr explicit expected(unexpect_t, Args &&... args)
      : value_(std::in_place_index<1>, std::forward<Args>(args)...) {}

  template <typename U, typename... Args>
  constexpr explicit expected(unexpect_t, std::initializer_list<U> init, Args &&... args)
      : value_(std::in_place_index<1>, init, std::forward<Args>(args)...) {}

  constexpr explicit operator bool() const noexcept { return has_value(); }
  constexpr bool has_value() const noexcept { return value_.index() == 0; }

  constexpr const T * operator->() const noexcept { return std::get_if<0>(&value_); }
  constexpr T * operator->() noexcept { return std::get_if<0>(&value_); }

  constexpr const T & operator*() const & noexcept { return *std::get_if<0>(&value_); }
  constexpr T & operator*() & noexcept { return *std::get_if<0>(&value_); }
  constexpr T && operator*() && noexcept { return std::move(*std::get_if<0>(&value_)); }

  constexpr const T & value() const & {
    if (has_value()) [[likely]] {
      return operator*();
    }
    throw bad_expected_access(error());
  }

  constexpr T & value() & {
    if (has_value()) [[likely]] {
      return operator*();
    }
    throw bad_expected_access(std::as_const(error()));
  }

  constexpr T && value() && {
    if (has_value()) [[likely]] {
      return std::move(*this).operator*();
    }
    throw bad_expected_access(std::move(error()));
  }

  constexpr const E & error() const & noexcept { return *std::get_if<1>(&value_); }
  constexpr E & error() & noexcept { return *std::get_if<1>(&value_); }
  constexpr E && error() && noexcept { return std::move(*std::get_if<1>(&value_)); }

  template <typename F> constexpr auto transform(F && func) & {
    using G = std::invoke_result_t<F, value_type &>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)(**this));
    }
    return expected<G, error_type>(unexpect, error());
  }

  template <typename F> constexpr auto transform(F && func) const & {
    using G = std::invoke_result_t<F, value_type const &>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)(**this));
    }
    return expected<G, error_type>(unexpect, error());
  }

  template <typename F> constexpr auto transform(F && func) && {
    using G = std::invoke_result_t<F, value_type>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)(*std::move(*this)));
    }
    return expected<G, error_type>(unexpect, std::move(*this).error());
  }

  template <typename F> constexpr auto transform_error(F && func) & {
    using G = std::invoke_result_t<F, E &>;
    if (has_value()) {
      return expected<value_type, G>(**this);
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(error()));
  }

  template <typename F> constexpr auto transform_error(F && func) const & {
    using G = std::invoke_result_t<F, E const &>;
    if (has_value()) {
      return expected<value_type, G>(**this);
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(error()));
  }

  template <typename F> constexpr auto transform_error(F && func) && {
    using G = std::invoke_result_t<F, E>;
    if (has_value()) {
      return expected<value_type, G>(*std::move(*this));
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(std::move(*this).error()));
  }

private:
  std::variant<T, E> value_;
};

template <typename E> class expected<void, E> {
public:
  using value_type = void;
  using error_type = E;
  using unexpected_type = unexpected<E>;
  template <typename U> using rebind = expected<U, error_type>;

public:
  constexpr expected() = default;

  template <typename G>
  constexpr explicit(!std::is_convertible_v<const G &, E>)
      expected(expected<void, G> const & other) {
    if (not other.has_value()) {
      *this = other.error();
    }
  }

  template <typename G>
  constexpr explicit(!std::is_convertible_v<G, E>) expected(expected<void, G> && other) {
    if (not other.has_value()) {
      *this = std::move(other).error();
    }
  }

  template <typename G>
  constexpr explicit(!std::is_convertible_v<const G &, E>) expected(unexpected<G> const & exp)
      : value_(exp.error()) {}

  template <typename G>
  constexpr explicit(!std::is_convertible_v<G, E>) expected(unexpected<G> && exp)
      : value_(std::move(exp).error()) {}

  constexpr explicit expected(std::in_place_t) {}

  template <typename... Args>
  constexpr explicit expected(unexpect_t, Args &&... args)
      : value_(std::in_place, std::forward<Args>(args)...) {}

  template <typename U, typename... Args>
  constexpr explicit expected(unexpect_t, std::initializer_list<U> init, Args &&... args)
      : value_(std::in_place, init, std::forward<Args>(args)...) {}

  constexpr explicit operator bool() const noexcept { return has_value(); }
  constexpr bool has_value() const noexcept { return not value_.has_value(); }

  constexpr void operator*() const noexcept {}

  void value() const & noexcept {
    if (has_value()) [[likely]] {
      return operator*();
    }
    throw bad_expected_access(error());
  }

  void value() && noexcept {
    if (has_value()) [[likely]] {
      return operator*();
    }
    throw bad_expected_access(std::move(error()));
  }

  constexpr const E & error() const & noexcept { return *value_; }
  constexpr E & error() & noexcept { return *value_; }
  constexpr E && error() && noexcept { return std::move(*value_); }

  template <typename F> constexpr auto transform(F && func) & {
    using G = std::invoke_result_t<F>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)());
    }
    return expected<G, error_type>(unexpect, error());
  }

  template <typename F> constexpr auto transform(F && func) const & {
    using G = std::invoke_result_t<F>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)());
    }
    return expected<G, error_type>(unexpect, error());
  }

  template <typename F> constexpr auto transform(F && func) && {
    using G = std::invoke_result_t<F>;
    if (has_value()) {
      return expected<G, error_type>(std::forward<F>(func)());
    }
    return expected<G, error_type>(unexpect, std::move(*this).error());
  }

  template <typename F> constexpr auto transform_error(F && func) & {
    using G = std::invoke_result_t<F, E &>;
    if (has_value()) {
      return expected<value_type, G>(**this);
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(error()));
  }

  template <typename F> constexpr auto transform_error(F && func) const & {
    using G = std::invoke_result_t<F, E const &>;
    if (has_value()) {
      return expected<value_type, G>(**this);
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(error()));
  }

  template <typename F> constexpr auto transform_error(F && func) && {
    using G = std::invoke_result_t<F, E>;
    if (has_value()) {
      return expected<value_type, G>(*std::move(*this));
    }
    return expected<value_type, G>(unexpect, std::forward<F>(func)(std::move(*this).error()));
  }

private:
  std::optional<E> value_;
};
}
#endif

namespace jvalidate::detail {
inline std::string to_message(std::errc ecode) { return std::make_error_code(ecode).message(); }
}
// NOLINTEND(readability-identifier-naming)