package com.donutsmp.donutcore.ai import com.donutsmp.donutcore.DonutCore import com.donutsmp.donutcore.util.SchedulerUtil import com.google.gson.JsonArray import com.google.gson.JsonObject import com.google.gson.JsonParser import org.bukkit.entity.Player import java.net.URI import java.net.http.HttpClient import java.net.http.HttpRequest import java.net.http.HttpResponse import java.time.Duration import java.util.* import java.util.concurrent.ConcurrentHashMap class ChatbotManager(private val plugin: DonutCore) { private val client: HttpClient = HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(10)) .build() private val conversationHistory = ConcurrentHashMap>() private val cooldowns = ConcurrentHashMap() private val rateLimits = ConcurrentHashMap() private val apiKey: String private val model: String private val maxTokens: Int private val temperature: Double private val contextMemory: Int private val systemPrompt: String private val cooldownSeconds: Int private val messagesPerMinute: Int private val messagesPerHour: Int private val responsePrefix: String private val errorColor: String init { val config = plugin.config.getConfigurationSection("chatbot")!! apiKey = config.getString("gemini-api-key", "")!! model = config.getString("model", "gemini-pro")!! maxTokens = config.getInt("max-tokens", 500) temperature = config.getDouble("temperature", 0.9) contextMemory = config.getInt("context-memory", 10) systemPrompt = config.getString("system-prompt", "You are a helpful AI assistant.")!! cooldownSeconds = config.getInt("cooldown-seconds", 5) messagesPerMinute = config.getInt("rate-limit.messages-per-minute", 10) messagesPerHour = config.getInt("rate-limit.messages-per-hour", 50) responsePrefix = config.getString("response-format.prefix", "&b[AI] &7")!!.replace("&", "§") errorColor = config.getString("response-format.error-color", "&c")!!.replace("&", "§") } fun sendMessage(player: Player, message: String) { if (!plugin.config.getBoolean("modules.chatbot", true)) { player.sendMessage("${errorColor}AI Chatbot is currently disabled!") return } if (apiKey.isEmpty() || apiKey == "YOUR_GEMINI_API_KEY_HERE") { player.sendMessage("${errorColor}AI Chatbot is not configured! Please set the API key.") return } if (!checkCooldown(player)) { player.sendMessage("${errorColor}Please wait ${getCooldownRemaining(player)}s before sending another message!") return } if (!checkRateLimit(player)) { player.sendMessage("${errorColor}You've sent too many messages! Please wait a moment.") return } setCooldown(player) incrementRateLimit(player) SchedulerUtil.runTaskAsynchronously(plugin) { try { val response = queryGemini(player.uniqueId, message) SchedulerUtil.runTask(plugin) { player.sendMessage("$responsePrefix$response") } } catch (e: Exception) { SchedulerUtil.runTask(plugin) { player.sendMessage("${errorColor}Failed to get AI response.") } } } } private fun queryGemini(uuid: UUID, message: String): String { val history = conversationHistory.getOrPut(uuid) { mutableListOf() } history.add(Message("user", message)) if (history.size > contextMemory * 2) { history.subList(0, history.size - contextMemory * 2).clear() } val request = HttpRequest.newBuilder() .uri(URI.create("https://generativelanguage.googleapis.com/v1beta/models/$model:generateContent?key=$apiKey")) .timeout(Duration.ofSeconds(30)) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(buildRequestBody(history))) .build() val response = client.send(request, HttpResponse.BodyHandlers.ofString()) if (response.statusCode() != 200) { throw Exception("API error ${response.statusCode()}") } val json = JsonParser.parseString(response.body()).asJsonObject val aiResponse = extractResponse(json) history.add(Message("model", aiResponse)) return aiResponse } private fun buildRequestBody(history: List): String { val json = JsonObject() val contents = JsonArray() val systemMsg = JsonObject() systemMsg.addProperty("role", "user") val systemParts = JsonArray() val systemPart = JsonObject() systemPart.addProperty("text", systemPrompt) systemParts.add(systemPart) systemMsg.add("parts", systemParts) contents.add(systemMsg) history.forEach { val msg = JsonObject() msg.addProperty("role", it.role) val parts = JsonArray() val part = JsonObject() part.addProperty("text", it.content) parts.add(part) msg.add("parts", parts) contents.add(msg) } json.add("contents", contents) val generationConfig = JsonObject() generationConfig.addProperty("temperature", temperature) generationConfig.addProperty("maxOutputTokens", maxTokens) json.add("generationConfig", generationConfig) return json.toString() } private fun extractResponse(json: JsonObject): String { return json.getAsJsonArray("candidates") .get(0).asJsonObject .getAsJsonObject("content") .getAsJsonArray("parts") .get(0).asJsonObject .get("text").asString } private fun checkCooldown(player: Player): Boolean { if (player.hasPermission("donutcore.bypass.cooldown")) return true val last = cooldowns[player.uniqueId] ?: return true return (System.currentTimeMillis() - last) / 1000 >= cooldownSeconds } private fun getCooldownRemaining(player: Player): Long { val last = cooldowns[player.uniqueId] ?: return 0 val elapsed = (System.currentTimeMillis() - last) / 1000 return maxOf(0, cooldownSeconds - elapsed) } private fun setCooldown(player: Player) { cooldowns[player.uniqueId] = System.currentTimeMillis() } private fun checkRateLimit(player: Player): Boolean { if (player.hasPermission("donutcore.bypass.cooldown")) return true val data = rateLimits.getOrPut(player.uniqueId) { RateLimitData() } val now = System.currentTimeMillis() data.cleanOldEntries(now) return data.timestamps.count { now - it < 60000 } < messagesPerMinute && data.timestamps.count { now - it < 3600000 } < messagesPerHour } private fun incrementRateLimit(player: Player) { rateLimits.getOrPut(player.uniqueId) { RateLimitData() } .timestamps.add(System.currentTimeMillis()) } fun clearHistory(uuid: UUID) { conversationHistory.remove(uuid) } data class Message(val role: String, val content: String) class RateLimitData { val timestamps = mutableListOf() fun cleanOldEntries(now: Long) { timestamps.removeIf { now - it > 3600000 } } } }