.gitignore

@@ -1,4 +1,25 @@
-.direnv
+# ---> Gradle
-.kotlin
 .gradle
-build
+**/build/
+!src/**/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
+.project
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+.direnv
+bin

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "kommand-lib"]
-	path = kommand-lib
-	url = git@gitea.hareworks.net:Hare/kommand-lib.git
-	branch=master

build.gradle.kts

@@ -1,13 +1,14 @@
-import net.minecrell.pluginyml.paper.PaperPluginDescription
+import net.minecrell.pluginyml.bukkit.BukkitPluginDescription
 
 group = "net.hareworks"
-version = "1.2"
+version = "1.1"
 
+val exposedVersion = "0.54.0"
 
 plugins {
-    kotlin("jvm") version "2.2.21"
+    kotlin("jvm") version "2.0.20"
-    kotlin("plugin.serialization") version "2.2.21"
+    kotlin("plugin.serialization") version "2.0.20"
-    id("de.eldoria.plugin-yml.paper") version "0.8.0"
+    id("net.minecrell.plugin-yml.bukkit") version "0.6.0"
     id("com.gradleup.shadow") version "9.2.2"
 }
 repositories {
@@ -15,12 +16,8 @@ repositories {
     maven("https://repo.papermc.io/repository/maven-public/")
     maven("https://repo.codemc.io/repository/maven-public/")
 }
-
-val exposedVersion = "0.54.0"
 dependencies {
     compileOnly("io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT")
-    implementation("org.jetbrains.kotlin:kotlin-stdlib")
-    implementation("net.hareworks:kommand-lib:1.1")
     implementation("net.kyori:adventure-api:4.17.0")
     implementation("net.kyori:adventure-text-minimessage:4.17.0")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
@@ -31,31 +28,78 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
     implementation("org.jetbrains.exposed:exposed-kotlin-datetime:$exposedVersion")
     implementation("de.tr7zw:item-nbt-api:2.15.3")
+    implementation("com.michael-bull.kotlin-result:kotlin-result:2.0.0")
 }
 tasks {
-    withType<Jar> {
-        archiveBaseName.set("SimplyMCDB")
-    }
     shadowJar {
-        minimize {
+        archiveBaseName.set("SimplyMCDB")
-            exclude(dependency("org.jetbrains.exposed:exposed-core"))
+        archiveClassifier.set("")
-            exclude(dependency("org.jetbrains.exposed:exposed-dao"))
-            exclude(dependency("org.jetbrains.exposed:exposed-jdbc"))
-            exclude(dependency("org.jetbrains.exposed:exposed-kotlin-datetime"))
-            exclude(dependency("org.postgresql:postgresql"))
-        }
-        archiveClassifier.set("min")
         relocate("de.tr7zw.changeme.nbtapi", "net.hareworks.simplymcdb.libs.nbtapi")
     }
+
+    build {
+        dependsOn(shadowJar)
+    }
 }
 
-paper {
+bukkit {
     main = "net.hareworks.simplymcdb.App"
     name = "Simply-Minecraft-DB"
     description = "It provides a simple way to manage player data through a database."
     version = getVersion().toString()
-	apiVersion = "1.21.10"
+		apiVersion = "1.21.10"
-    authors = listOf(
+    authors =
-        "Hare-K02"
+            listOf("Hare-K02")
-    )
+    permissions {
+        register("simplydb.*") {
+            children = listOf("simplydb.command", "simplydb.admin")
+        }
+        register("simplydb.command") {
+            description = "Allows access to the /simplydb command"
+            default = BukkitPluginDescription.Permission.Default.TRUE
+        }
+        register("simplydb.command.*") {
+            children = listOf(
+                "simplydb.command.config",
+                "simplydb.command.config.*",
+                "simplydb.command.on",
+                "simplydb.command.off",
+            )
+        }
+        register("simplydb.command.config") {
+            description = "Allows access to the /simplydb config command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.command.config.*") {
+            children = listOf(
+                "simplydb.command.config.reload",
+                "simplydb.command.config.fetch",
+                "simplydb.command.config.upload",
+            )
+        }
+        register("simplydb.command.config.reload") {
+            description = "Allows access to the /simplydb config reload command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.command.config.fetch") {
+            description = "Allows access to the /simplydb config fetch command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.command.config.upload") {
+            description = "Allows access to the /simplydb config upload command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.command.on") {
+            description = "Allows access to the /simplydb on command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.command.off") {
+            description = "Allows access to the /simplydb off command"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+        register("simplydb.admin") {
+            description = "Allows configration/manage simplydb"
+            default = BukkitPluginDescription.Permission.Default.OP
+        }
+		}
 }

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1764173365,
+        "lastModified": 1764020296,
-        "narHash": "sha256-JaNFPy3nywPNxSDpEgFFqvngQww5Igb6twG4NhMo8oc=",
+        "narHash": "sha256-6zddwDs2n+n01l+1TG6PlyokDdXzu/oBmEejcH5L5+A=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "2fecba9952096ba043c16b9ef40b92851ff3e5d9",
+        "rev": "a320ce8e6e2cc6b4397eef214d202a50a4583829",
         "type": "github"
       },
       "original": {

flake.nix

@@ -36,6 +36,10 @@
             export PATH="$JAVA_HOME/bin:$PATH"
 
             export GRADLE_USER_HOME="$PWD/.gradle"
+
+            echo "Loaded Minecraft dev env (JDK 21 + Gradle)"
+            java -version || true
+            gradle --version || true
           '';
         };
       }

gradle.properties

@@ -1,5 +0,0 @@
-org.gradle.configuration-cache=true
-org.gradle.parallel=true
-org.gradle.caching=true
-
-kotlin.stdlib.default.dependency=false

gradle/gradle-daemon-jvm.properties

@@ -0,0 +1,2 @@
+#This file is generated by updateDaemonJvm
+toolchainVersion=21

gradle/libs.versions.toml

@@ -1,2 +0,0 @@
-# This file was generated by the Gradle 'init' task.
-# https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -86,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -114,7 +115,7 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH="\\\"\\\""
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -205,7 +206,7 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
@@ -213,7 +214,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
         -classpath "$CLASSPATH" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -70,11 +70,11 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle.kts

@@ -1,3 +0,0 @@
-rootProject.name = "simply-mcdb"
-
-includeBuild("kommand-lib")

src/main/kotlin/net/hareworks/kommandlib/main.kt

@@ -0,0 +1,147 @@
+package net.hareworks.kommandlib
+
+import com.github.michaelbull.result.*
+import kotlin.collections.listOf
+import org.bukkit.Bukkit
+import org.bukkit.command.CommandMap
+import org.bukkit.command.CommandSender
+import org.bukkit.command.PluginCommand
+import org.bukkit.command.TabCompleter
+import org.bukkit.plugin.java.JavaPlugin
+import net.hareworks.simplymcdb.App
+
+class KommandLib(plugin: JavaPlugin, vararg routes: Argument) {
+  val entries = routes.toList()
+  init {
+    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
+    f.isAccessible = true
+    val commandMap = f.get(Bukkit.getServer()) as CommandMap
+    for (route in routes) {
+      commandMap.register(
+              plugin.getName(),
+              (PluginCommand::class
+                              .java
+                              .declaredConstructors
+                              .first()
+                              .apply { isAccessible = true }
+                              .newInstance(route.name, plugin) as
+                              PluginCommand)
+                      .apply {
+                        this.name = name
+                        this.setExecutor { sender, _, alias, args ->
+                          val routeargs = routeTreeSearch(arrayOf(alias, *args))
+                          if (routeargs.size == args.size + 1)
+                                  routeargs.last().onCommand(sender, args)
+                          true
+                        }
+                        this.tabCompleter = TabCompleter { sender, _, alias, args ->
+                          val routeargs = routeTreeSearch(arrayOf(alias, *args))
+                          if (routeargs.size == args.size)
+                                  routeargs.last().getCompletList(sender, args)
+                          else listOf()
+                        }
+                      }
+      )
+    }
+  }
+
+  fun routeTreeSearch(args: Array<String>): List<Argument> {
+    val list =
+            mutableListOf<Argument>(
+                    entries.find { it.name == args[0] } ?: throw Exception("Invalid command")
+            )
+    var i = 1
+    while (i + 1 <= args.size) {
+      if (list.last().routes.isEmpty()) break
+      val route = list.last().routes.sortedBy { it.priority }.find { it.name == args[i] } ?: break
+      list.add(route)
+      i += route.unit
+    }
+    return list
+  }
+
+  fun unregister() {
+    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
+    f.isAccessible = true
+    val commandMap = f.get(Bukkit.getServer()) as CommandMap
+    for (route in entries) {
+      commandMap.getCommand(route.name)?.unregister(commandMap)
+    }
+  }
+}
+
+abstract class Argument(
+        val argname: String,
+        vararg routes: Argument,
+        val execute: (CommandSender, Array<String>) -> Unit
+) {
+  val name = argname
+  var routes = routes.toList()
+  var permission: String = ""
+    set(value) {
+      field = value
+      if (value.isEmpty()) return
+      for (route in routes) {
+        route.permission = value + "." + route.name
+      }
+    }
+  var condition: (CommandSender) -> Boolean = { true }
+
+  public fun addArgs(vararg routes: Argument): Argument {
+    this.routes += routes
+    return this
+  }
+
+  abstract var priority: Int
+  open var unit: Int = 1
+  open fun onCommand(sender: CommandSender, args: Array<String>) {
+    execute(sender, args)
+  }
+
+  abstract fun suggest(sender: CommandSender, args: Array<String>): List<String>
+
+  fun getCompletList(sender: CommandSender, args: Array<String>): List<String> {
+    return routes
+            .filter { sender.hasPermission(it.permission) && it.condition(sender) }
+            .map { it.suggest(sender, args) }
+            .flatten()
+  }
+}
+
+class Route(
+        name: String,
+        vararg routes: Argument,
+        execute: (CommandSender, Array<String>) -> Unit
+) : Argument(name, *routes, execute = execute) {
+  override var priority: Int = 2
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return if (sender.hasPermission(this.permission) &&
+                    this.condition(sender) &&
+                    this.name.startsWith(args.last())
+    )
+            listOf(this.name)
+    else listOf()
+  }
+}
+
+class Text(name: String, vararg routes: Argument, execute: (CommandSender, Array<String>) -> Unit) :
+        Argument(name, *routes, execute = execute) {
+  override var priority: Int = 0
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return listOf(args.last())
+  }
+}
+
+class Integer(
+        name: String,
+        vararg routes: Argument,
+        execute: (CommandSender, Array<String>) -> Unit
+) : Argument(name, *routes, execute = execute) {
+  override var priority: Int = 1
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return listOf()
+  }
+}

src/main/kotlin/net/hareworks/simplymcdb/App.kt

@@ -1,7 +1,7 @@
 package net.hareworks.simplymcdb
 
-import net.hareworks.kommand_lib.KommandLib
+import net.hareworks.kommandlib.KommandLib
-import net.hareworks.simplymcdb.command.registerCommands
+import net.hareworks.simplymcdb.command.smcdb
 import net.hareworks.simplymcdb.database.Database
 import org.bukkit.plugin.java.JavaPlugin
 
@@ -30,7 +30,7 @@ public class App : JavaPlugin() {
   override fun onEnable() {
     instance = this
     Config.init()
-    command = registerCommands(this)
+    command = KommandLib(this, smcdb)
 
     server.pluginManager.registerEvents(EventListener, this)
 
@@ -59,4 +59,4 @@ public class App : JavaPlugin() {
     logger.info("simplymcdb disabled.")
     enabled = State.DISABLED
   }
-}
+}

src/main/kotlin/net/hareworks/simplymcdb/Command.kt

@@ -1,281 +1,287 @@
 package net.hareworks.simplymcdb.command
 
-import java.util.UUID
+import com.github.michaelbull.result.*
-import net.hareworks.kommand_lib.KommandLib
+import net.hareworks.kommandlib.*
-import net.hareworks.kommand_lib.kommand
+import net.hareworks.simplymcdb.*
-import net.hareworks.simplymcdb.App
-import net.hareworks.simplymcdb.Config
-import net.hareworks.simplymcdb.State
 import net.hareworks.simplymcdb.database.Database
-import net.hareworks.simplymcdb.fetch
-import net.hareworks.simplymcdb.findPlayersNeedingMigration
-import net.hareworks.simplymcdb.isRegistered
-import net.hareworks.simplymcdb.overwritePlayerData
-import net.hareworks.simplymcdb.register
-import net.hareworks.simplymcdb.update
-import net.hareworks.simplymcdb.PlayerSerializer
 import net.kyori.adventure.audience.Audience
 import net.kyori.adventure.text.minimessage.MiniMessage
 import org.bukkit.entity.Player
-import org.bukkit.plugin.java.JavaPlugin
-
-private val miniMessage = MiniMessage.miniMessage()
-private val commandBuffer = mutableMapOf<UUID, String>()
 
 public fun Audience.sendMM(message: String) {
-  this.sendMessage(miniMessage.deserialize(message))
+  this.sendMessage(MiniMessage.miniMessage().deserialize(message))
 }
 
-private fun Audience.sendConfigHelp() {
+val command_buffer = mutableMapOf<java.util.UUID, String>()
-  sendMM(
+public val smcdb =
-      "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database")
+        Route("smcdb") { sender, _ -> sender.sendMessage("simptlymcdb command") }
-}
+                .addArgs(
-
+                        Route("config") { sender, _ ->
-public fun registerCommands(plugin: JavaPlugin): KommandLib =
+                                  (sender as Player).performCommand("smcdb config help")
-    kommand(plugin) {
+                                }
-      command("smcdb") {
+                                .addArgs(
-        description = "Control Simply-Minecraft-DB"
+                                        Route("reload") { sender, _ ->
-        permission = "simplydb.command"
+                                          sender.sendMessage("reloading config...")
-
+                                          Config.reload()
-        executes {
+                                          sender.sendMessage("reloaded.")
-          sender.sendMessage("simplymcdb command")
+                                        },
-        }
+                                        Route("fetch") { sender, _ ->
-
+                                          sender.sendMessage("fetching config...")
-        literal("config") {
+                                        },
-          requires("simplydb.command.config")
+                                        Route("upload") { sender, _ ->
-          executes { sender.sendConfigHelp() }
+                                          sender.sendMessage("uploading config...")
-
+                                        },
-          literal("reload") {
+                                        Route("help") { sender, _ ->
-            requires("simplydb.command.config.reload")
+                                          var help =
-            executes {
+                                                  MiniMessage.miniMessage()
-              sender.sendMessage("reloading config...")
+                                                          .deserialize(
-              Config.reload()
+                                                                  "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database"
-              sender.sendMessage("reloaded.")
+                                                          )
-            }
+                                          sender.sendMessage(help)
-          }
+                                        }
-
+                                ),
-          literal("fetch") {
+                        Route("help") { sender, _ ->
-            requires("simplydb.command.config.fetch")
+                          sender.sendMM(
-            executes { sender.sendMessage("fetching config...") }
+                                  "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it"
-          }
+                          )
-
+                        },
-          literal("upload") {
+                        Route("activate") { sender, _ ->
-            requires("simplydb.command.config.upload")
+                          if (App.instance.enabled == State.ACTIVE) {
-            executes { sender.sendMessage("uploading config...") }
+                            sender.sendMessage("simplymcdb is already enabled.")
-          }
+                            return@Route
-
+                          }
-          literal("help") { executes { sender.sendConfigHelp() } }
+                          App.instance.enable()
-        }
+                          sender.sendMessage("simplymcdb enabled.")
-
+                        },
-        literal("help") {
+                        Route("deactivate") { sender, _ ->
-          executes {
+                          if (App.instance.enabled == State.DISABLED) {
-            sender.sendMM(
+                            sender.sendMessage("simplymcdb is already disabled.")
-                "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it")
+                            return@Route
-          }
+                          }
-        }
+                          App.instance.disable()
-
+                          sender.sendMessage("simplymcdb disabled.")
-        literal("activate") {
+                        },
-          requires("simplydb.command.on")
+                        Route("database") { _, _ -> }
-          executes {
+                                .addArgs(
-            if (App.instance.enabled == State.ACTIVE) {
+                                        Route("init") { sender, _ ->
-              sender.sendMessage("simplymcdb is already enabled.")
+                                          Database.initialize()
-              return@executes
+                                          sender.sendMessage("database initialized.")
-            }
+                                        },
-            App.instance.enable()
+                                        Route("reset") { sender, _ ->
-            sender.sendMessage("simplymcdb enabled.")
+                                          Database.reset()
-          }
+                                          sender.sendMessage("database reset.")
-        }
+                                        },
-
+                                ),
-        literal("deactivate") {
+                        Route("migrate") { sender, _ ->
-          requires("simplydb.command.off")
+                          if (sender !is Player) {
-          executes {
+                            sender.sendMM("<red>[SMCDB] This command can only be run by players.")
-            if (App.instance.enabled == State.DISABLED) {
+                            return@Route
-              sender.sendMessage("simplymcdb is already disabled.")
+                          }
-              return@executes
+                          when (App.instance.enabled) {
-            }
+                            State.DISABLED -> {
-            App.instance.disable()
+                              sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
-            sender.sendMessage("simplymcdb disabled.")
+                              return@Route
-          }
+                            }
-        }
+                            State.DISCONNECTED -> {
-
+                              sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
-        literal("database") {
+                              return@Route
-          literal("init") {
+                            }
-            executes {
+                            else -> {}
-              Database.initialize()
+                          }
-              sender.sendMessage("database initialized.")
+                          if (!isRegistered(sender.uniqueId)) {
-            }
+                            sender.sendMM("<red>[SMCDB] You are not registered in the database.")
-          }
+                            return@Route
-          literal("reset") {
+                          }
-            executes {
+                          try {
-              Database.reset()
+                            sender.sendMM("<gray>[SMCDB] Applying legacy data...")
-              sender.sendMessage("database reset.")
+                            fetch(sender)
-            }
+                            update(sender)
-          }
+                            sender.sendMM("<green>[SMCDB] Migration complete. Data updated to the latest format.")
-        }
+                          } catch (e: Exception) {
-
+                            App.instance.logger.warning("Failed to migrate data for ${sender.uniqueId}: ${e.message}")
-        literal("migrate") {
+                            sender.sendMM("<red>[SMCDB] Migration failed. Check server logs.")
-          executes {
+                          }
-            val player = sender as? Player
+                        }.addArgs(
-            if (player == null) {
+                                Route("all") { sender, _ ->
-              sender.sendMM("<red>[SMCDB] This command can only be run by players.")
+                                  if (sender !is Player) {
-              return@executes
+                                    sender.sendMM("<red>[SMCDB] This command can only be run by players.")
-            }
+                                    return@Route
-            when (App.instance.enabled) {
+                                  }
-              State.DISABLED -> {
+                                  when (App.instance.enabled) {
-                sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
+                                    State.DISABLED -> {
-                return@executes
+                                      sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
-              }
+                                      return@Route
-              State.DISCONNECTED -> {
+                                    }
-                sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
+                                    State.DISCONNECTED -> {
-                return@executes
+                                      sender.sendMM(
-              }
+                                              "<yellow>[SMCDB] Database disconnected. Try again later."
-              else -> {}
+                                      )
-            }
+                                      return@Route
-            if (!isRegistered(player.uniqueId)) {
+                                    }
-              sender.sendMM("<red>[SMCDB] You are not registered in the database.")
+                                    else -> {}
-              return@executes
+                                  }
-            }
+                                  val targets = findPlayersNeedingMigration()
-            try {
+                                  if (targets.isEmpty()) {
-              sender.sendMM("<gray>[SMCDB] Applying legacy data...")
+                                    sender.sendMM("<gray>[SMCDB] No legacy data found.")
-              fetch(player)
+                                    return@Route
-              update(player)
+                                  }
-              sender.sendMM("<green>[SMCDB] Migration complete. Data updated to the latest format.")
+                                  sender.sendMM(
-            } catch (e: Exception) {
+                                          "<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait."
-              App.instance.logger.warning("Failed to migrate data for ${player.uniqueId}: ${e.message}")
+                                  )
-              sender.sendMM("<red>[SMCDB] Migration failed. Check server logs.")
+                                  val backup = PlayerSerializer.serialize(sender)
-            }
+                                  var migrated = 0
-          }
+                                  try {
-
+                                    targets.forEach { entry ->
-          literal("all") {
+                                      try {
-            executes {
+                                        PlayerSerializer.deserialize(sender, entry.serialized)
-              val executor = sender as? Player
+                                        val updatedSnapshot = PlayerSerializer.serialize(sender)
-              if (executor == null) {
+                                        overwritePlayerData(entry.uuid, updatedSnapshot)
-                sender.sendMM("<red>[SMCDB] This command can only be run by players.")
+                                        migrated++
-                return@executes
+                                      } catch (ex: Exception) {
-              }
+                                        App.instance.logger.warning(
-              when (App.instance.enabled) {
+                                                "Failed to migrate data for ${entry.uuid}: ${ex.message}"
-                State.DISABLED -> {
+                                        )
-                  sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
+                                      }
-                  return@executes
+                                    }
-                }
+                                  } finally {
-                State.DISCONNECTED -> {
+                                    try {
-                  sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
+                                      PlayerSerializer.deserialize(sender, backup)
-                  return@executes
+                                    } catch (restoreEx: Exception) {
-                }
+                                      App.instance.logger.warning(
-                else -> {}
+                                              "Failed to restore migration executor state: ${restoreEx.message}"
-              }
+                                      )
-              val targets = findPlayersNeedingMigration()
+                                    }
-              if (targets.isEmpty()) {
+                                  }
-                sender.sendMM("<gray>[SMCDB] No legacy data found.")
+                                  sender.sendMM(
-                return@executes
+                                          "<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures."
-              }
+                                  )
-              sender.sendMM("<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait.")
+                                }
-              val backup = PlayerSerializer.serialize(executor)
+                        ),
-              var migrated = 0
+                        Route("check") { sender, _ ->
-              try {
+                          sender.sendMM(
-                targets.forEach { entry ->
+                                  "${when (App.instance.enabled) {
-                  try {
+                                              State.ACTIVE -> "<green>●"
-                    PlayerSerializer.deserialize(executor, entry.serialized)
+                                              State.DISCONNECTED -> "<yellow>■"
-                    val updatedSnapshot = PlayerSerializer.serialize(executor)
+                                              State.DISABLED -> "<red>○"
-                    overwritePlayerData(entry.uuid, updatedSnapshot)
+                                            }}<white> simply-minecraft-database"
-                    migrated++
+                          )
-                  } catch (ex: Exception) {
+                          sender.sendMM(
-                    App.instance.logger.warning("Failed to migrate data for ${entry.uuid}: ${ex.message}")
+                                  "status: ${when (App.instance.enabled) {
-                  }
+                                                          State.ACTIVE -> "<green>active" 
-                }
+                                                          State.DISCONNECTED -> "<yellow>disconnected"
-              } finally {
+                                                          State.DISABLED -> "<red>disabled"}}"
-                try {
+                          )
-                  PlayerSerializer.deserialize(executor, backup)
+                          sender.sendMM(
-                } catch (restoreEx: Exception) {
+                                  "<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}"
-                  App.instance.logger.warning("Failed to restore migration executor state: ${restoreEx.message}")
+                          )
-                }
+                          sender.sendMM(
-              }
+                                  "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}"
-              sender.sendMM("<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures.")
+                          )
-            }
+                        },
-          }
+                        Route("register") { sender, _ ->
-        }
+                          if (sender !is Player) {
-
+                            sender.sendMM("This command is only available for players.")
-        literal("check") {
+                            return@Route
-          executes {
+                          } else
-            val commandSender = sender
+                                  when (App.instance.enabled) {
-            commandSender.sendMM(
+                                    State.DISABLED ->
-                "${when (App.instance.enabled) {
+                                            sender.sendMM(
-                  State.ACTIVE -> "<green>●"
+                                                    "<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status."
-                  State.DISCONNECTED -> "<yellow>■"
+                                            )
-                  State.DISABLED -> "<red>○"
+                                    State.DISCONNECTED ->
-                }}<white> simply-minecraft-database")
+                                            sender.sendMM(
-            commandSender.sendMM(
+                                                    "<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status."
-                "status: ${when (App.instance.enabled) {
+                                            )
-                  State.ACTIVE -> "<green>active"
+                                    else -> {
-                  State.DISCONNECTED -> "<yellow>disconnected"
+                                      if (!isRegistered(sender.uniqueId)) {
-                  State.DISABLED -> "<red>disabled"
+                                        sender.sendMM(
-                }}")
+                                                "<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" +
-            commandSender.sendMM(
+                                                        "Are you sure you want to register?<newline>" +
-                "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}")
+                                                        "<green>/smcdb confirm<gray> to confirm."
-            commandSender.sendMM("<gray>- <white>database test: <yellow>checking...")
+                                        )
-
+                                      } else {
-            // Run the potentially slow ping off the main thread to avoid freezing the server thread.
+                                        sender.sendMM("<gray>[SMCDB] You are already registered.")
-            App.instance.server.scheduler.runTaskAsynchronously(App.instance, Runnable {
+                                      }
-              val pingSuccess = try {
+                                    }
-                Database.ping()
+                                  }
-              } catch (ex: Exception) {
+                        },
-                App.instance.logger.warning("Database ping failed: ${ex.message}")
+                        Route("confirm") { sender, _ ->
-                false
+                          if (sender !is Player) return@Route
-              }
+                          when (command_buffer[sender.uniqueId]) {
-              App.instance.server.scheduler.runTask(App.instance, Runnable {
+                            "register" -> {
-                commandSender.sendMM(
+                              if (App.instance.enabled == State.ACTIVE) {
-                    "<gray>- <white>database test result: ${if (pingSuccess) "success" else "failed"}")
+                                register(sender)
-              })
+                                sender.sendMM("<gray>[SMCDB] Successfully registered.")
-            })
+                              } else {
-          }
+                                sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
-        }
+                              }
-
+                            }
-        literal("register") {
+                            else -> {
-          executes {
+                              sender.sendMM("<red>[SMCDB] Invalid command.")
-            val player = sender as? Player
+                            }
-            if (player == null) {
+                          }
-              sender.sendMM("This command is only available for players.")
+                          command_buffer.remove(sender.uniqueId)
-              return@executes
+                        }
-            }
+                        // Route("update") { sender, _ ->
-            when (App.instance.enabled) {
+                        //   if (sender !is Player) {
-              State.DISABLED -> {
+                        //     sender.sendMM("This command is only available for players.")
-                sender.sendMM("<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status.")
+                        //     return@Route
-                return@executes
+                        //   } else
-              }
+                        //           when (App.instance.enabled) {
-              State.DISCONNECTED -> {
+                        //             State.DISABLED ->
-                sender.sendMM("<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status.")
+                        //                     sender.sendMM(
-                return@executes
+                        //                             "<red>[SMCDB] simplymcdb is disabled.<br>Run
-              }
+                        // /smcdb check to check the status."
-              else -> {}
+                        //                     )
-            }
+                        //             State.DISCONNECTED ->
-            if (!isRegistered(player.uniqueId)) {
+                        //                     sender.sendMM(
-              sender.sendMM(
+                        //                             "<red>[SMCDB] simplymcdb is enabled but
-                  "<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" +
+                        // disconnected.<br>Run /smcdb check to check the status."
-                      "Are you sure you want to register?<newline>" +
+                        //                     )
-                      "<green>/smcdb confirm<gray> to confirm.")
+                        //             else -> {
-              commandBuffer[player.uniqueId] = "register"
+                        //               if (isRegistered(sender.uniqueId)) {
-            } else {
+                        //                 update(sender)
-              sender.sendMM("<gray>[SMCDB] You are already registered.")
+                        //                 sender.sendMM("<gray>[SMCDB] Successfully updated.")
-            }
+                        //               } else {
-          }
+                        //                 sender.sendMM("<red>[SMCDB] You are not registered.")
-        }
+                        //               }
-
+                        //             }
-        literal("confirm") {
+                        //           }
-          executes {
+                        // },
-            val player = sender as? Player ?: return@executes
+                        // Route("fetch") { sender, _ ->
-            when (commandBuffer[player.uniqueId]) {
+                        //   if (sender !is Player) {
-              "register" -> {
+                        //     sender.sendMM("This command is only available for players.")
-                if (App.instance.enabled == State.ACTIVE) {
+                        //     return@Route
-                  register(player)
+                        //   } else
-                  sender.sendMM("<gray>[SMCDB] Successfully registered.")
+                        //           when (App.instance.enabled) {
-                } else {
+                        //             State.DISABLED ->
-                  sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
+                        //                     sender.sendMM(
-                }
+                        //                             "<red>[SMCDB] simplymcdb is disabled.<br>Run
-              }
+                        // /smcdb check to check the status."
-              else -> sender.sendMM("<red>[SMCDB] Invalid command.")
+                        //                     )
-            }
+                        //             State.DISCONNECTED ->
-            commandBuffer.remove(player.uniqueId)
+                        //                     sender.sendMM(
-          }
+                        //                             "<red>[SMCDB] simplymcdb is enabled but
-        }
+                        // disconnected.<br>Run /smcdb check to check the status."
-      }
+                        //                     )
-    }
+                        //             else -> {
+                        //               if (isRegistered(sender.uniqueId)) {
+                        //                 sender.sendMM(
+                        //                         "<gray>[SMCDB] Welcome back,
+                        // ${sender.name}.<newline>Fetching your data..."
+                        //                 )
+                        //                 fetch(sender)
+                        //               } else {
+                        //                 sender.sendMM(
+                        //                         "<gray>[SMCDB] Welcome, ${sender.name}.<newline>"
+                        // +
+                        //                                 "SMCDB is active but you have already
+                        // played before.<newline>" +
+                        //                                 "Run <green>/smcdb register<gray> to
+                        // register yourself."
+                        //                 )
+                        //               }
+                        //             }
+                        //           }
+                        // },
+                        )