/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2026 Sadie Powell <sadie@witchery.services>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "inspircd.h"

const insp::casemap ascii_case_insensitive_map[256] = {
	0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,
	16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
	32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
	48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
	64,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
	112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91,  92,  93,  94,  95,
	96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
	112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
	128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
	144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
	160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
	176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
	192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
	208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
	224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
	240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
};

const insp::casemap* national_case_insensitive_map = ascii_case_insensitive_map;

// These functions are from the Public Domain implementation of MurmurHash2
// by Austin Appleby but modified to remove C++ warnings and to hash case
// insensitively using the IRC casemapping. Do not make changes to them if you
// do not know what you are doing.
#if SIZE_MAX == UINT64_MAX
# define MURMUR_SEED_MAX UINT64_MAX
# define MURMUR_SEED_TYPE uint64_t
# define MURMUR_HASH MurmurHash64A
static uint64_t MurmurHash64A(const void* key, int len, uint64_t seed)
{
	const uint64_t m = 0xc6a4a7935bd1e995ULL;
	const int r = 47;

	uint64_t h = seed ^ (len * m);

	const uint64_t* data = (const uint64_t*)key;
	const uint64_t* end = data + (len / 8);

	while (data != end)
	{
		uint64_t k = insp::map_case(*data++);

		k *= m;
		k ^= k >> r;
		k *= m;

		h ^= k;
		h *= m;
	}

	const unsigned char* data2 = (const unsigned char*)data;

	switch (len & 7)
	{
		case 7:
			h ^= uint64_t(insp::map_case(data2[6])) << 48;
			[[fallthrough]];
		case 6:
			h ^= uint64_t(insp::map_case(data2[5])) << 40;
			[[fallthrough]];
		case 5:
			h ^= uint64_t(insp::map_case(data2[4])) << 32;
			[[fallthrough]];
		case 4:
			h ^= uint64_t(insp::map_case(data2[3])) << 24;
			[[fallthrough]];
		case 3:
			h ^= uint64_t(insp::map_case(data2[2])) << 16;
			[[fallthrough]];
		case 2:
			h ^= uint64_t(insp::map_case(data2[1])) << 8;
			[[fallthrough]];
		case 1:
			h ^= uint64_t(insp::map_case(data2[0]));
			h *= m;
			break;
	};

	h ^= h >> r;
	h *= m;
	h ^= h >> r;

	return h;
}
#else
# if SIZE_MAX != UINT32_MAX
#  warning SIZE_MAX is an unknown size; falling back to 32-bit MurmurHash
# endif
# define MURMUR_SEED_MAX UINT32_MAX
# define MURMUR_SEED_TYPE uint32_t
# define MURMUR_HASH MurmurHash2A

# define mmix(h,k) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
static uint32_t MurmurHash2A(const void * key, int len, uint32_t seed)
{
	const uint32_t m = 0x5bd1e995;
	const int r = 24;
	uint32_t l = len;

	const unsigned char* data = (const unsigned char*)key;

	uint32_t h = seed;

	while(len >= 4)
	{
		uint32_t k = insp::map_case(*(uint32_t*)data);

		mmix(h, k);

		data += 4;
		len -= 4;
	}

	uint32_t t = 0;

	switch(len)
	{
		case 3:
			t ^= insp::map_case(data[2]) << 16;
			[[fallthrough]];
		case 2:
			t ^= insp::map_case(data[1]) << 8;
			[[fallthrough]];
		case 1:
			t ^= insp::map_case(data[0]);
			break;
	};

	mmix(h, t);
	mmix(h, l);

	h ^= h >> 13;
	h *= m;
	h ^= h >> 15;

	return h;
}
# undef mmix
#endif


bool insp::casemapped_equals(const std::string_view& str1, const std::string_view& str2, const insp::casemap* map)
{
	if (str1.length() != str2.length())
		return false;

	if (!map) [[likely]]
		map = national_case_insensitive_map;

	for (size_t idx = 0; idx < str1.length(); ++idx)
	{
		const auto chr1 = static_cast<unsigned char>(str1[idx]);
		const auto chr2 = static_cast<unsigned char>(str2[idx]);
		if (map[chr1] != map[chr2])
			return false;
	}
	return true;
}

bool insp::casemapped_less(const std::string_view& str1, const std::string_view& str2, const insp::casemap* map)
{
	if (!map) [[likely]]
		map = national_case_insensitive_map;

	const auto maxsize = std::min(str1.length(), str2.length());
	for (size_t idx = 0; idx < maxsize; ++idx)
	{
		const auto chr1 = map[static_cast<unsigned char>(str1[idx])];
		const auto chr2 = map[static_cast<unsigned char>(str2[idx])];
		if (chr1 > chr2)
			return false;
		else if (chr1 < chr2)
			return true;
	}
	return str1.length() < str2.length();
}

size_t insp::casemapped_hash(const std::string_view& str)
{
	static auto seed_initialized = false;
	static MURMUR_SEED_TYPE seed;
	if (!seed_initialized) [[unlikely]]
	{
		seed = ServerInstance->GenRandomInt(MURMUR_SEED_MAX);
		seed_initialized = true;
	}
	return MURMUR_HASH(str.data(), static_cast<int>(str.length()), seed);
}