module bancho.ratelimit;

import core.time;

import vibe.core.core;
import vibe.core.sync;

/// Params:
/// 	messages = Maximum allowed messages in the given timespan
/// 	timespan = Timespan to check messages in
struct ChatRatelimiter(int maxMessages, Duration timespan)
{
	/// Delay to always apply to avoid large gaps
	Duration baseDelay = timespan / maxMessages / 2; // default to half an average cycle so if messages are going to be spammed, half of timespan is the maximum idle time
	/// Log of all sent message times in ms, because that's what bancho uses.
	long[maxMessages] times;
	/// Index where to insert in times array right now.
	int cycle;
	InterruptibleTaskMutex mutex;

	void load()
	{
		mutex = new InterruptibleTaskMutex();
		first = MonoTime.currTime();
	}

	private MonoTime first;
	private long now()
	{
		return (MonoTime.currTime() - first).total!"msecs";
	}

	void putWait(bool put)
	{
		synchronized (mutex)
		{
			auto first = times[(cycle + 1) % $];
			auto sinceLast = (now - times[(cycle + $ - 1) % $]).msecs;
			if (sinceLast > timespan)
			{
				// do nothing
			}
			else if (sinceLast > timespan - baseDelay)
			{
				// sleep remaining of baseDelay
				sleep(timespan - sinceLast);
			}
			else
			{
				sleep(baseDelay);
				auto totalTime = (now - first).msecs;
				if (totalTime < timespan)
					sleep(timespan - totalTime);
			}
			if (put)
			{
				times[cycle] = now;
				cycle = (cycle + 1) % times.length;
			}
		}
	}

	/// Returns true if a message can be sent instantly.
	bool peekInstant()
	{
		if (!mutex.tryLock())
			return false;
		mutex.unlock();
		auto sinceLast = (now - times[(cycle + $ - 1) % $]).msecs;
		return sinceLast > timespan;
	}

	/// Returns true if a message can be sent instantly or with the baseDelay.
	bool peekBase()
	{
		if (!mutex.tryLock())
			return false;
		mutex.unlock();
		auto sinceLast = (now - times[(cycle + $ - 1) % $]).msecs;
		return sinceLast - baseDelay > timespan;
	}
}

// public rooms: 60 messages / minute
// private channels: 300 messages / minute
struct BanchoRatelimiter(int publicMax = 6, Duration publicTime = 6.seconds,
		int privateMax = 5, Duration privateTime = 1.seconds)
{
	ChatRatelimiter!(publicMax, publicTime) publicLimit;
	ChatRatelimiter!(privateMax, privateTime) privateLimit;

	void load()
	{
		publicLimit.load();
		privateLimit.load();
	}

	void putWait(string channel, bool put)
	{
		isPublic(channel) ? publicLimit.putWait(put) : privateLimit.putWait(put);
	}

	bool peekInstant(string channel)
	{
		return isPublic(channel) ? publicLimit.peekInstant() : privateLimit.peekInstant();
	}

	bool peekBase(string channel)
	{
		return isPublic(channel) ? publicLimit.peekBase() : privateLimit.peekBase();
	}

}

private bool isPublic(string channel)
{
	if (channel.length && channel[0] == '#')
	{
		// channel, so public
		return true;
	}
	else
	{
		// doesn't start with #, must be a player, so private
		return false;
	}
}