/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2012-2013, 2017-2025 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2012 Robby <robby@chatbelgie.be>
 *   Copyright (C) 2012 ChrisTX <xpipe@hotmail.de>
 *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
 *   Copyright (C) 2007-2009 Dennis Friis <peavey@inspircd.org>
 *   Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
 *   Copyright (C) 2007 Oliver Lupton <om@inspircd.org>
 *   Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org>
 *
 * 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/>.
 */


#pragma once

#include <cfloat>
#include <climits>
#include <csignal>
#include <cstdarg>
#include <cstdint>
#include <cstring>

#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <deque>
#include <functional>
#include <memory>
#include <map>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

#ifndef _WIN32
# include <sys/time.h>
#endif

#include "utility/aligned_storage.h"
#include "utility/iterator_range.h"

#include "intrusive_list.h"
#include "flat_map.h"
#include "compat.h"
#include "typedefs.h"
#include "convto.h"
#include "stdalgo.h"
#include "exception.h"

CoreExport extern InspIRCd* ServerInstance;

#include "config.h"
#include "dynref.h"
#include "cull.h"
#include "extensible.h"
#include "ctables.h"
#include "numeric.h"
#include "uid.h"
#include "server.h"
#include "token_list.h"
#include "users.h"
#include "channels.h"
#include "timer.h"
#include "hashcomp.h"
#include "channelmanager.h"
#include "usermanager.h"
#include "socket.h"
#include "command_parse.h"
#include "mode.h"
#include "socketengine.h"
#include "snomasks.h"
#include "message.h"
#include "modules.h"
#include "moduledefs.h"
#include "clientprotocol.h"
#include "thread.h"
#include "configreader.h"
#include "protocol.h"
#include "bancache.h"
#include "logging.h"

/** This class contains various STATS counters
 * It is used by the InspIRCd class, which internally
 * has an instance of it.
 */
class ServerStats final
{
public:
	/** Number of accepted connections. */
	size_t Accept = 0;

	/** Number of rejected connections. */
	size_t Refused = 0;

	/** Number of unknown commands seen. */
	size_t Unknown = 0;

	/** Number of nickname collisions handled. */
	size_t Collisions = 0;

	/** Number of fully connected users seen. */
	size_t Connects = 0;

	/** Total bytes of data transmitted. */
	size_t Sent = 0;

	/** Total bytes of data received. */
	size_t Recv = 0;

#ifdef _WIN32
	/** CPU performance frequency on boot. */
	LARGE_INTEGER BootCPU;

	/** CPU performance frequency at the last sample. */
	LARGE_INTEGER LastCPU;

	/** Time the last sample was read. */
	FILETIME LastSampled;
#else
	/** CPU usage at the last sample. */
	timeval LastCPU;

	/** Time the last sample was read. */
	timespec LastSampled;
#endif
};

/** The main class of the irc server.
 * This class contains instances of all the other classes in this software.
 * Amongst other things, it contains a ModeParser, a DNS object, a CommandParser
 * object, and a list of active Module objects, and facilities for Module
 * objects to interact with the core system it implements.
 */
class CoreExport InspIRCd final
{
private:
	/** The last signal that was received from the operating system. */
	static sig_atomic_t lastsignal;

	/** A 64k buffer used to read socket data into. */
	char readbuffer[65535];

	/** The client protocol events provided by the core. */
	ClientProtocol::RFCEvents rfcevents;

	/** The current time, updated once per main loop iteration. */
	struct timespec ts;

	/** Prepares the server for restart or shutdown. */
	void Cleanup();

	/** Handles an stored signal in the main loop.
	 * @param signal The signal received from the operating system.
	 */
	void HandleSignal(sig_atomic_t signal);

	/** Attempt to write the process id to a file. */
	void WritePID();

public:
	/** Actions that must happen outside of the current call stack. */
	ActionList AtomicActions;

	/** Caches server bans to speeds up checking of restrictions on connect. */
	BanCacheManager BanCache;

	/** Manager for state relating to channels. */
	ChannelManager Channels;

	/** Default implementation of the protocol interface which does nothing. */
	ProtocolInterface DefaultProtocolInterface;

	/* Manager for the extension system. */
	ExtensionManager Extensions;

	/** Objects that should be culled outside of the current call stack. */
	CullList GlobalCulls;

	/** Manager for the logging system. */
	Log::Manager Logs;

	/* Manager for the mode handlers. */
	ModeParser Modes;

	/** Manager for the module loading system. */
	ModuleManager Modules;

	/** Manager for the command handlers. */
	CommandParser Parser;

	/** Manages sending snomasks to server operators. */
	SnomaskManager SNO;

	/** Holds miscellaneous stats counters. */
	ServerStats Stats;

	/** Manages scheduling and triggering of timer events. */
	TimerManager Timers;

	/* Generator for unique user identifiers. */
	UIDGenerator UIDGen;

	/** Manager for state relating to users. */
	UserManager Users;

	/** The server configuration. */
	ServerConfig* Config = nullptr;

	/* If non-nullptr then the thread that is reading the server configuration on rehash. */
	ConfigReaderThread* ConfigThread = nullptr;

	/** A fake user that represents the local server. */
	FakeUser* FakeClient = nullptr;

	/** The protocol interface used for interacting with remote servers by the linking module. */
	ProtocolInterface* PI = &DefaultProtocolInterface;

	/** Manager for X-lines. */
	XLineManager* XLines = nullptr;

	/** The current server configuration file from --config or configure. */
	std::string ConfigFileName;

	/** Fills a buffer with random bytes. */
	std::function<void(char*, size_t)> GenRandom = &DefaultGenRandom;

	/** Determines whether a nickname is valid. */
	std::function<bool(const std::string_view&)> IsNick = &DefaultIsNick;

	/** Determines whether a username is valid. */
	std::function<bool(const std::string_view&)> IsUser = &DefaultIsUser;

	/** List of the open listeners. */
	std::vector<ListenSocket*> ports;

	/** The time at which the server was started. */
	time_t startup_time;

	/** Initialises a new server instance and stores it in ServerInstance
	 * @param argc The argument count from main().
	 * @param argv The argument list from main().
	 */
	InspIRCd(int argc, char** argv);

	/** Binds to a specific port from a config tag.
	 * @param tag the tag that contains bind information.
	 * @param sa The endpoint to listen on.
	 * @param oldports Previously listening ports that may be on the same endpoint.
	 * @param protocol The protocol to bind with or 0 to determine from the endpoint.
	 * @return True if the port was bound successfully; otherwise, false.
	 */
	bool BindPort(const std::shared_ptr<ConfigTag>& tag, const irc::sockets::sockaddrs& sa, std::vector<ListenSocket*>& oldports, sa_family_t protocol);

	/** Binds all ports specified in the configuration file.
	 * @param failedports The location to store details about the ports that failed to bind.
	 * @return The number of ports bound without error.
	 */
	size_t BindPorts(FailedPortList& failedports);

	/** Compares a password to a hashed password.
	 * @param password The hashed password.
	 * @param passwordhash If non-empty then the algorithm the password is hashed with.
	 * @param value The value to check to see if the password is valid.
	 * @return True if the password is correct, otherwise, false.
	 */
	static bool CheckPassword(const std::string& password, const std::string& passwordhash, const std::string& value);

	/** Generates a random integer.
	 * @param max The maximum value for the integer.
	 * @return A random integer between 0 and \p max.
	 */
	unsigned long GenRandomInt(unsigned long max) const;

	/** Generates a human readable random string.
	 * @param length The length in bytes.
	 * @return  A random string of \p length bytes.
	 */
	std::string GenRandomStr(size_t length) const;

	/** Generates a random string.
	 * @param length The length in bytes.
	 * @param printable Whether to only return printable characters.
	 * @return  A random string of \p length bytes.
	 */
	[[deprecated("Use GenRandomStr(length) or GenRandom(buf, len) instead")]]
	std::string GenRandomStr(size_t length, bool printable) const;

	/** Retrieves a 64k buffer used to read socket data into. */
	inline auto* GetReadBuffer() { return readbuffer; }

	/** Retrieves the client protocol events provided by the core. */
	inline auto& GetRFCEvents() { return rfcevents; }

	/** Fills the output buffer with the specified number of random characters.
	 * This is the default function for InspIRCd::GenRandom.
	 * @param output The output buffer to store random characters in.
	 * @param max The maximum number of random characters to put in the buffer.
	 */
	static void DefaultGenRandom(char* output, size_t max);

	/** Determines whether a nickname is valid according to the RFC 1459 rules.
	 * This is the default function for InspIRCd::IsNick.
	 * @param nick The nickname to validate.
	 * @return True if the nickname is valid according to RFC 1459 rules; otherwise, false.
	 */
	static bool DefaultIsNick(const std::string_view& nick);

	/** Determines whether a username is valid according to the RFC 1459 rules.
	 * This is the default function for InspIRCd::IsUser.
	 * @param user The username to validate.
	 * @return True if the username is valid according to RFC 1459 rules; otherwise, false.
	*/
	static bool DefaultIsUser(const std::string_view& user);

	/** Causes the server to exit after unloading modules and closing all open file descriptors.
	 * @param status The exit code to give to the operating system.
	 */
	[[noreturn]]
	void Exit(int status);

	/** Determines whether a fully qualified hostname is valid according to RFC 5891 rules.
	 * @param host The hostname to validate.
	 * @return True if the hostname is valid; otherwise, false.
	 */
	inline static auto IsFQDN(const std::string_view& host) { return IsHost(host, false); }

	/** Determines whether a hostname is valid according to RFC 5891 rules.
	 * @param host The hostname to validate.
	 * @param allowsimple Whether to allow simple hostnames (e.g. localhost).
	 * @return True if the hostname is valid; otherwise, false.
	 */
	static bool IsHost(const std::string_view& host, bool allowsimple);

	/** Determines whether the specified string is a server identifier.
	 * @param sid The string to check.
	 * @return True if the specified string is a server identifier; otherwise, false.
	 */
	static bool IsSID(const std::string_view& sid);

	/** Determines whether the specified string is a valid nick!user\@host mask.
	 * @param mask The string to check.
	 * @return True if the specified string is a valid nick!user\@host mask; otherwise, false.
	 */
	static bool IsValidMask(const std::string& mask);

	/** Matches two strings using glob pattern matching, optionally with a case map to use instead
	 * of the server case map.
	 * @param str The literal string to match against
	 * @param pattern The glob pattern to match against.
	 * @param map The character map to use when matching.
	 * @return True if the string matches the mask; otherwise, false.
	 */
	static bool Match(const std::string& str, const std::string& pattern, const unsigned char* map = nullptr);

	/** Matches two strings using glob pattern matching, optionally with a case map to use instead
	 * of the server case map.
	 * @param str The literal string to match against
	 * @param pattern The glob pattern to match against.
	 * @param map The character map to use when matching.
	 * @return True if the string matches the pattern; otherwise, false.
	 */
	static bool Match(const char* str, const char* pattern, const unsigned char* map = nullptr);

	/** Matches two strings using glob pattern and CIDR range matching, optionally with a case map
	 * to use instead of the server case map.
	 * @param str The literal string to match against
	 * @param pattern The glob pattern to match against.
	 * @param map The character map to use when matching.
	 * @return True if the string matches the pattern; otherwise, false.
	 */
	static bool MatchCIDR(const std::string& str, const std::string& pattern, const unsigned char* map = nullptr);

	/** Matches two strings using glob pattern and CIDR range matching, optionally with a case map
	 * to use instead of the server case map.
	 * @param str The literal string to match against
	 * @param pattern The glob pattern to match against.
	 * @param map The character map to use when matching.
	 * @return True if the string matches the pattern; otherwise, false.
	 */
	static bool MatchCIDR(const char* str, const char* pattern, const unsigned char* map = nullptr);

	/** Matches a hostname and address against a space delimited list of hostmasks.
	 * @param masks The space delimited masks to match against.
	 * @param hostname The hostname to try and match.
	 * @param address The IP address or UNIX socket path to try and match.
	 * @return True if a mask matches the hostname or address; otherwise, false.
	 */
	static bool MatchMask(const std::string& masks, const std::string& hostname, const std::string& address);

	/** Reloads the server configuration.
	 * @param uuid If non-empty then the uuid of the user who started the rehash.
	 */
	void Rehash(const std::string& uuid = "");

	/** Starts the execution of the server main loop. */
	[[noreturn]]
	void Run();

	/** Replaces color escapes in the specified lines with IRC colors.
	 * @param lines A vector of lines to replace color escapes in.
	 */
	[[deprecated("Use ProcessColors(std::string) instead")]]
	static void ProcessColors(std::vector<std::string>& lines);

	/** Replaces color escapes in the specified string with IRC colors.
	 * @param lines The string replace color escapes in.
	 */
	static void ProcessColors(std::string& str);

	/** Stores an incoming signal when received from the operating system.
	 * @param signal The signal received from the operating system.
	 */
	static void SetSignal(int signal);

	/* Removes IRC colors from the specified string.
	 * @param str The string to strip colors from.
	 */
	static void StripColor(std::string& str);

	/** Retrieves the time, updated once per main loop iteration, as the number of seconds since
	 * the UNIX epoch. This is faster than calling time functions manually.
	 */
	inline auto Time() const { return ts.tv_sec; }

	/** Retrieves the time, updated once per main loop iteration, as the number of fractional
	 * seconds since the UNIX epoch. This is faster than calling time functions manually.
	 */
	inline auto Time_ns() const { return ts.tv_nsec; }

	/** Compares two strings in a timing-safe way. If the lengths of the strings differ the
	 * function returns false immediately (leaking information about the length). Otherwise, it
	 * compares each character and only returns after all characters have been compared.
	 * @param str1 The first string to compare.
	 * @param str2 The second string to compare.
	 * @return True if the strings are equivalent; otherwise, false.
	 */
	static bool TimingSafeCompare(const std::string& str1, const std::string& str2);

	/** Updates the current cached time. Don't call this unless you have reason to do so. */
	void UpdateTime();
};

inline void Cullable::Deleter::operator()(Cullable* item) const
{
	if (item)
		ServerInstance->GlobalCulls.AddItem(item);
}

inline void Channel::Write(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg, char status, const CUList& except_list) const
{
	ClientProtocol::Event event(protoevprov, msg);
	Write(event, status, except_list);
}

inline void LocalUser::Send(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg)
{
	ClientProtocol::Event event(protoevprov, msg);
	Send(event);
}