// Glaze Library

// For the license information refer to glaze.hpp

#pragma once

#include <climits>

#include "glaze/api/xxh64.hpp"

#include "glaze/core/meta.hpp"

// Collision calculations done with the formula: e^((-k * (k - 1)/(2 * N)))

// The approximation error tends to zero as N increases, and we are dealing with a large N

// https://preshing.com/20110504/hash-collision-probabilities/

// With 10,000 registered types the probabilities of a collision are:

// 64 bit hash: 2.71027645e-12 === 1 - 1/e^(6249375/2305843009213693952)

// 128 bit hash: 1.469221e-31 === 1 - 1/e^(6249375/42535295865117307932921825928971026432)

// 256 bit hash: 4.317652e-70 === 1 -

// 1/e^(6249375/14474011154664524427946373126085988481658748083205070504932198000989141204992) Probability of winning

// the Mega Millions lottery: 1 / 302,575,350 === 3.30496189e-9 Number of times winning to equal a collision chance: 64

// bit: 1220 times 128 bit: 2.2494655e22 times (or 22 sextillion times) 256 bit: 7.6545351e60 times From these

// calculations it is apparent that a 128 bit hash is more than sufficient

namespace glz

{

   template <class T, T Value>

   consteval auto make_array()

   {

      return []<size_t... I>(std::index_sequence<I...>) {

         return std::array<char, sizeof(T)>{static_cast<char>(((Value >> (CHAR_BIT * I)) & 0xff))...};

      }(std::make_index_sequence<sizeof(T)>{});

   }

   namespace detail

   {

      // convert an integer to a string_view at compile time

      constexpr uint64_t num_digits(auto x) noexcept // number of digits needed, including minus sign

      {

         return x < 10 ? 1 : 1 + num_digits(x / 10);

      }

      template <char... args>

      struct metastring

      {

         const char data[sizeof...(args)] = {args...};

      };

      // recursive number-printing template, general case (for three or more digits)

      template <uint64_t size, uint64_t x, char... args>

      struct numeric_builder

      {

         using type = typename numeric_builder<size - 1, x / 10, '0' + x % 10, args...>::type;

      };

      // special case for two digits; minus sign is handled here

      template <uint64_t x, char... args>

      struct numeric_builder<2, x, args...>

      {

         using type = metastring<'0' + x / 10, '0' + x % 10, args...>;

      };

      // special case for one digit (positive numbers only)

      template <uint64_t x, char... args>

      struct numeric_builder<1, x, args...>

      {

         using type = metastring<'0' + x, args...>;

      };

      // convenience wrapper for numeric_builder

      template <uint64_t x>

      struct numeric_string

      {

         // generate a unique string type representing this number

         using type = typename numeric_builder<num_digits(x), x, '\0'>::type;

         // declare a static string of that type (instantiated later at file scope)

         static constexpr type value{};

         static constexpr const std::string_view get() { return {value.data, num_digits(x)}; }

      };

   }

   template <class T, T Value>

   struct int_to_sv

   {

      static constexpr auto arr = make_array<T, Value>();

      static consteval std::string_view get() { return {arr.data(), arr.size()}; }

   };

   template <class T, T Value>

   inline constexpr std::string_view int_to_sv_v = int_to_sv<T, Value>{}.get();

   template <uint64_t I>

   inline consteval auto to_sv()

   {

      return detail::numeric_string<I>::get();

   }

   template <size_t I>

   struct hash128_i

   {

      static constexpr sv str = to_sv<I>();

      static constexpr sv h0 = int_to_sv_v<uint64_t, xxh64::hash(str.data(), str.size(), 0)>;

      static constexpr sv h1 = int_to_sv_v<uint64_t, xxh64::hash(str.data(), str.size(), 1)>;

      static constexpr sv value = join_v<h0, h1>;

   };

   template <size_t I>

   inline constexpr std::string_view hash128_i_v = hash128_i<I>::value;

   template <const std::string_view& Str>

   struct hash128

   {

      static constexpr sv h0 = int_to_sv_v<uint64_t, xxh64::hash(Str.data(), Str.size(), 0)>;

      static constexpr sv h1 = int_to_sv_v<uint64_t, xxh64::hash(Str.data(), Str.size(), 1)>;

      static constexpr sv value = join_v<h0, h1>;

   };

   template <const std::string_view& Str>

   constexpr std::string_view hash128_v = hash128<Str>::value;

}