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

#ifndef TEST_SUPPORT_NASTY_STRING_H
#define TEST_SUPPORT_NASTY_STRING_H

#include <algorithm>
#include <cstddef>
#include <string>
#include <type_traits>

#include "make_string.h"
#include "test_macros.h"
#include "constexpr_char_traits.h" // is_pointer_in_range

// This defines a nasty_string similar to nasty_containers. This string's
// value_type does operator hijacking, which allows us to ensure that the
// library uses the provided `CharTraits` instead of using operations on
// the value_type directly.


// When using the code during constant evaluation it relies on
//   P2647R1 Permitting static constexpr variables in constexpr functions
// This is a C++23 feature, which is not supported by all compilers yet.
// * GCC >= 13
// * Clang >= 16
// * MSVC no support yet
//
// TODO After there is proper compiler support use TEST_STD_VER >= 23 instead
// of this macro in the tests.
#if TEST_STD_VER < 23 || __cpp_constexpr < 202211L
#  define TEST_HAS_NO_NASTY_STRING
#endif

#ifndef TEST_HAS_NO_NASTY_STRING
// Make sure the char-like operations in strings do not depend on the char-like type.
struct nasty_char {
  template <typename T>
  friend auto operator<=>(T, T) = delete;

  template <typename T>
  friend void operator+(T&&) = delete;

  template <typename T>
  friend void operator-(T&&) = delete;

  template <typename T>
  friend void operator&(T&&) = delete;

  char c;
};

static_assert(std::is_trivial<nasty_char>::value, "");
static_assert(std::is_standard_layout<nasty_char>::value, "");

// These traits are based on the constexpr_traits test class.
struct nasty_char_traits {
  typedef nasty_char char_type;
  typedef int int_type;
  typedef std::streamoff off_type;
  typedef std::streampos pos_type;
  typedef std::mbstate_t state_type;
  // The comparison_category is omitted so the class will have weak_ordering
  // in C++20. This is intentional.

  static constexpr void assign(char_type& c1, const char_type& c2) noexcept { c1 = c2; }

  static constexpr bool eq(char_type c1, char_type c2) noexcept { return c1.c == c2.c; }

  static constexpr bool lt(char_type c1, char_type c2) noexcept { return c1.c < c2.c; }

  static constexpr int compare(const char_type* s1, const char_type* s2, std::size_t n);
  static constexpr std::size_t length(const char_type* s);
  static constexpr const char_type* find(const char_type* s, std::size_t n, const char_type& a);
  static constexpr char_type* move(char_type* s1, const char_type* s2, std::size_t n);
  static constexpr char_type* copy(char_type* s1, const char_type* s2, std::size_t n);
  static constexpr char_type* assign(char_type* s, std::size_t n, char_type a);

  static constexpr int_type not_eof(int_type c) noexcept { return eq_int_type(c, eof()) ? ~eof() : c; }

  static constexpr char_type to_char_type(int_type c) noexcept { return char_type(c); }

  static constexpr int_type to_int_type(char_type c) noexcept { return int_type(c.c); }

  static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept { return c1 == c2; }

  static constexpr int_type eof() noexcept { return int_type(EOF); }
};

constexpr int nasty_char_traits::compare(const nasty_char* s1, const nasty_char* s2, std::size_t n) {
  for (; n; --n, ++s1, ++s2) {
    if (lt(*s1, *s2))
      return -1;
    if (lt(*s2, *s1))
      return 1;
  }
  return 0;
}

constexpr std::size_t nasty_char_traits::length(const nasty_char* s) {
  std::size_t len = 0;
  for (; !eq(*s, nasty_char(0)); ++s)
    ++len;
  return len;
}

constexpr const nasty_char* nasty_char_traits::find(const nasty_char* s, std::size_t n, const nasty_char& a) {
  for (; n; --n) {
    if (eq(*s, a))
      return s;
    ++s;
  }
  return 0;
}

constexpr nasty_char* nasty_char_traits::move(nasty_char* s1, const nasty_char* s2, std::size_t n) {
  if (s1 == s2)
    return s1;

  nasty_char* r = s1;
  if (is_pointer_in_range(s1, s1 + n, s2)) {
    for (; n; --n)
      assign(*s1++, *s2++);
  } else {
    s1 += n;
    s2 += n;
    for (; n; --n)
      assign(*--s1, *--s2);
  }
  return r;
}

constexpr nasty_char* nasty_char_traits::copy(nasty_char* s1, const nasty_char* s2, std::size_t n) {
  if (!std::is_constant_evaluated()) // fails in constexpr because we might be comparing unrelated pointers
    assert(s2 < s1 || s2 >= s1 + n);
  nasty_char* r = s1;
  for (; n; --n, ++s1, ++s2)
    assign(*s1, *s2);
  return r;
}

constexpr nasty_char* nasty_char_traits::assign(nasty_char* s, std::size_t n, nasty_char a) {
  nasty_char* r = s;
  for (; n; --n, ++s)
    assign(*s, a);
  return r;
}

using nasty_string = std::basic_string<nasty_char, nasty_char_traits>;

template <std::size_t N>
struct ToNastyChar {
  constexpr ToNastyChar(const char (&r)[N]) {
    std::transform(r, r + N, std::addressof(text[0]), [](char c) { return nasty_char{c}; });
  }
  nasty_char text[N];
};

template <std::size_t N>
ToNastyChar(const char (&)[N]) -> ToNastyChar<N>;

template <ToNastyChar t>
constexpr auto to_nasty_char() {
  return t;
}

// A macro like MAKE_CSTRING
//
// The difference is this macro can convert the nasty_char too.
//
// The lambda is a template, so the 'if constexpr' false branch is not evaluated for the nasty_char.
#  define CONVERT_TO_CSTRING(CHAR, STR)                                                                                \
    []<class CharT> {                                                                                                  \
      if constexpr (std::is_same_v<CharT, nasty_char>) {                                                               \
        static constexpr auto result = to_nasty_char<STR>();                                                           \
        return result.text;                                                                                            \
      } else                                                                                                           \
        return MAKE_CSTRING(CharT, STR);                                                                               \
    }.template operator()<CHAR>() /* */
#else                             // TEST_HAS_NO_NASTY_STRING
#  define CONVERT_TO_CSTRING(CharT, STR) MAKE_CSTRING(CharT, STR)
#endif                            // TEST_HAS_NO_NASTY_STRING

#endif                            // TEST_SUPPORT_NASTY_STRING_H
