add rate limiting functionality with user feedback to CommandExecutor

Author: Helltar

src/main/kotlin/com/helltar/signai/Strings.kt

@@ -5,4 +5,5 @@ object Strings {
     const val CONTEXT_HAS_BEEN_REMOVED = "Context has been removed \uD83D\uDC4C"
     const val MANY_REQUEST = "Please wait, I am processing your previous request \uD83E\uDD16"
     const val CHAT_CONTEXT_EMPTY = "▫\uFE0F Empty"
+    const val SLOWMODE = "Request limit reached. Try again in %d sec \uD83D\uDE0A"
 }

src/main/kotlin/com/helltar/signai/bot/CommandExecutor.kt

@@ -6,31 +6,60 @@ import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import kotlin.math.ceil
 
 class CommandExecutor(private val scope: CoroutineScope) {
 
     private val requestsMap = hashMapOf<String, Job>()
+    private val requestTimestamps = hashMapOf<String, MutableList<Long>>()
 
     private companion object {
+        const val LIMIT_COUNT = 5
+        const val LIMIT_WINDOW = 3600_000L
         val log = KotlinLogging.logger {}
     }
 
+    private sealed interface LaunchResult {
+        data object Success : LaunchResult
+        data object Busy : LaunchResult
+        data class RateLimited(val waitSeconds: Long) : LaunchResult
+    }
+
     fun execute(botCommand: BotCommand) {
         val key = botCommand.envelope.source
 
-        if (!launch(key) { botCommand.run() })
-            scope.launch { botCommand.replyToMessage(Strings.MANY_REQUEST) }
+        when (val result = tryLaunch(key) { botCommand.run() }) {
+            is LaunchResult.Success -> {}
+            is LaunchResult.Busy -> scope.launch { botCommand.replyToMessage(Strings.MANY_REQUEST) }
+            is LaunchResult.RateLimited -> scope.launch { botCommand.replyToMessage(Strings.SLOWMODE.format(result.waitSeconds)) }
+        }
     }
 
-    private fun launch(key: String, block: suspend () -> Unit): Boolean {
-        if (requestsMap.containsKey(key))
-            if (requestsMap[key]?.isCompleted == false)
-                return false
+    private fun tryLaunch(key: String, block: suspend () -> Unit): LaunchResult {
+        if (requestsMap[key]?.isActive == true)
+            return LaunchResult.Busy
+
+        val timestamps = requestTimestamps.getOrPut(key) { mutableListOf() }
+        val currentTime = System.currentTimeMillis()
+        val windowStart = currentTime - LIMIT_WINDOW
+
+        timestamps.removeAll { it < windowStart }
+
+        if (timestamps.size >= LIMIT_COUNT) {
+            val oldestRequestTime = timestamps.first()
+            val unblockTime = oldestRequestTime + LIMIT_WINDOW
+            val waitMs = unblockTime - currentTime
+            val waitSeconds = if (waitMs > 0) ceil(waitMs / 1000.0).toLong() else 1L
+            log.debug { "rate limit for $key. wait: ${waitSeconds}s" }
+            return LaunchResult.RateLimited(waitSeconds)
+        }
+
+        timestamps.add(currentTime)
 
-        log.debug { "launch --> $key" }
+        log.debug { "launch --> $key (requests: ${timestamps.size} / $LIMIT_COUNT)" }
 
         requestsMap[key] = scope.launch { block() }
 
-        return true
+        return LaunchResult.Success
     }
 }