//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14, c++17

//  template<bool OtherConst>
//    requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
//  friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);

#include <array>
#include <cassert>
#include <ranges>

#include "../types.h"
#include "test_range.h"

template <bool Const>
struct Iter {
  std::tuple<int>* it_;

  using value_type       = std::tuple<int>;
  using difference_type  = std::intptr_t;
  using iterator_concept = std::input_iterator_tag;

  constexpr decltype(auto) operator*() const { return *it_; }
  constexpr Iter& operator++() {
    ++it_;
    return *this;
  }
  constexpr void operator++(int) { ++it_; }
};

template <bool Const>
struct Sent {
  std::tuple<int>* end_;

  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
};

template <bool Const>
struct CrossComparableSent {
  std::tuple<int>* end_;

  template <bool C>
  constexpr bool operator==(const Iter<C>& i) const {
    return i.it_ == end_;
  }
};

template <template <bool> typename St>
struct Range : TupleBufferView {
  using TupleBufferView::TupleBufferView;
  constexpr Iter<false> begin() { return Iter<false>{buffer_}; }
  constexpr Iter<true> begin() const { return Iter<true>{buffer_}; }
  constexpr St<false> end() { return St<false>{buffer_ + size_}; }
  constexpr St<true> end() const { return St<true>{buffer_ + size_}; }
};

using R                = Range<Sent>;
using CrossComparableR = Range<CrossComparableSent>;

using std::ranges::elements_view;
using std::ranges::iterator_t;
using std::ranges::sentinel_t;

static_assert(weakly_equality_comparable_with<iterator_t<elements_view<R, 0>>, //
                                              sentinel_t<elements_view<R, 0>>>);

static_assert(!weakly_equality_comparable_with<iterator_t<const elements_view<R, 0>>, //
                                               sentinel_t<elements_view<R, 0>>>);

static_assert(!weakly_equality_comparable_with<iterator_t<elements_view<R, 0>>, //
                                               sentinel_t<const elements_view<R, 0>>>);

static_assert(weakly_equality_comparable_with<iterator_t<const elements_view<R, 0>>, //
                                              sentinel_t<const elements_view<R, 0>>>);

static_assert(weakly_equality_comparable_with<iterator_t<elements_view<CrossComparableR, 0>>, //
                                              sentinel_t<elements_view<CrossComparableR, 0>>>);

static_assert(weakly_equality_comparable_with<iterator_t<const elements_view<CrossComparableR, 0>>, //
                                              sentinel_t<elements_view<CrossComparableR, 0>>>);

static_assert(weakly_equality_comparable_with<iterator_t<elements_view<CrossComparableR, 0>>, //
                                              sentinel_t<const elements_view<CrossComparableR, 0>>>);

static_assert(weakly_equality_comparable_with<iterator_t<const elements_view<CrossComparableR, 0>>, //
                                              sentinel_t<const elements_view<CrossComparableR, 0>>>);

template <class R, bool ConstIter, bool ConstSent>
constexpr void testOne() {
  auto getBegin = [](auto&& rng) {
    if constexpr (ConstIter) {
      return std::as_const(rng).begin();
    } else {
      return rng.begin();
    }
  };

  auto getEnd = [](auto&& rng) {
    if constexpr (ConstSent) {
      return std::as_const(rng).end();
    } else {
      return rng.end();
    }
  };

  // iter == sentinel.base
  {
    std::tuple<int> buffer[] = {{1}};
    R v{buffer};
    std::ranges::elements_view<R, 0> ev(v);
    auto iter = getBegin(ev);
    auto st   = getEnd(ev);
    ++iter;
    assert(iter == st);
  }

  // iter != sentinel.base
  {
    std::tuple<int> buffer[] = {{1}};
    R v{buffer};
    std::ranges::elements_view<R, 0> ev(v);
    auto iter = getBegin(ev);
    auto st   = getEnd(ev);
    assert(iter != st);
  }

  // empty range
  {
    std::array<std::tuple<int>, 0> arr;
    R v{arr};
    std::ranges::elements_view<R, 0> ev(v);
    auto iter = getBegin(ev);
    auto sent = getEnd(ev);
    assert(iter == sent);
  }
}

constexpr bool test() {
  testOne<R, false, false>();
  testOne<R, true, true>();
  testOne<CrossComparableR, false, false>();
  testOne<CrossComparableR, true, true>();
  testOne<CrossComparableR, true, false>();
  testOne<CrossComparableR, false, true>();

  return true;
}

int main(int, char**) {
  test();
  static_assert(test());

  return 0;
}