json-validator/include/jvalidate/format.h

#pragma once
#include <jvalidate/_macro.h>

#include <cctype>
#include <chrono>
#include <cstddef>
#include <cstring>
#include <ctime>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>

#ifdef JVALIDATE_HAS_IDNA
#include <ada/idna/to_unicode.h>
#include <ada/idna/validity.h>
#endif

#include <jvalidate/detail/expect.h>
#include <jvalidate/detail/idna_special_cases.h>
#include <jvalidate/detail/pointer.h>
#include <jvalidate/detail/relative_pointer.h>
#include <jvalidate/detail/string.h>
#include <jvalidate/forward.h>

#define CONSTRUCTS(TYPE) format::ctor_as_valid<detail::TYPE>

#define UTF32(FN) JVALIDATE_IIF(JVALIDATE_HAS_IDNA, format::utf32<format::FN<char32_t>>, nullptr)

namespace jvalidate::format {
bool date(std::string_view dt);
bool time(std::string_view dt);
bool date_time(std::string_view dt);
bool duration(std::string_view dur);

bool uri(std::string_view uri);
bool uuid(std::string_view id);
template <typename CharT = char> bool hostname(std::basic_string_view<CharT> name);

bool ipv4(std::string_view ip);
bool ipv6(std::string_view ip);

template <typename CharT = char> bool email(std::basic_string_view<CharT> em);
}

namespace jvalidate::format::detail {
struct result {
  ptrdiff_t consumed;
  bool valid;
};

inline bool is_leapyear(int y) { return (y % 400) == 0 || ((y % 4) == 0 && (y % 100) != 0); }

inline bool illegal_date(int y, int m, int d) {
  static constexpr int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  if (is_leapyear(y) && m == 1) {
    --d;
  }
  return d > days[m];
}

inline result date(std::string_view dt) {
  struct tm tm;
  if (auto end = strptime(dt.data(), "%Y-%m-%d", &tm); end) {
    if ((end - dt.data()) != 10 || illegal_date(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday)) {
      return {.consumed = 0, .valid = false};
    }
    return {.consumed = end - dt.data(), .valid = true};
  }
  return {.consumed = 0L, .valid = false};
}

inline bool is_leapsecond(std::tm tm) {
  if (tm.tm_sec != 60) {
    return true;
  }

#if __cpp_lib_chrono >= 201907L
  tm.tm_isdst = -1;
  std::chrono::seconds time(std::mktime(&tm));
  auto const & leap_seconds = std::chrono::get_tzdb().leap_seconds;
  return std::ranges::find(leap_seconds, time) != leap_seconds.end();
#else
  return false;
#endif
}

inline bool is_pchar(std::string_view part, size_t & pos,
                     std::string_view extra_valid_chars = ":@") {
  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
  if (std::isalnum(part[pos]) || std::strchr("-._~!$&'()*+,;=", part[pos])) {
    return true;
  }
  if (part[pos] == '%') {
    return std::strchr(g_hex_digits, part[++pos]) && std::strchr(g_hex_digits, part[++pos]);
  }
  return extra_valid_chars.find(part[pos]) != part.npos;
};

inline bool is_uri_authority(std::string_view uri) {
  if (size_t pos = uri.find('@'); pos != uri.npos && pos < uri.find('/')) {
    for (size_t i = 0; i < pos; ++i) {
      if (not is_pchar(uri, i, ":")) {
        return false;
      }
    }
    uri.remove_prefix(pos + 1);
  }
  if (uri[0] == '[') {
    size_t pos = uri.find(']');
    auto ip = uri.substr(1, pos - 1);
    uri.remove_prefix(pos + 1);
    if (not ipv6(ip)) {
      return false;
    }
  }
  if (size_t pos = uri.find(':'); pos != uri.npos) {
    if (not std::ranges::all_of(uri.substr(pos + 1), [](auto c) { return std::isdigit(c); })) {
      return false;
    }
    uri.remove_suffix(uri.size() - pos + 1);
  }
  return ipv4(uri) || hostname(uri);
}
}

namespace jvalidate::format {
inline bool date(std::string_view dt) {
  auto [consumed, valid] = detail::date(dt);
  return valid && consumed == dt.size();
}

inline bool time(std::string_view dt) {
  std::tm tm;
  char const * end = strptime(dt.data(), "%T", &tm);
  if (end == nullptr || end == dt.end() || (end - dt.data()) < 8) {
    return false;
  }
  dt.remove_prefix(end - dt.begin());
  if (dt[0] == '.') {
    dt.remove_prefix(1);
    if (dt.empty() || not std::isdigit(dt[0])) {
      return false;
    }
    while (std::isdigit(dt[0])) {
      dt.remove_prefix(1);
    }
  }

  if (dt[0] == 'Z' || dt[0] == 'z') {
    return dt.size() == 1 && detail::is_leapsecond(tm);
  }
  if (std::strchr("+-", dt[0])) {
    return strptime(dt.data() + 1, "%R", &tm) == dt.end() && detail::is_leapsecond(tm);
  }
  return false;
}

inline bool date_time(std::string_view dt) {
  auto [size, good] = detail::date(dt);
  if (not good || std::strchr("Tt", dt[size]) == nullptr) {
    return false;
  }
  dt.remove_prefix(size + 1);
  return time(dt);
}

inline bool uri(std::string_view uri) {
  auto test_uri_part = [&uri](char delim) {
    size_t const pos = uri.find(delim);
    if (pos == uri.npos) {
      return true;
    }
    auto part = uri.substr(pos + 1);
    uri = uri.substr(0, pos);
    for (size_t pos = 0; pos < part.size(); ++pos) {
      RETURN_UNLESS(detail::is_pchar(part, pos, ":@/?"), false);
    }
    return true;
  };

  // https://www.rfc-editor.org/rfc/rfc3986.html#appendix-A
  if (size_t const pos = uri.find(':'); pos != uri.npos) {
    RETURN_UNLESS(std::isalpha(uri[0]), false);
    for (size_t i = 1; i < pos; ++i) {
      RETURN_UNLESS(std::isalnum(uri[i]) || std::strchr("+-.", uri[i]), false);
    }
    uri.remove_prefix(pos + 1);
  } else {
    return false;
  }

  RETURN_UNLESS(test_uri_part('#'), false);
  RETURN_UNLESS(test_uri_part('?'), false);

  auto path = uri;
  if (uri.starts_with("//")) {
    uri.remove_prefix(2);
    path = uri.substr(std::min(uri.size(), uri.find('/')));
    uri.remove_suffix(path.size());
    RETURN_UNLESS(detail::is_uri_authority(uri), false);
  }

  if (size_t const pos = path.find('/'); pos != path.npos) {
    for (size_t i = 0; i < pos; ++i) {
      RETURN_UNLESS(detail::is_pchar(path, i, "@"), false);
    }
    path.remove_prefix(pos);
  }

  for (size_t i = 0; i < path.size(); ++i) {
    RETURN_UNLESS(detail::is_pchar(path, i, "/:@"), false);
  }

  return true;
}

inline bool uuid(std::string_view id) {
  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
  constexpr size_t g_uuid_len = 36;
  constexpr size_t g_uuid_tokens = 5;
  char tok0[9], tok1[5], tok2[5], tok3[5], tok4[13];

  auto is_hex = [](std::string_view s) {
    return s.find_first_not_of(g_hex_digits) == std::string::npos;
  };
  return id.size() == g_uuid_len &&
         sscanf(id.data(), "%8s-%4s-%4s-%4s-%12s", tok0, tok1, tok2, tok3, tok4) == g_uuid_tokens &&
         is_hex(tok0) && is_hex(tok1) && is_hex(tok2) && is_hex(tok3) && is_hex(tok4);
}

inline bool duration(std::string_view dur) {
  auto eat = [&dur](std::string_view text) {
    char type;
    unsigned int rep;
    if (sscanf(dur.data(), "%u%c", &rep, &type) != 2 || text.find(type) == std::string::npos) {
      return std::string::npos;
    }
    dur.remove_prefix(dur.find(type) + 1);
    return text.find(type);
  };

  if (dur[0] != 'P' || dur.size() == 1) {
    return false;
  }
  dur.remove_prefix(1);

  if (dur[0] != 'T') {
    if (eat("W") != std::string::npos) {
      return dur.empty();
    }
    std::string_view ymd{"YMD"};
    while (not ymd.empty() && not dur.empty()) {
      if (size_t n = eat(ymd); n != std::string::npos) {
        ymd.remove_prefix(n + 1);
      } else {
        return false;
      }
    }
    if (dur.empty()) {
      return true;
    }
  }

  if (dur[0] != 'T' || dur.size() == 1) {
    return false;
  }
  dur.remove_prefix(1);

  std::string_view hms{"HMS"};
  while (not hms.empty() && not dur.empty()) {
    if (size_t n = eat(hms); n != std::string::npos) {
      hms.remove_prefix(n + 1);
    } else {
      return false;
    }
  }
  return dur.empty();
}

template <typename CharT> bool is_invalid_host_char(CharT c) {
  return c != '-' && not(std::isalnum(c) || c > 0x7F);
}

template <typename CharT>
bool is_invalid_size_or_boundary_hostname(std::basic_string_view<CharT> name) {
  using delim = detail::char_delimiters<CharT>;
  return (name.empty() || detail::length_u8(name) >= 64 ||
          (name.size() >= 4 && name.substr(2).starts_with(delim::illegal_dashes_ulabel)) ||
          name[0] == '-' || name.back() == '-');
}

#if !JVALIDATE_HAS_IDNA
inline bool hostname_part(std::string_view name) {
  using delim = detail::char_delimiters<char>;

  if (is_invalid_size_or_boundary_hostname(name)) {
    return false;
  }
  return std::ranges::none_of(name, [](char c) { return c != '-' && not std::isalnum(c); });
}
#else
template <typename CharT> inline bool hostname_part(std::basic_string_view<CharT> name) {
  using delim = detail::char_delimiters<CharT>;
  if (name.starts_with(delim::punycode_prefix)) {
    std::u32string decoded = detail::to_u32(ada::idna::to_unicode(detail::to_u8(name)));
    return (decoded != detail::to_u32(name)) && hostname_part<char32_t>(decoded);
  }

  if (is_invalid_size_or_boundary_hostname(name)) {
    return false;
  }
  if constexpr (std::is_same_v<char, CharT>) {
    return std::ranges::none_of(name, [](char c) { return c != '-' && not std::isalnum(c); });
  } else {
    return ada::idna::is_label_valid(name);
  }
}
#endif

template <typename CharT> inline bool hostname(std::basic_string_view<CharT> name) {
  using delim = detail::char_delimiters<CharT>;
  if (name.find_first_of(delim::illegal_hostname_chars) != name.npos) {
    return false;
  }

  if (detail::to_u8(name).size() > (name.back() == '.' ? 254 : 253)) {
    return false;
  }

  if (not std::ranges::all_of(delim::special_cases,
                              [name](auto & sc) { return sc.accepts(name); })) {
    return false;
  }

  for (size_t n = name.find('.'); n != std::string::npos;
       name.remove_prefix(n + 1), n = name.find('.')) {
    if (not hostname_part(name.substr(0, n))) {
      return false;
    }
  }
  return name.empty() || hostname_part(name);
}

inline bool ipv4(std::string_view ip) {
  unsigned int ip0, ip1, ip2, ip3;
  char eof;
  if (ip.find_first_not_of("0123456789.") != std::string::npos) {
    return false;
  }
  if (ip[0] == '0' && std::isdigit(ip[1])) {
    return false;
  }
  if (size_t n = ip.find(".0"); n != std::string::npos && std::isdigit(ip[n + 2])) {
    return false;
  }
  if (sscanf(std::string(ip).c_str(), "%3u.%3u.%3u.%3u%c", &ip0, &ip1, &ip2, &ip3, &eof) != 4) {
    return false;
  }
  return ip0 <= 0xFF && ip1 <= 0xFF && ip2 <= 0xFF && ip3 <= 0xFF;
}

inline bool ipv6(std::string_view ip) {
  int expected_spans = 8;

  if (size_t n = ip.find('.'); n != std::string::npos) {
    if (not ipv4(ip.substr(ip.find_last_of(':') + 1))) {
      return false;
    }
    // This is a cheat to allow e.g. ::127.0.0.1 to validate
    expected_spans = 7;
    ip = ip.substr(0, n);
  }

  if (ip.find_first_not_of("0123456789ABCDEFabcdef:") != std::string::npos) {
    return false;
  }
  if (ip.size() >= 40) {
    return false;
  }

  bool has_compressed = false;
  int groups = 0;

  if (ip.starts_with("::")) {
    has_compressed = true;
    ip.remove_prefix(2);
  }
  while (!ip.empty()) {
    int data;
    if (sscanf(ip.data(), "%4x", &data) != 1) {
      return false;
    }
    if (size_t n = ip.find(':'); std::min(n, ip.size()) > 4) {
      return false;
    } else if (n != std::string::npos) {
      ip.remove_prefix(n + 1);
    } else {
      ip = "";
    }
    ++groups;
    if (ip[0] == ':') {
      if (std::exchange(has_compressed, true)) {
        return false;
      }
      ip.remove_prefix(1);
    }
  }

  return groups == expected_spans || (has_compressed && groups < expected_spans);
}

// Let's be honest - no matter what RFC 5321 §4.1.2 or RFC 6531 say, the only
// way to know if an email address is valid is to try and send a message to it.
// Therefore, there's no point in trying to validate things according to a
// complex grammar - as long as it has an '@' sign with at least one character
// on each side, we ought to call it an email.
template <typename CharT> inline bool email(std::basic_string_view<CharT> em) {
  using delim = detail::char_delimiters<CharT>;
  size_t n = em.find_last_of('@');
  if (n == 0 || n >= em.size() - 1) {
    return false;
  }

  auto const who = em.substr(0, n);
  if (who.starts_with('"') && who.ends_with('"')) {
    // No validation
  } else if (who.starts_with('.') || who.ends_with('.')) {
    return false;
  } else if (em.substr(0, n).find(delim::dotdot) != em.npos) {
    return false;
  }

  auto domain = em.substr(n + 1);
  if (not(domain.starts_with('[') && domain.ends_with(']'))) {
    return hostname(domain);
  }
  domain.remove_prefix(1);
  domain.remove_suffix(1);

  if (auto ip = detail::to_u8(domain); ip.starts_with("IPv6:")) {
    return ipv6(ip.substr(5));
  } else {
    return ipv4(ip);
  }
}

template <typename T> inline bool ctor_as_valid(std::string_view str) {
  try {
    [[maybe_unused]] auto _ = T(str);
    return true;
  } catch (std::exception const &) { return false; }
}

template <auto Predicate> bool utf32(std::string_view str) {
  return Predicate(detail::to_u32(str));
}
}

namespace jvalidate {
class FormatValidator {
public:
  using Predicate = bool (*)(std::string_view);
  enum class Status { Unknown, Unimplemented, Valid, Invalid };

private:
  std::unordered_map<std::string, Predicate> supported_formats_{
      {"date", &format::date},
      {"date-time", &format::date_time},
      {"duration", &format::duration},
      {"email", &format::email},
      {"hostname", &format::hostname},
      {"idn-email", UTF32(email)},
      {"idn-hostname", UTF32(hostname)},
      {"ipv4", &format::ipv4},
      {"ipv6", &format::ipv6},
      {"iri", nullptr},
      {"iri-reference", nullptr},
      {"json-pointer", CONSTRUCTS(Pointer)},
      {"relative-json-pointer", CONSTRUCTS(RelativePointer)},
      {"regex", nullptr},
      {"time", &format::time},
      {"uri", &format::uri},
      {"uri-reference", nullptr},
      {"uri-template", nullptr},
      {"uuid", &format::uuid},
  };

public:
  FormatValidator() = default;
  FormatValidator(Predicate is_regex) { supported_formats_.insert_or_assign("regex", is_regex); }

  Status operator()(std::string const & format, std::string_view text) const {
    if (auto it = supported_formats_.find(format); it != supported_formats_.end() && it->second) {
      if (not it->second) {
        return Status::Unimplemented;
      }
      return it->second(text) ? Status::Valid : Status::Invalid;
    }
    return Status::Unknown;
  }
};
}

#undef CONSTRUCTS
#undef UTF32