#ifndef CORE_HPPASH_CODE_HPP
#define CORE_HPPASH_CODE_HPP

#include <limits.h>

#include "core/utils/Meta.hpp"
#include "core/utils/Types.hpp"

namespace Core {
    template<typename H>
    inline size_t hashCode(const H& key) {
        return key.hashCode();
    }

    template<typename T>
    inline size_t hashNumber(T t) {
        static_assert(sizeof(t) <= sizeof(size_t));
        return static_cast<size_t>(t);
    }

    inline size_t hashCode(char key) {
        return hashNumber(key);
    }

    inline size_t hashCode(signed char key) {
        return hashNumber(key);
    }

    inline size_t hashCode(signed short key) {
        return hashNumber(key);
    }

    inline size_t hashCode(signed int key) {
        return hashNumber(key);
    }

    inline size_t hashCode(signed long key) {
        return hashNumber(key);
    }

    inline size_t hashCode(signed long long key) {
        return hashNumber(key);
    }

    inline size_t hashCode(unsigned char key) {
        return hashNumber(key);
    }

    inline size_t hashCode(unsigned short key) {
        return hashNumber(key);
    }

    inline size_t hashCode(unsigned int key) {
        return hashNumber(key);
    }

    inline size_t hashCode(unsigned long key) {
        return hashNumber(key);
    }

    inline size_t hashCode(unsigned long long key) {
        return hashNumber(key);
    }

    template<typename T>
    inline consteval T emptyValue() {
        if constexpr(Core::IsSame<char, T>) {
            return CHAR_MAX;
        } else if constexpr(Core::IsSame<signed char, T>) {
            return SCHAR_MAX;
        } else if constexpr(Core::IsSame<signed short, T>) {
            return SHRT_MAX;
        } else if constexpr(Core::IsSame<signed int, T>) {
            return INT_MAX;
        } else if constexpr(Core::IsSame<signed long, T>) {
            return LONG_MAX;
        } else if constexpr(Core::IsSame<signed long long, T>) {
            return LLONG_MAX;
        } else if constexpr(Core::IsSame<unsigned char, T>) {
            return UCHAR_MAX;
        } else if constexpr(Core::IsSame<unsigned short, T>) {
            return USHRT_MAX;
        } else if constexpr(Core::IsSame<unsigned int, T>) {
            return UINT_MAX;
        } else if constexpr(Core::IsSame<unsigned long, T>) {
            return ULONG_MAX;
        } else if constexpr(Core::IsSame<unsigned long long, T>) {
            return ULLONG_MAX;
        } else {
            return T::emptyValue();
        }
    }
}

#endif