package com.godlp.database; import com.godlp.GodLP; import com.godlp.models.ContextKey; import com.godlp.models.GodGroup; import com.godlp.models.GodPermission; import com.godlp.models.GodUser; import com.godlp.utils.JsonUtil; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.sql.*; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.logging.Level; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; import java.util.zip.ZipOutputStream; /** * Abstract base class for database implementations. */ public abstract class DatabaseManager { protected final GodLP plugin; /** * Creates a new DatabaseManager. * * @param plugin The plugin instance */ public DatabaseManager(GodLP plugin) { this.plugin = plugin; } /** * Initializes the database connection and creates tables. */ public abstract void initialize(); /** * Shuts down the database connection. */ public abstract void shutdown(); /** * Executes a database operation asynchronously. * * @param operation The operation to execute * @param The return type * @return A CompletableFuture with the result */ protected abstract CompletableFuture executeAsync(DatabaseOperation operation); /** * Functional interface for database operations. * * @param The return type */ @FunctionalInterface public interface DatabaseOperation { T execute(Connection connection) throws SQLException; } // === User Operations === /** * Loads a user from the database. * * @param uuid The player's UUID * @return The GodUser, or null if not found */ public CompletableFuture loadUser(UUID uuid) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "SELECT * FROM godlp_players WHERE uuid = ?")) { stmt.setString(1, uuid.toString()); try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return this.mapUser(rs); } } } return null; }); } /** * Loads a user by username. * * @param username The username * @return The GodUser, or null if not found */ public CompletableFuture loadUserByName(String username) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "SELECT * FROM godlp_players WHERE LOWER(username) = LOWER(?)")) { stmt.setString(1, username); try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return this.mapUser(rs); } } } return null; }); } /** * Saves a user to the database. * * @param user The user to save * @return A CompletableFuture for completion */ public CompletableFuture saveUser(GodUser user) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "INSERT OR REPLACE INTO godlp_players " + "(uuid, username, primary_group, prefix, suffix, permissions, meta, updated_at) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?)")) { stmt.setString(1, user.getUuid().toString()); stmt.setString(2, user.getUsername()); stmt.setString(3, user.getPrimaryGroup()); stmt.setString(4, user.getPrefix()); stmt.setString(5, user.getSuffix()); stmt.setString(6, JsonUtil.serializePermissions(user.getPermissions())); stmt.setString(7, JsonUtil.serializeMap(user.getMeta())); stmt.setLong(8, System.currentTimeMillis()); stmt.executeUpdate(); } // Save group assignments this.saveUserGroups(connection, user); user.setDirty(false); return null; }); } /** * Saves user group assignments. */ private void saveUserGroups(Connection connection, GodUser user) throws SQLException { // Remove old assignments try (PreparedStatement stmt = connection.prepareStatement( "DELETE FROM godlp_player_groups WHERE uuid = ?")) { stmt.setString(1, user.getUuid().toString()); stmt.executeUpdate(); } // Insert current assignments try (PreparedStatement stmt = connection.prepareStatement( "INSERT INTO godlp_player_groups (uuid, group_name, expires_at) VALUES (?, ?, ?)")) { for (Map.Entry entry : user.getGroupAssignments().entrySet()) { stmt.setString(1, user.getUuid().toString()); stmt.setString(2, entry.getKey()); stmt.setLong(3, entry.getValue()); stmt.addBatch(); } stmt.executeBatch(); } } /** * Loads group assignments for a user. */ protected void loadUserGroups(Connection connection, GodUser user) throws SQLException { try (PreparedStatement stmt = connection.prepareStatement( "SELECT group_name, expires_at FROM godlp_player_groups WHERE uuid = ?")) { stmt.setString(1, user.getUuid().toString()); try (ResultSet rs = stmt.executeQuery()) { while (rs.next()) { user.addGroup(rs.getString("group_name"), rs.getLong("expires_at")); } } } } /** * Maps a ResultSet row to a GodUser object. */ private GodUser mapUser(ResultSet rs) throws SQLException { GodUser user = new GodUser( UUID.fromString(rs.getString("uuid")), rs.getString("username") ); user.setPrimaryGroup(rs.getString("primary_group")); user.setPrefix(rs.getString("prefix")); user.setSuffix(rs.getString("suffix")); // Load permissions String permJson = rs.getString("permissions"); if (permJson != null && !permJson.isEmpty()) { for (GodPermission perm : JsonUtil.deserializePermissions(permJson)) { user.addPermission(perm); } } // Load meta String metaJson = rs.getString("meta"); if (metaJson != null && !metaJson.isEmpty()) { Map meta = JsonUtil.deserializeMap(metaJson); meta.forEach(user::setMeta); } // Load group assignments this.loadUserGroups(rs.getStatement().getConnection(), user); user.setDirty(false); return user; } // === Group Operations === /** * Loads all groups from the database. * * @return The set of all groups */ public CompletableFuture> loadAllGroups() { return this.executeAsync(connection -> { Set groups = new HashSet<>(); try (Statement stmt = connection.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM godlp_groups")) { while (rs.next()) { groups.add(this.mapGroup(rs)); } } return groups; }); } /** * Saves a group to the database. * * @param group The group to save * @return A CompletableFuture for completion */ public CompletableFuture saveGroup(GodGroup group) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "INSERT OR REPLACE INTO godlp_groups " + "(name, display_name, prefix, suffix, weight, is_default, permissions, parents, meta, updated_at) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")) { stmt.setString(1, group.getName()); stmt.setString(2, group.getDisplayName()); stmt.setString(3, group.getPrefix()); stmt.setString(4, group.getSuffix()); stmt.setInt(5, group.getWeight()); stmt.setBoolean(6, group.isDefault()); stmt.setString(7, JsonUtil.serializePermissions(group.getPermissions())); stmt.setString(8, JsonUtil.serializeList(new ArrayList<>(group.getParents()))); stmt.setString(9, JsonUtil.serializeMap(group.getMeta())); stmt.setLong(10, System.currentTimeMillis()); stmt.executeUpdate(); } group.setDirty(false); return null; }); } /** * Deletes a group from the database. * * @param groupName The group name * @return A CompletableFuture for completion */ public CompletableFuture deleteGroup(String groupName) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "DELETE FROM godlp_groups WHERE name = ?")) { stmt.setString(1, groupName); stmt.executeUpdate(); } return null; }); } /** * Loads all users from the database. * * @return The set of all users */ public CompletableFuture> loadAllUsers() { return this.executeAsync(connection -> { Set users = new HashSet<>(); try (Statement stmt = connection.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM godlp_players")) { while (rs.next()) { users.add(this.mapUser(rs)); } } return users; }); } /** * Maps a ResultSet row to a GodGroup object. */ private GodGroup mapGroup(ResultSet rs) throws SQLException { GodGroup group = new GodGroup(rs.getString("name")); group.setDisplayName(rs.getString("display_name")); group.setPrefix(rs.getString("prefix")); group.setSuffix(rs.getString("suffix")); group.setWeight(rs.getInt("weight")); group.setDefault(rs.getBoolean("is_default")); // Load permissions String permJson = rs.getString("permissions"); if (permJson != null && !permJson.isEmpty()) { for (GodPermission perm : JsonUtil.deserializePermissions(permJson)) { group.addPermission(perm); } } // Load parents String parentsJson = rs.getString("parents"); if (parentsJson != null && !parentsJson.isEmpty()) { for (String parent : JsonUtil.deserializeList(parentsJson)) { group.addParent(parent); } } // Load meta String metaJson = rs.getString("meta"); if (metaJson != null && !metaJson.isEmpty()) { Map meta = JsonUtil.deserializeMap(metaJson); meta.forEach(group::setMeta); } group.setDirty(false); return group; } // === Log Operations === /** * Logs an action to the database. * * @param action The action type * @param actor The actor UUID (can be null) * @param target The target UUID (can be null) * @param details The details string * @return A CompletableFuture for completion */ public CompletableFuture log(String action, String actor, String target, String details) { return this.executeAsync(connection -> { try (PreparedStatement stmt = connection.prepareStatement( "INSERT INTO godlp_logs (timestamp, action, actor, target, details) VALUES (?, ?, ?, ?, ?)")) { stmt.setLong(1, System.currentTimeMillis()); stmt.setString(2, action); stmt.setString(3, actor); stmt.setString(4, target); stmt.setString(5, details); stmt.executeUpdate(); } return null; }); } // === Backup Operations === /** * Creates a backup of the database. * * @return A CompletableFuture with the backup file path */ public CompletableFuture createBackup() { return CompletableFuture.supplyAsync(() -> { try { File dataFolder = this.plugin.getDataFolder(); File backupDir = new File(dataFolder, this.plugin.getConfigManager().getBackupDirectory()); if (!backupDir.exists()) { backupDir.mkdirs(); } String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss")); File backupFile = new File(backupDir, "backup_" + timestamp + ".zip"); // Clean old backups this.cleanOldBackups(backupDir); try (FileOutputStream fos = new FileOutputStream(backupFile); ZipOutputStream zos = new ZipOutputStream(fos)) { File dbFile; String storageType = this.plugin.getConfigManager().getStorageType(); if ("MYSQL".equalsIgnoreCase(storageType)) { // For MySQL, export tables as SQL dump this.addSqlDumpToZip(zos); } else { // For SQLite, just add the database file String filePath = this.plugin.getConfigManager().getSQLiteFile(); dbFile = new File(this.plugin.getDataFolder(), filePath); if (dbFile.exists()) { this.addFileToZip(zos, dbFile, dbFile.getName()); } } } this.plugin.getLogger().log(Level.INFO, "Backup created: " + backupFile.getAbsolutePath()); return backupFile.getAbsolutePath(); } catch (Exception e) { this.plugin.getLogger().log(Level.SEVERE, "Failed to create backup.", e); return null; } }); } /** * Restores a backup. * * @param backupName The backup file name * @return A CompletableFuture with success status */ public CompletableFuture restoreBackup(String backupName) { return CompletableFuture.supplyAsync(() -> { try { File backupDir = new File(this.plugin.getDataFolder(), this.plugin.getConfigManager().getBackupDirectory()); File backupFile = new File(backupDir, backupName); if (!backupFile.exists()) { return false; } try (FileInputStream fis = new FileInputStream(backupFile); ZipInputStream zis = new ZipInputStream(fis)) { ZipEntry entry; while ((entry = zis.getNextEntry()) != null) { if (!entry.isDirectory()) { File targetFile; if (entry.getName().equals("godlp_backup.sql")) { // SQL dump restore for both types — run the statements targetFile = null; String sql = new String(zis.readAllBytes()); this.executeSqlDump(sql); } else { // Regular file restore (SQLite .db file) targetFile = new File(this.plugin.getDataFolder(), entry.getName()); targetFile.getParentFile().mkdirs(); try (FileOutputStream out = new FileOutputStream(targetFile)) { zis.transferTo(out); } } } zis.closeEntry(); } } this.plugin.getLogger().log(Level.INFO, "Backup restored: " + backupFile.getAbsolutePath()); return true; } catch (Exception e) { this.plugin.getLogger().log(Level.SEVERE, "Failed to restore backup.", e); return false; } }); } private void addFileToZip(ZipOutputStream zos, File file, String entryName) throws IOException { ZipEntry zipEntry = new ZipEntry(entryName); zos.putNextEntry(zipEntry); try (FileInputStream fis = new FileInputStream(file)) { fis.transferTo(zos); } zos.closeEntry(); } private void addSqlDumpToZip(ZipOutputStream zos) throws IOException, SQLException { ZipEntry zipEntry = new ZipEntry("godlp_backup.sql"); zos.putNextEntry(zipEntry); // Export all tables as INSERT statements this.exportTablesAsSql(zos); zos.closeEntry(); } private void exportTablesAsSql(ZipOutputStream zos) throws IOException, SQLException { this.executeAsync(connection -> { try { for (String table : new String[]{"godlp_players", "godlp_groups", "godlp_player_groups", "godlp_logs"}) { try (Statement stmt = connection.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM " + table)) { ResultSetMetaData meta = rs.getMetaData(); int columns = meta.getColumnCount(); while (rs.next()) { StringBuilder sb = new StringBuilder("INSERT INTO ").append(table).append(" VALUES ("); for (int i = 1; i <= columns; i++) { if (i > 1) sb.append(", "); Object val = rs.getObject(i); if (val == null) { sb.append("NULL"); } else { sb.append("'").append(val.toString().replace("'", "''")).append("'"); } } sb.append(");\n"); zos.write(sb.toString().getBytes()); } } } } catch (IOException e) { throw new RuntimeException("Failed to write SQL dump", e); } return null; }).join(); // Must be synchronous inside async backup } private void executeSqlDump(String sql) throws SQLException { this.executeAsync(connection -> { try (Statement stmt = connection.createStatement()) { for (String statement : sql.split(";\\s*")) { String trimmed = statement.trim(); if (!trimmed.isEmpty()) { stmt.executeUpdate(trimmed); } } } return null; }).join(); } /** * Removes old backups exceeding the configured limit. * * @param backupDir The backup directory */ private void cleanOldBackups(File backupDir) { int maxBackups = this.plugin.getConfigManager().getMaxBackups(); File[] backups = backupDir.listFiles((dir, name) -> name.startsWith("backup_") && name.endsWith(".zip")); if (backups != null && backups.length > maxBackups) { Arrays.sort(backups, Comparator.comparingLong(File::lastModified)); for (int i = 0; i < backups.length - maxBackups; i++) { backups[i].delete(); } } } }