package de.brxno.glazeHomes.service; import de.brxno.glazeHomes.GlazeHomes; import de.brxno.glazeHomes.model.Home; import de.brxno.glazeHomes.storage.IHomeStorage; import de.brxno.glazeHomes.util.MessageUtil; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.logging.Level; /** * Service für Home-Verwaltung (CRUD, Permissions, Validierung) */ public class HomeService { private final GlazeHomes plugin; private final IHomeStorage storage; private final HomeCacheService cache; private static final int MAX_HOMES = 7; public HomeService(GlazeHomes plugin, IHomeStorage storage) { this.plugin = plugin; this.storage = storage; this.cache = new HomeCacheService(); } /** * Gibt den Cache-Service zurück */ public HomeCacheService getCache() { return cache; } /** * Prüft, ob ein Spieler das Home-Slot-Permission hat */ public boolean hasSlotPermission(Player player, int slot) { if (slot < 1 || slot > MAX_HOMES) { return false; } if (player.hasPermission("glazehomes.admin")) { return true; } return player.hasPermission("glazehomes." + slot); } /** * Gibt alle erlaubten Slots für einen Spieler zurück */ public List getAvailableSlots(Player player) { List slots = new ArrayList<>(); if (player.hasPermission("glazehomes.admin")) { for (int i = 1; i <= MAX_HOMES; i++) { slots.add(i); } return slots; } for (int i = 1; i <= MAX_HOMES; i++) { if (player.hasPermission("glazehomes." + i)) { slots.add(i); } } return slots; } /** * Prüft, ob ein Home einen Slot gültig hat und die Welt protected ist */ public boolean canSetHome(Player player, int slot) { // Permission Check if (!hasSlotPermission(player, slot)) { return false; } // World Whitelist Check if (plugin.getConfigManager().isWorldWhitelistEnabled()) { String worldName = player.getWorld().getName(); List allowedWorlds = plugin.getConfigManager().getAllowedWorlds(); if (!allowedWorlds.contains(worldName)) { return false; } } return true; } /** * Setzt ein neues Home für einen Spieler * * ABLAUF (Instant UI + Async DB): * 1. Validation (sync) * 2. Cache-Update (sync) → Home als "gesetzt" markieren * 3. GUI-Update (sync, Main-Thread) → WHITE_BED → BLUE_BED SOFORT * 4. DB-Write (async) → Daten persistent speichern * 5. Bei Fehler: Rollback (Cache + GUI) * * @param player Spieler * @param slot Slot (1-7) * @param onGuiUpdate Callback für sofortiges GUI-Update (MUSS Main-Thread sein!) * @return CompletableFuture mit Erfolg/Fehler */ public CompletableFuture setHome(Player player, int slot, Runnable onGuiUpdate) { // 1. Validation (sync) if (!canSetHome(player, slot)) { return CompletableFuture.completedFuture(false); } UUID uuid = player.getUniqueId(); final String serverId; boolean routingEnabled = plugin.getConfigManager().getConfig().getBoolean("routing.enabled", false); if (routingEnabled) { String tempServerId = plugin.getRoutingService().getCurrentServerId(); if ("INVALID".equals(tempServerId)) { // Routing misconfigured - cannot set home if (onGuiUpdate != null) { Bukkit.getScheduler().runTask(plugin, () -> { player.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + "§cError: Routing misconfigured (server-id missing)")); }); } return CompletableFuture.completedFuture(false); } // Keep the internal server id normalized serverId = tempServerId.trim().toLowerCase(java.util.Locale.ROOT); } else { serverId = "local"; } Home home = Home.fromPlayer(player, slot, serverId); // 2. Cache-Update (sync, instant) cache.markHomeSet(uuid, slot); plugin.getLogger().info("[INSTANT] Home marked as set in cache: " + player.getName() + " slot " + slot + " (server=" + serverId + ")"); // 3. GUI-Update (sync, Main-Thread) // WICHTIG: Inventory updates MUST be on main thread! if (onGuiUpdate != null) { Bukkit.getScheduler().runTask(plugin, () -> { onGuiUpdate.run(); plugin.getLogger().info("[INSTANT] GUI updated: " + player.getName() + " slot " + slot); }); } // 4. DB-Write (async, im Hintergrund) return storage.saveHome(home).thenApply(success -> { if (success) { plugin.getLogger().info("[DB] Home saved to database: " + player.getName() + " slot " + slot + " (home_server=" + serverId + ")"); return true; } else { // 5. Rollback bei DB-Fehler plugin.getLogger().warning("[DB ERROR] Failed to save home, rolling back: " + player.getName() + " slot " + slot); // Cache zurücksetzen cache.markHomeDeleted(uuid, slot); // GUI zurücksetzen (Main-Thread) Bukkit.getScheduler().runTask(plugin, () -> { if (onGuiUpdate != null) { onGuiUpdate.run(); // GUI refresh (BLUE_BED → WHITE_BED) } // Fehlermeldung an Spieler String errorMsg = plugin.getConfigManager().getMessage("database-error"); player.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + errorMsg)); }); return false; } }); } /** * Setzt ein neues Home für einen Spieler (ohne GUI-Update Callback) * * Für Commands wie /sethome, wo kein GUI offen ist. * * @param player Spieler * @param slot Slot (1-7) * @return CompletableFuture mit Erfolg/Fehler */ public CompletableFuture setHome(Player player, int slot) { return setHome(player, slot, null); } /** * Teleportiert einen Spieler zu einem Home (mit oder ohne Warmup) * Supports cross-server teleportation via routing */ public CompletableFuture teleportToHome(Player player, int slot, boolean bypassWarmup) { return storage.loadHome(player.getUniqueId(), slot).thenApplyAsync(home -> { if (home == null) { return false; } String targetServer = home.getHomeServer(); if (targetServer == null || targetServer.isEmpty()) { // Use RoutingService fallback for legacy rows targetServer = plugin.getRoutingService().getTargetServer(home.getWorldName()); } else { // Normalize internal server id for comparison targetServer = targetServer.trim().toLowerCase(java.util.Locale.ROOT); } boolean routingEnabled = plugin.getConfigManager().getConfig().getBoolean("routing.enabled", false); final String currentServerId; if (routingEnabled) { currentServerId = plugin.getRoutingService().getCurrentServerId(); if ("INVALID".equals(currentServerId)) { player.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + "§cError: Routing misconfigured (server-id missing)")); return false; } plugin.getLogger().info("[TP] TP request actor=" + player.getName() + " slot=" + slot + " current=" + currentServerId + " target=" + targetServer + " world=" + home.getWorldName()); if (!targetServer.equals(currentServerId)) { final String finalTargetServer = targetServer; plugin.getLogger().info("[TP] CONNECT actor=" + player.getName() + " from=" + currentServerId + " to=" + targetServer); Bukkit.getScheduler().runTask(plugin, () -> { plugin.getCrossServerTeleportService().initiateCrossServerTeleport(player, home, finalTargetServer); }); return true; } } else { currentServerId = null; } // Same-server teleport org.bukkit.World world = Bukkit.getWorld(home.getWorldName()); if (world == null) { player.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + MessageUtil.parse(plugin.getConfigManager().getMessage("world-not-loaded")))); return false; } if (bypassWarmup) { // Direkter Teleport org.bukkit.Location location = home.toLocation(world); player.teleportAsync(location); return true; } else { // Mit Warmup TeleportService.startTeleportWarmup(plugin, player, home); return true; } }, Bukkit.getScheduler().getMainThreadExecutor(plugin)); } /** * Teleportiert einen Admin zu einem Home eines anderen Spielers (mit Cross-Server Support) * * @param actor The admin player who will be teleported * @param ownerUuid The UUID of the player who owns the home * @param slot The home slot * @param bypassWarmup Whether to bypass warmup */ public CompletableFuture teleportToHomeAsAdmin(Player actor, UUID ownerUuid, int slot, boolean bypassWarmup) { return storage.loadHome(ownerUuid, slot).thenApplyAsync(home -> { if (home == null) { return false; } String targetServer = home.getHomeServer(); if (targetServer == null || targetServer.isEmpty()) { // Use RoutingService fallback for legacy rows targetServer = plugin.getRoutingService().getTargetServer(home.getWorldName()); } else { targetServer = targetServer.trim().toLowerCase(java.util.Locale.ROOT); } boolean routingEnabled = plugin.getConfigManager().getConfig().getBoolean("routing.enabled", false); final String currentServerId; if (routingEnabled) { currentServerId = plugin.getRoutingService().getCurrentServerId(); if ("INVALID".equals(currentServerId)) { actor.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + "§cError: Routing misconfigured (server-id missing)")); return false; } plugin.getLogger().info("[TP-ADMIN] TP request actor=" + actor.getName() + " owner=" + ownerUuid + " slot=" + slot + " current=" + currentServerId + " target=" + targetServer + " world=" + home.getWorldName()); if (!targetServer.equals(currentServerId)) { final String finalTargetServer = targetServer; plugin.getLogger().info("[TP-ADMIN] CONNECT actor=" + actor.getName() + " from=" + currentServerId + " to=" + targetServer); Bukkit.getScheduler().runTask(plugin, () -> { plugin.getCrossServerTeleportService().initiateCrossServerTeleport(actor, home, finalTargetServer); }); return true; } } else { currentServerId = null; } // Same-server teleport org.bukkit.World world = Bukkit.getWorld(home.getWorldName()); if (world == null) { actor.sendMessage(MessageUtil.parse(plugin.getConfigManager().getPrefix() + MessageUtil.parse(plugin.getConfigManager().getMessage("world-not-loaded")))); return false; } if (bypassWarmup) { // Direkter Teleport org.bukkit.Location location = home.toLocation(world); actor.teleportAsync(location); return true; } else { // Mit Warmup TeleportService.startTeleportWarmup(plugin, actor, home); return true; } }, Bukkit.getScheduler().getMainThreadExecutor(plugin)); } /** * Löscht ein Home * * ABLAUF: * 1. Cache-Update (sync) → Home als "gelöscht" markieren * 2. DB-Delete (async) * 3. Bei Fehler: Rollback im Cache * * @param player Spieler * @param slot Slot (1-7) * @return CompletableFuture mit Erfolg/Fehler */ public CompletableFuture deleteHome(Player player, int slot) { UUID uuid = player.getUniqueId(); // Cache-Update (sofort) cache.markHomeDeleted(uuid, slot); // DB-Delete (async) return storage.deleteHome(uuid, slot).thenApply(success -> { if (success) { plugin.getLogger().info("Home deleted for " + player.getName() + " at slot " + slot); return true; } else { // Rollback bei Fehler plugin.getLogger().warning("Failed to delete home from DB, rolling back cache: " + player.getName() + " slot " + slot); cache.markHomeSet(uuid, slot); return false; } }); } /** * Lädt alle Homes eines Spielers (async) */ public CompletableFuture> loadHomes(Player player) { return storage.loadHomes(player.getUniqueId()); } /** * Lädt alle Homes und refreshed den Cache (für GUI-Open) * * WICHTIG: Immer beim GUI-Open aufrufen! * - Lädt aktuelle Daten aus DB * - Refreshed Cache mit DB-Daten (DB ist "source of truth") * - Gibt Homes zurück für GUI-Building * * @param playerUuid Spieler UUID * @return CompletableFuture mit Home-Liste */ public CompletableFuture> loadHomesAndRefreshCache(UUID playerUuid) { return storage.loadHomes(playerUuid).thenApply(homes -> { // Cache refreshen mit aktuellen DB-Daten Set existingSlots = new HashSet<>(); for (Home home : homes) { existingSlots.add(home.getSlot()); } cache.refreshCache(playerUuid, existingSlots); plugin.getLogger().info("[CACHE] Refreshed cache for player: " + playerUuid + " (" + existingSlots.size() + " homes)"); return homes; }); } /** * Lädt alle Homes anhand der UUID (für Admin/Offline-Spieler) */ public CompletableFuture> loadHomesByUUID(UUID playerUUID) { return storage.loadHomes(playerUUID); } /** * Löscht ein Home admin-seitig (für andere Spieler) */ public CompletableFuture adminDeleteHome(UUID targetUUID, int slot) { return storage.deleteHome(targetUUID, slot); } /** * Teleportiert einen Admin zu einem Home eines anderen Spielers */ public CompletableFuture adminTeleportToHome(Player admin, UUID targetUUID, int slot) { // Admin teleport should obey home_server; bypass warmup for admin convenience return teleportToHomeAsAdmin(admin, targetUUID, slot, true); } }