//===----------------------------------------------------------------------===//
//
// 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

// std::views::drop

#include <ranges>

#include <array>
#include <cassert>
#include <concepts>
#include <span>
#include <string_view>
#include <utility>

#include "test_iterators.h"
#include "test_range.h"

struct SizedView : std::ranges::view_base {
  int* begin_ = nullptr;
  int* end_ = nullptr;
  constexpr SizedView(int* begin, int* end) : begin_(begin), end_(end) {}

  constexpr auto begin() const { return forward_iterator<int*>(begin_); }
  constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
};
static_assert(std::ranges::forward_range<SizedView>);
static_assert(std::ranges::sized_range<SizedView>);
static_assert(std::ranges::view<SizedView>);

struct SizedViewWithUnsizedSentinel : std::ranges::view_base {
  using iterator = random_access_iterator<int*>;
  using sentinel = sentinel_wrapper<random_access_iterator<int*>>;

  int* begin_ = nullptr;
  int* end_ = nullptr;
  constexpr SizedViewWithUnsizedSentinel(int* begin, int* end) : begin_(begin), end_(end) {}

  constexpr auto begin() const { return iterator(begin_); }
  constexpr auto end() const { return sentinel(iterator(end_)); }
  constexpr std::size_t size() const { return end_ - begin_; }
};
static_assert(std::ranges::random_access_range<SizedViewWithUnsizedSentinel>);
static_assert(std::ranges::sized_range<SizedViewWithUnsizedSentinel>);
static_assert(!std::sized_sentinel_for<SizedViewWithUnsizedSentinel::sentinel, SizedViewWithUnsizedSentinel::iterator>);
static_assert(std::ranges::view<SizedViewWithUnsizedSentinel>);

template <class T>
constexpr void test_small_range(const T& input) {
  constexpr int N = 100;
  auto size = std::ranges::size(input);
  assert(size < N);

  auto result = input | std::views::drop(N);
  assert(result.empty());
}

constexpr bool test() {
  constexpr int N = 8;
  int buf[N] = {1, 2, 3, 4, 5, 6, 7, 8};

  // Test that `std::views::drop` is a range adaptor.
  {
    using SomeView = SizedView;

    // Test `view | views::drop`
    {
      SomeView view(buf, buf + N);
      std::same_as<std::ranges::drop_view<SomeView>> decltype(auto) result = view | std::views::drop(3);
      assert(result.base().begin_ == buf);
      assert(result.base().end_ == buf + N);
      assert(base(result.begin()) == buf + 3);
      assert(base(base(result.end())) == buf + N);
      assert(result.size() == 5);
    }

    // Test `adaptor | views::drop`
    {
      SomeView view(buf, buf + N);
      auto f = [](int i) { return i; };
      auto const partial = std::views::transform(f) | std::views::drop(3);

      using Result = std::ranges::drop_view<std::ranges::transform_view<SomeView, decltype(f)>>;
      std::same_as<Result> decltype(auto) result = partial(view);
      assert(result.base().base().begin_ == buf);
      assert(result.base().base().end_ == buf + N);
      assert(base(result.begin().base()) == buf + 3);
      assert(base(base(result.end().base())) == buf + N);
      assert(result.size() == 5);
    }

    // Test `views::drop | adaptor`
    {
      SomeView view(buf, buf + N);
      auto f = [](int i) { return i; };
      auto const partial = std::views::drop(3) | std::views::transform(f);

      using Result = std::ranges::transform_view<std::ranges::drop_view<SomeView>, decltype(f)>;
      std::same_as<Result> decltype(auto) result = partial(view);
      assert(result.base().base().begin_ == buf);
      assert(result.base().base().end_ == buf + N);
      assert(base(result.begin().base()) == buf + 3);
      assert(base(base(result.end().base())) == buf + N);
      assert(result.size() == 5);
    }

    // Check SFINAE friendliness
    {
      struct NotAView { };
      static_assert(!std::is_invocable_v<decltype(std::views::drop)>);
      static_assert(!std::is_invocable_v<decltype(std::views::drop), NotAView, int>);
      static_assert( CanBePiped<SomeView&,   decltype(std::views::drop(3))>);
      static_assert( CanBePiped<int(&)[10],  decltype(std::views::drop(3))>);
      static_assert(!CanBePiped<int(&&)[10], decltype(std::views::drop(3))>);
      static_assert(!CanBePiped<NotAView,    decltype(std::views::drop(3))>);

      static_assert(!CanBePiped<SomeView&,   decltype(std::views::drop(/*n=*/NotAView{}))>);
    }
  }

  {
    static_assert(std::same_as<decltype(std::views::drop), decltype(std::ranges::views::drop)>);
  }

  // `views::drop(empty_view, n)` returns an `empty_view`.
  {
    using Result = std::ranges::empty_view<int>;
    [[maybe_unused]] std::same_as<Result> decltype(auto) result = std::views::empty<int> | std::views::drop(3);
  }

  // `views::drop(span, n)` returns a `span`.
  {
    std::span<int> s(buf);
    std::same_as<decltype(s)> decltype(auto) result = s | std::views::drop(5);
    assert(result.size() == 3);
  }

  // `views::drop(span, n)` returns a `span` with a dynamic extent, regardless of the input `span`.
  {
    std::span<int, 8> s(buf);
    std::same_as<std::span<int, std::dynamic_extent>> decltype(auto) result = s | std::views::drop(3);
    assert(result.size() == 5);
  }

  // `views::drop(string_view, n)` returns a `string_view`.
  {
    {
      std::string_view sv = "abcdef";
      std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::drop(2);
      assert(result.size() == 4);
    }

    {
      std::u32string_view sv = U"abcdef";
      std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::drop(2);
      assert(result.size() == 4);
    }
  }

  // `views::drop(iota_view, n)` returns an `iota_view`.
  {
    auto iota = std::views::iota(1, 8);
    // The second template argument of the resulting `iota_view` is different because it has to be able to hold
    // the `range_difference_t` of the input `iota_view`.
    using Result = std::ranges::iota_view<int, int>;
    std::same_as<Result> decltype(auto) result = iota | std::views::drop(3);
    assert(result.size() == 4);
    assert(*result.begin() == 4);
    assert(*std::ranges::next(result.begin(), 3) == 7);
  }

  // `views::drop(subrange, n)` returns a `subrange` when `subrange::StoreSize == false`.
  {
    auto subrange = std::ranges::subrange(buf, buf + N);
    LIBCPP_STATIC_ASSERT(!decltype(subrange)::_StoreSize);

    using Result = std::ranges::subrange<int*>;
    std::same_as<Result> decltype(auto) result = subrange | std::views::drop(3);
    assert(result.size() == 5);
  }

  // `views::drop(subrange, n)` returns a `subrange` when `subrange::StoreSize == true`.
  {
    using View = SizedViewWithUnsizedSentinel;
    View view(buf, buf + N);

    using Subrange = std::ranges::subrange<View::iterator, View::sentinel, std::ranges::subrange_kind::sized>;
    auto subrange = Subrange(view.begin(), view.end(), std::ranges::distance(view.begin(), view.end()));
    LIBCPP_STATIC_ASSERT(decltype(subrange)::_StoreSize);

    std::same_as<Subrange> decltype(auto) result = subrange | std::views::drop(3);
    assert(result.size() == 5);
  }

  // `views::drop(subrange, n)` doesn't return a `subrange` if it's not a random access range.
  {
    SizedView v(buf, buf + N);
    auto subrange = std::ranges::subrange(v.begin(), v.end());

    using Result = std::ranges::drop_view<std::ranges::subrange<forward_iterator<int*>,
        sized_sentinel<forward_iterator<int*>>>>;
    std::same_as<Result> decltype(auto) result = subrange | std::views::drop(3);
    assert(result.size() == 5);
  }

  // When the size of the input range `s` is shorter than `n`, an `empty_view` is returned.
  {
    test_small_range(std::span(buf));
    test_small_range(std::string_view("abcdef"));
    test_small_range(std::ranges::subrange(buf, buf + N));
    test_small_range(std::views::iota(1, 8));
  }

#if TEST_STD_VER >= 23
  // `views::drop(repeat_view, n)` returns a `repeat_view` when `repeat_view` models `sized_range`.
  {
    auto repeat                                = std::ranges::repeat_view<int, int>(1, 8);
    using Result                               = std::ranges::repeat_view<int, int>;
    std::same_as<Result> decltype(auto) result = repeat | std::views::drop(3);
    static_assert(std::ranges::sized_range<Result>);
    assert(result.size() == 5);
    assert(*result.begin() == 1);
  }

  // `views::drop(repeat_view, n)` returns a `repeat_view` when `repeat_view` doesn't model `sized_range`.
  {
    auto repeat                                = std::ranges::repeat_view<int>(1);
    using Result                               = std::ranges::repeat_view<int, std::unreachable_sentinel_t>;
    std::same_as<Result> decltype(auto) result = repeat | std::views::drop(3);
    static_assert(!std::ranges::sized_range<Result>);
    static_assert(std::same_as<std::unreachable_sentinel_t, decltype(result.end())>);
  }
#endif

  // Test that it's possible to call `std::views::drop` with any single argument as long as the resulting closure is
  // never invoked. There is no good use case for it, but it's valid.
  {
    struct X { };
    [[maybe_unused]] auto partial = std::views::drop(X{});
  }

  return true;
}

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

  return 0;
}