4.0.1 Release

Update dependencies, actually fix tests
Fix tests
2022-04-16 18:40:34 +02:00 · 2022-04-15 21:51:29 +02:00 · 2022-04-15 20:08:13 +02:00 · 2022-03-23 09:27:43 +01:00 · 2022-03-23 09:26:53 +01:00 · 2022-03-23 09:20:09 +01:00
171 changed files with 2954 additions and 2989 deletions
@@ -1 +0,0 @@
-.gitea/CODEOWNERS linguist-detectable=false
@@ -1,3 +0,0 @@
-# Pull requests request review from the eligible staff team(s).
-# One approval from either an Admin or Developer satisfies branch protection.
-*   @trueog/Admins @trueog/Developers
@@ -1,60 +1,6 @@
 # Maintenance Changelog
 This file contains update logs for this project. The top may contain a `Unreleased` section, gathering update logs for a future update during development.

---
-## 4.3.0 - September 17th 2024
-### Changed
-* Added alternative player count and player list hover message for when endtimers are running, similar to the existing ping messages setting. They are disabled by default and can be found in their `player-count-message` and `player-list-hover-message` config sections
-* All timer commands now accept durations like `2h30m`, `1h30m5s`, or `90s`. The default behavior without units will still be in minutes
-  * The language defaults will *not* automatically update the command help messages
-* Slightly reorganized the configuration file (it will be automatically migrated on startup, but new sections will be slapped at the bottom of the file)
-* The `fallback` field now also accepts null values next to an empty array for disabling the feature
-* Updated language files from [Crowdin](https://crowdin.com/translate/maintenance)
-
-### Fixed
-* Fixed the `/maintenance dump` command
-* Fixed the original player sample not being cleared in Velocity
-* Velocity: Fixed the console getting broadcasts twice
-* Velocity: Don't log legacy color codes to the console
-* Paper: Fixed the player count messages on Paper 1.21
---
-## 4.2.1 - May 17th 2024
-### Changed
-* The proxied maintenance status is now also shown for forced hosts (thanks to alec-jensen)
-* Offline player fetching improvements (thanks to EpicPlayerA10)
-  * Added the setting `fallback-to-offline-uuid` to use offline player uuids in maintenance whitelist commands (defaults to false)
-* Maintenance now skips the plugin remapping process on 1.20.5+ Paper servers
-* Small optimizations
-* Updated language files from [Crowdin](https://crowdin.com/translate/maintenance)
-  * Massive thank you to all the contributors! These include: vortix22, xdalul, CodeZhangBorui, jesusskye, Doc94,
-    Texider_, marvin2k0, leonard.bausenwein, pro.timeo.kerjean, meviper, troev5, Murka124, jhqwqmc, Pryzinho,
-    raysetratyboy, Kolja07, and rikunightcore
---
-## 4.2.0 - September 17th 2023
-### Changed
-* Velocity/Bungee: Added `commands-on-single-maintenance-enable` and `commands-on-single-maintenance-disable` config options to define commands to be executed after maintenance has been toggled on a proxied server
-  * Commands inside the `all` list will be executed for any proxied server, but you can also define commands for specific servers by adding arrays with the server names as keys
-  * You can use the placeholder `%SERVER%` in commands to be replaced with the server name
-* Start-, end-, and schedule timers for proxied servers now also include the server in the feedback message
-* Updated language files from [Crowdin](https://crowdin.com/translate/maintenance) (including new language files for Danish, Japanese, Korean, and Hungarian)
---
-## 4.1.0 - April 17th 2023
-### Changed
-* Added config option `enable-playercounthovermessage` to be able to toggle the player count hover message
-* Removed platform specific command aliases (e.g. `maintenancevelocity`)
-* Translations
-  * Moved translation editing to [Crowdin](https://crowdin.com/translate/maintenance)
-  * Added Turkish translation file (thanks to Proomp)
-  * Added Swedish translation file (thanks to Sup33r)
-  * Added Ukrainian translation file (thanks to Mrlucke)
-  * Added Japanese translation file (thanks to yu-solt)
-* Added bStats metrics to Velocity and Sponge modules
-
-### Fixed
-* Fixed disabling the `enable-pingmessages` setting not working on Paper servers
-* Fixed variable replacement in messages with gradients
-* Fixed the message for cancelling proxied server timers not replacing the server argument
-* Setting `enable-pingmessages` to `false` no longer disables custom player and player hover messages
 ---
 ## 4.0.1 - April 17th 2022
 ### Fixed
@@ -119,7 +65,7 @@ This file contains update logs for this project. The top may contain a `Unreleas
 * Bungee/Velocity: Added language fields to choose custom kickmessages for individual proxied servers
  * See [**HERE**](https://github.com/KennyTV/Maintenance/wiki/Configuration#language-file) for an example setting
 * Added Chinese language file (thanks to Spigot user yeban)
-* Added Italian language file
+* Added Italian language file (thanks to @TheViperShow)
 * Updated Russian language file (thanks to Spigot user En_0t_S)
 * Removed automated config migration from 2.x->3.0
  * See [**HERE**](https://github.com/KennyTV/Maintenance/wiki/Updates#updating-from-2x) on how to do that manually - virtually noone should be using such old versions anymore
@@ -8,7 +8,7 @@ about: Report a bug to have it fixed
 **How does the problem occur/what are the steps to reproduce it?**

 ## Error
-**Is there an error? Save it via https://mclo.gs/ and link paste the link.**
+**Is there an error? Save it via https://pastebin.com/ and link paste the link.**

 ## Server information
 **Type '/maintenance dump' and paste the given link here**
@@ -7,20 +7,19 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/actions/wrapper-validation@v3
+      - uses: actions/checkout@v3.0.0

-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3.0.0
        with:
-          java-version: 17
+          java-version: 11
          distribution: 'temurin'

      - name: Build with Gradle
        run: ./gradlew build

      - name: Upload a Build Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3.0.0
        with:
          name: Maintenance Files
          path: build/libs
@@ -2,7 +2,6 @@
 build/
 .gradle
 bin/
-run/
 tmp/
 *.tmp
 *.bak
@@ -1,10 +1,11 @@
 # Maintenance
 [![Version](https://img.shields.io/github/release/kennytv/Maintenance.svg)](https://github.com/kennytv/Maintenance/releases)
 ![Build Status](https://github.com/kennytv/Maintenance/workflows/Build/badge.svg)
-[![Crowdin](https://badges.crowdin.net/maintenance/localized.svg)](https://crowdin.com/project/maintenance)
+[![GH Downloads](https://img.shields.io/github/downloads/kennytv/Maintenance/total)](https://github.com/kennytv/Maintenance/releases)
 [![Discord](https://img.shields.io/discord/489135856284729384.svg?label=Discord&logo=discord&logoColor=fff)](https://discord.gg/vGCUzHq)
+[![Twitter](https://img.shields.io/twitter/follow/kennytvn.svg?label=Twitter)](https://twitter.com/kennytvn)

-Maintenance is the most customizable free maintenance plugin for your Minecraft server you can find. It runs on Paper (also Spigot, but with limited functionality), BungeeCord, Sponge, as well as Velocity.
+Maintenance is the most customizable free maintenance plugin for your Minecraft server you can find. It runs on Spigot, BungeeCord, Sponge, as well as Velocity.

 Its features include:
 * A custom motd as well as server icon, that will be shown during maintenance
@@ -15,22 +16,19 @@ Its features include:
 * Features specifically for Bungee/Velocity
  * Only want to enable maintenance on a single server? You can also do so by using the `/maintenance <on/off> <servername>` command
  * Link multiple proxy instances through a MySQL database connection, so you don't have to change maintenance on each proxy by hand
-  * Use PlaceholderAPI placeholders with the [**MaintenanceAddon**](https://hangar.papermc.io/kennytv/MaintenanceAddon) (for Velocity and Bungee)
+  * Use PlaceholderAPI placeholders with the [**MaintenanceAddon**](https://github.com/kennytv/Maintenance/wiki/MaintenanceAddon) (only for Bungee)

 A full list of commands, permissions and configuration options can be found in the wiki listed below.
-* [Hangar Downloads](https://hangar.papermc.io/kennytv/Maintenance)
 * [Wiki](https://github.com/kennytv/Maintenance/wiki) (configuration, permissions, API usage)
+* [Downloads](https://github.com/kennytv/Maintenance/releases) (GitHub)
 * [Changelogs](https://github.com/kennytv/Maintenance/blob/master/.github/CHANGELOG.md)
 * [Issue tracker/bug reports](https://github.com/kennytv/Maintenance/issues)
 * [Discord](https://discord.gg/vGCUzHq)
-* [PlaceholderAPI addon](https://hangar.papermc.io/kennytv/MaintenanceAddon)
+* [PlaceholderAPI addon](https://github.com/kennytv/Maintenance/wiki/MaintenanceAddon)

-
-## Localization
-The English base language file is localized using Crodwin. You can see and update translations here: https://crowdin.com/project/maintenance
-
-Join [our Discord](https://discord.gg/vGCUzHq) if you want to get the proofreader or translator role on the project.
-Adding translations for languages not yet listed is always appreciated as well!
+Other forum threads
+* [Spigot forums](https://www.spigotmc.org/resources/maintenance.40699/)
+* [Ore/Sponge Forums](https://ore.spongepowered.org/KennyTV/Maintenance)

 ## Compiling
 To create a working jar yourself, simply clone the project and compile it with Gradle (`gradlew build`).
@@ -1,5 +1,5 @@
 plugins {
-    id("com.gradleup.shadow")
+    id("com.github.johnrengelman.shadow")
 }

 // Shade and relocate adventure in an extra module, so that common/the rest can directly depend on a
@@ -1,5 +1,5 @@
 plugins {
-    id("com.gradleup.shadow")
+    id("com.github.johnrengelman.shadow")
 }

 tasks {
@@ -1,5 +1,5 @@
 plugins {
-    id("com.gradleup.shadow")
+    id("com.github.johnrengelman.shadow")
 }

 tasks {
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -8,5 +8,5 @@ repositories {

 dependencies {
    // version must be manually kept in sync with the one in root project settings.gradle.kts
-    implementation("com.gradleup.shadow", "shadow-gradle-plugin", "8.3.9")
+    implementation("gradle.plugin.com.github.johnrengelman", "shadow", "7.1.1")
 }
@@ -30,11 +30,14 @@ private fun Project.configurePublication(configurer: MavenPublication.() -> Unit
 }

 fun Project.latestCommitHash(): String {
-    return providers.exec {
+    val byteOut = ByteArrayOutputStream()
+    exec {
        commandLine = listOf("git", "rev-parse", "--short", "HEAD")
-    }.standardOutput.asBytes.get().toString(Charsets.UTF_8).trim()
+        standardOutput = byteOut
+    }
+    return byteOut.toString(Charsets.UTF_8.name()).trim()
 }

 fun JavaPluginExtension.javaTarget(version: Int) {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(17))
+    toolchain.languageVersion.set(JavaLanguageVersion.of(version))
 }
@@ -1,16 +1,13 @@
 plugins {
    `java-library`
    `maven-publish`
-    signing
 }

 tasks {
    // Variable replacements
    processResources {
-        val ver = project.version.toString()
-        val desc = project.description
        filesMatching(listOf("plugin.yml", "bungee.yml", "META-INF/sponge_plugins.json")) {
-            expand("version" to ver, "description" to desc)
+            expand("version" to project.version, "description" to project.description)
        }
    }
    javadoc {
@@ -31,43 +28,10 @@ java {
    withSourcesJar()
 }

-signing {
-    useGpgCmd()
-    sign(publishing.publications)
-}
-
 publishing {
    publications.create<MavenPublication>("mavenJava") {
        groupId = rootProject.group as String
        artifactId = project.name
        version = rootProject.version as String
-        pom {
-            name.set("Maintenance")
-            description.set("Paper plugin to enable maintenance mode on your Minecraft server.")
-            url.set("https://github.com/kennytv/Maintenance")
-            licenses {
-                license {
-                    name.set("GNU GPLv3")
-                    url.set("https://www.gnu.org/licenses/gpl-3.0.html")
-                }
-            }
-            developers {
-                developer {
-                    id.set("kennytv")
-                    name.set("Nassim Jahnke")
-                }
-            }
-        }
    }
-
-    if (!name.startsWith("adventure")) {
-        repositories.maven {
-            name = "OSSRH"
-            url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-            credentials {
-                username = System.getenv("OSSRH_USERNAME")
-                password = System.getenv("OSSRH_PASSWORD")
-            }
-        }
-    }
-}
+}
@@ -1,12 +1,10 @@
-import java.util.*
-
 plugins {
    id("maintenance.shadow-conventions")
 }

 tasks {
    shadowJar {
-        archiveFileName.set("Maintenance-${project.name.substringAfter("maintenance-").replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}-${project.version}.jar")
+        archiveFileName.set("Maintenance-${project.name.substringAfter("maintenance-").capitalize()}-${project.version}.jar")
        destinationDirectory.set(rootProject.layout.buildDirectory.dir("libs"))
    }
 }
@@ -4,7 +4,7 @@ import org.gradle.kotlin.dsl.named

 plugins {
    id("maintenance.base-conventions")
-    id("com.gradleup.shadow")
+    id("com.github.johnrengelman.shadow")
 }

 tasks {
@@ -25,5 +25,4 @@ publishShadowJar()

 fun ShadowJar.configureRelocations() {
    relocate("com.zaxxer.hikari", "eu.kennytv.maintenance.lib.hikari")
-    relocate("org.bstats", "eu.kennytv.maintenance.lib.bstats")
 }
@@ -2,7 +2,6 @@ import org.gradle.api.plugins.JavaPlugin.TEST_IMPLEMENTATION_CONFIGURATION_NAME

 plugins {
    base
-    id("eclipse")
    id("maintenance.build-logic")
 }

@@ -13,10 +12,11 @@ allprojects {
 }

 val platforms = setOf(
-    projects.maintenancePaper,
+    projects.maintenanceSpigot,
+    projects.maintenanceBungee,
    projects.maintenanceSponge,
    projects.maintenanceVelocity
-).map { it.path }
+).map { it.dependencyProject }

 val special = setOf(
    projects.maintenance,
@@ -25,10 +25,11 @@ val special = setOf(
    projects.adventure,
    projects.adventure.adventureApi,
    projects.adventure.adventurePlatformBukkit,
-).map { it.path }
+    projects.adventure.adventurePlatformBungee,
+).map { it.dependencyProject }

 subprojects {
-    when (path) {
+    when (this) {
        in platforms -> plugins.apply("maintenance.platform-conventions")
        in special -> plugins.apply("maintenance.base-conventions")
        else -> plugins.apply("maintenance.standard-conventions")
@@ -38,4 +39,4 @@ subprojects {
        TEST_IMPLEMENTATION_CONFIGURATION_NAME(rootProject.libs.bundles.junit)
        TEST_IMPLEMENTATION_CONFIGURATION_NAME(rootProject.libs.snakeyaml)
    }
-}
+}
@@ -0,0 +1,7 @@
+dependencies {
+    implementation(projects.maintenanceCoreProxy)
+    implementation(projects.adventure.adventurePlatformBungee) {
+        targetConfiguration = "shadow"
+    }
+    compileOnly(libs.bungee)
+}
@@ -0,0 +1,47 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee;
+
+import eu.kennytv.maintenance.api.Maintenance;
+import eu.kennytv.maintenance.core.MaintenanceBase;
+import net.md_5.bungee.api.plugin.Plugin;
+
+import java.io.File;
+
+public final class MaintenanceBungeeBase extends Plugin implements MaintenanceBase {
+    private MaintenanceBungeePlugin maintenance;
+
+    @Override
+    public void onEnable() {
+        maintenance = new MaintenanceBungeePlugin(this);
+    }
+
+    @Override
+    public void onDisable() {
+        maintenance.disable();
+    }
+
+    @Override
+    public Maintenance getApi() {
+        return maintenance;
+    }
+
+    File getPluginFile() {
+        return getFile();
+    }
+}
@@ -0,0 +1,299 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.bungee.command.MaintenanceBungeeCommand;
+import eu.kennytv.maintenance.bungee.command.MaintenanceBungeeCommandBase;
+import eu.kennytv.maintenance.bungee.listener.ProxyPingListener;
+import eu.kennytv.maintenance.bungee.listener.ServerConnectListener;
+import eu.kennytv.maintenance.bungee.metrics.MetricsLite;
+import eu.kennytv.maintenance.bungee.util.BungeeSenderInfo;
+import eu.kennytv.maintenance.bungee.util.BungeeServer;
+import eu.kennytv.maintenance.bungee.util.BungeeTask;
+import eu.kennytv.maintenance.bungee.util.ComponentUtil;
+import eu.kennytv.maintenance.core.dump.PluginDump;
+import eu.kennytv.maintenance.core.hook.ServerListPlusHook;
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import eu.kennytv.maintenance.core.proxy.hook.LuckPermsProxyHook;
+import eu.kennytv.maintenance.core.proxy.util.ProfileLookup;
+import eu.kennytv.maintenance.core.proxy.util.ProxyOfflineSenderInfo;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import eu.kennytv.maintenance.core.util.ServerType;
+import eu.kennytv.maintenance.core.util.Task;
+import eu.kennytv.maintenance.lib.kyori.adventure.platform.bungeecord.BungeeAudiences;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.Favicon;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.ComponentBuilder;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.chat.hover.content.Text;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.api.plugin.PluginManager;
+import org.jetbrains.annotations.Nullable;
+
+import javax.imageio.ImageIO;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
+    private final MaintenanceBungeeBase plugin;
+    private final BungeeAudiences audiences;
+    private Favicon favicon;
+
+    MaintenanceBungeePlugin(final MaintenanceBungeeBase plugin) {
+        super(plugin.getDescription().getVersion(), ServerType.BUNGEE);
+        this.plugin = plugin;
+        this.audiences = BungeeAudiences.create(plugin);
+
+        settingsProxy = new SettingsProxy(this);
+        settings = settingsProxy;
+
+        sendEnableMessage();
+
+        final PluginManager pm = getProxy().getPluginManager();
+        pm.registerListener(plugin, new ProxyPingListener(this, settingsProxy));
+        pm.registerListener(plugin, new ServerConnectListener(this, settingsProxy));
+        commandManager = new MaintenanceBungeeCommand(this, settingsProxy);
+        pm.registerCommand(plugin, new MaintenanceBungeeCommandBase(commandManager));
+
+        continueLastEndtimer();
+        new MetricsLite(plugin);
+
+        final Plugin serverListPlus = pm.getPlugin("ServerListPlus");
+        if (serverListPlus != null) {
+            serverListPlusHook = new ServerListPlusHook(serverListPlus);
+            if (settings.isEnablePingMessages()) {
+                serverListPlusHook.setEnabled(!settingsProxy.isMaintenance());
+            }
+            plugin.getLogger().info("Enabled ServerListPlus integration!");
+        }
+
+        if (false && pm.getPlugin("LuckPerms") != null) {
+            LuckPermsProxyHook.<ProxiedPlayer>register(this, player -> {
+                final net.md_5.bungee.api.connection.Server server = player.getServer();
+                return server != null ? server.getInfo().getName() : null;
+            });
+            getLogger().info("Registered LuckPerms context");
+        }
+    }
+
+    @Override
+    public void sendUpdateNotification(final SenderInfo sender) {
+        final TextComponent tc1 = new TextComponent(TextComponent.fromLegacyText(getPrefix()));
+        final TextComponent tc2 = new TextComponent(TextComponent.fromLegacyText("§cDownload it at: §6https://www.spigotmc.org/resources/maintenance.40699/"));
+        final TextComponent click = new TextComponent(TextComponent.fromLegacyText(" §7§l§o(CLICK ME)"));
+        click.setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, "https://www.spigotmc.org/resources/maintenance.40699/"));
+        click.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text(new ComponentBuilder("§aDownload the latest version").create())));
+        tc1.addExtra(tc2);
+        tc1.addExtra(click);
+        ((BungeeSenderInfo) sender).sendMessage(tc1);
+    }
+
+    public boolean isMaintenance(final ServerInfo serverInfo) {
+        return settingsProxy.isMaintenance(serverInfo.getName());
+    }
+
+    @Override
+    protected void kickPlayersFromProxy() {
+        for (final ProxiedPlayer player : getProxy().getPlayers()) {
+            if (!hasPermission(player, "bypass") && !settingsProxy.isWhitelisted(player.getUniqueId())) {
+                player.disconnect(ComponentUtil.toBadComponents(settingsProxy.getKickMessage()));
+            }
+        }
+    }
+
+    @Override
+    protected void kickPlayers(final Server server, final Server fallback) {
+        // Kick players from a proxied server
+        final ServerInfo fallbackServer = fallback != null ? ((BungeeServer) fallback).getServer() : null;
+        final boolean checkForFallback = fallbackServer != null && !isMaintenance(fallback);
+        for (final ProxiedPlayer player : ((BungeeServer) server).getServer().getPlayers()) {
+            if (!hasPermission(player, "bypass") && !settingsProxy.isWhitelisted(player.getUniqueId())) {
+                if (checkForFallback && fallbackServer.canAccess(player)) {
+                    audiences.player(player).sendMessage(settingsProxy.getMessage("singleMaintenanceActivated", "%SERVER%", server.getName()));
+                    player.connect(fallbackServer);
+                } else {
+                    player.disconnect(ComponentUtil.toBadComponents(settingsProxy.getFullServerKickMessage(server.getName())));
+                }
+            } else {
+                audiences.player(player).sendMessage(settingsProxy.getMessage("singleMaintenanceActivated", "%SERVER%", server.getName()));
+            }
+        }
+    }
+
+    @Override
+    protected void kickPlayersTo(final Server server) {
+        // Kick all players to a single waiting server
+        final ServerInfo serverInfo = ((BungeeServer) server).getServer();
+        // Notifications done in global method
+        for (final ProxiedPlayer player : getProxy().getPlayers()) {
+            if (hasPermission(player, "bypass") || settingsProxy.isWhitelisted(player.getUniqueId())) continue;
+            if (player.getServer() != null && player.getServer().getInfo().getName().equals(serverInfo.getName()))
+                continue;
+            if (serverInfo.canAccess(player) && !isMaintenance(serverInfo)) {
+                audiences.player(player).sendMessage(settingsProxy.getMessage("sentToWaitingServer", "%SERVER%", server.getName()));
+                player.connect(serverInfo);
+            } else {
+                player.disconnect(ComponentUtil.toBadComponents(settingsProxy.getKickMessage()));
+            }
+        }
+    }
+
+    @Override
+    public Task startMaintenanceRunnable(final Runnable runnable) {
+        return new BungeeTask(getProxy().getScheduler().schedule(plugin, runnable, 0, 1, TimeUnit.SECONDS).getId());
+    }
+
+    @Override
+    public void getOfflinePlayer(final String name, final Consumer<@Nullable SenderInfo> consumer) {
+        final ProxiedPlayer player = getProxy().getPlayer(name);
+        if (player != null) {
+            consumer.accept(new BungeeSenderInfo(player));
+            return;
+        }
+
+        getProxy().getScheduler().runAsync(plugin, () -> {
+            try {
+                final ProfileLookup profile = doUUIDLookup(name);
+                consumer.accept(new ProxyOfflineSenderInfo(profile.getUuid(), profile.getName()));
+            } catch (final IOException e) {
+                e.printStackTrace();
+                consumer.accept(null);
+            }
+        });
+    }
+
+    @Override
+    public void getOfflinePlayer(final UUID uuid, final Consumer<@Nullable SenderInfo> consumer) {
+        final ProxiedPlayer player = getProxy().getPlayer(uuid);
+        consumer.accept(player != null ? new BungeeSenderInfo(player) : null);
+    }
+
+    @Override
+    @Nullable
+    public Server getServer(final String server) {
+        final ServerInfo serverInfo = getProxy().getServerInfo(server);
+        return serverInfo != null ? new BungeeServer(serverInfo) : null;
+    }
+
+    @Override
+    public Set<String> getServers() {
+        return getProxy().getServers().keySet();
+    }
+
+    @Override
+    @Nullable
+    public String getServerNameOf(final SenderInfo sender) {
+        final ProxiedPlayer player = getProxy().getPlayer(sender.getUuid());
+        if (player == null || player.getServer() == null) return null;
+        return player.getServer().getInfo().getName();
+    }
+
+    @Override
+    public void async(final Runnable runnable) {
+        getProxy().getScheduler().runAsync(plugin, runnable);
+    }
+
+    @Override
+    protected void executeConsoleCommand(final String command) {
+        getProxy().getPluginManager().dispatchCommand(getProxy().getConsole(), command);
+    }
+
+    @Override
+    public void broadcast(final Component component) {
+        audiences.all().sendMessage(component);
+    }
+
+    @Override
+    public File getDataFolder() {
+        return plugin.getDataFolder();
+    }
+
+    @Override
+    public File getPluginFile() {
+        return plugin.getPluginFile();
+    }
+
+    @Override
+    protected int getOnlinePlayers() {
+        return getProxy().getOnlineCount();
+    }
+
+    @Override
+    protected int getMaxPlayers() {
+        return getProxy().getConfig().getPlayerLimit();
+    }
+
+    @Override
+    public InputStream getResource(final String name) {
+        return plugin.getResourceAsStream(name);
+    }
+
+    @Override
+    public Logger getLogger() {
+        return plugin.getLogger();
+    }
+
+    @Override
+    public String getServerVersion() {
+        return getProxy().getVersion();
+    }
+
+    @Override
+    public List<PluginDump> getPlugins() {
+        return getProxy().getPluginManager().getPlugins().stream().map(plugin ->
+                new PluginDump(plugin.getDescription().getName(), plugin.getDescription().getVersion(), Arrays.asList(plugin.getDescription().getAuthor()))).collect(Collectors.toList());
+    }
+
+    @Override
+    protected void loadIcon(final File file) throws IOException {
+        favicon = Favicon.create(ImageIO.read(file));
+    }
+
+    public boolean hasPermission(final CommandSender sender, final String permission) {
+        return sender.hasPermission("maintenance." + permission) || sender.hasPermission("maintenance.admin");
+    }
+
+    public ProxyServer getProxy() {
+        return plugin.getProxy();
+    }
+
+    public Favicon getFavicon() {
+        return favicon;
+    }
+
+    public BungeeAudiences audiences() {
+        return audiences;
+    }
+}
@@ -0,0 +1,82 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.command;
+
+import eu.kennytv.maintenance.bungee.MaintenanceBungeePlugin;
+import eu.kennytv.maintenance.bungee.util.BungeeSenderInfo;
+import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import eu.kennytv.maintenance.core.proxy.command.MaintenanceProxyCommand;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public final class MaintenanceBungeeCommand extends MaintenanceProxyCommand {
+    private final MaintenanceBungeePlugin plugin;
+
+    public MaintenanceBungeeCommand(final MaintenanceBungeePlugin plugin, final SettingsProxy settings) {
+        super(plugin, settings);
+        this.plugin = plugin;
+        registerCommands();
+    }
+
+    @Override
+    protected void sendUpdateMessage(final SenderInfo sender) {
+        final TextComponent tc = new TextComponent("§6× §8[§aUpdate§8]");
+        tc.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/maintenance forceupdate"));
+        tc.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText("§aClick here to update the plugin")));
+        tc.addExtra(" §8< §7Or use the command §c/maintenance forceupdate");
+        ((BungeeSenderInfo) sender).sendMessage(tc);
+    }
+
+    @Override
+    public List<String> getServersCompletion(final String s) {
+        final List<String> list = new ArrayList<>();
+        for (final Map.Entry<String, ServerInfo> entry : plugin.getProxy().getServers().entrySet()) {
+            final String serverName = entry.getValue().getName();
+            if (entry.getKey().toLowerCase().startsWith(s) && !plugin.getSettingsProxy().getMaintenanceServers().contains(serverName)) {
+                list.add(serverName);
+            }
+        }
+        return list;
+    }
+
+    @Override
+    public void sendDumpMessage(final SenderInfo sender, final String url) {
+        final BungeeSenderInfo bungeeSender = ((BungeeSenderInfo) sender);
+        final TextComponent clickText = new TextComponent(plugin.getPrefix() + "§7Click here to copy the link");
+        clickText.setClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, url));
+        clickText.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText("§aClick here to copy the link")));
+        bungeeSender.sendMessage(clickText);
+    }
+
+    @Override
+    public List<String> getPlayersCompletion() {
+        final List<String> list = new ArrayList<>();
+        for (final ProxiedPlayer p : plugin.getProxy().getPlayers()) {
+            list.add(p.getName());
+        }
+        return list;
+    }
+}
@@ -0,0 +1,48 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.command;
+
+import eu.kennytv.maintenance.bungee.util.BungeeSenderInfo;
+import eu.kennytv.maintenance.core.command.MaintenanceCommand;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.plugin.Command;
+import net.md_5.bungee.api.plugin.TabExecutor;
+
+public final class MaintenanceBungeeCommandBase extends Command implements TabExecutor {
+    private final MaintenanceCommand command;
+
+    public MaintenanceBungeeCommandBase(final MaintenanceCommand command) {
+        super("maintenance", "maintenance.command", "maintenancebungee", "mt");
+        this.command = command;
+    }
+
+    @Override
+    public boolean hasPermission(final CommandSender sender) {
+        return sender.hasPermission("maintenance.admin") || sender.hasPermission("maintenance.command");
+    }
+
+    @Override
+    public void execute(final CommandSender sender, final String[] args) {
+        command.execute(new BungeeSenderInfo(sender), args);
+    }
+
+    @Override
+    public Iterable<String> onTabComplete(final CommandSender sender, final String[] args) {
+        return command.getSuggestions(new BungeeSenderInfo(sender), args);
+    }
+}
@@ -0,0 +1,66 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.listener;
+
+import eu.kennytv.maintenance.bungee.MaintenanceBungeePlugin;
+import eu.kennytv.maintenance.bungee.util.ComponentUtil;
+import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import net.md_5.bungee.api.ServerPing;
+import net.md_5.bungee.api.event.ProxyPingEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+
+public final class ProxyPingListener implements Listener {
+    private final MaintenanceBungeePlugin plugin;
+    private final SettingsProxy settings;
+
+    public ProxyPingListener(final MaintenanceBungeePlugin plugin, final SettingsProxy settings) {
+        this.plugin = plugin;
+        this.settings = settings;
+    }
+
+    @EventHandler(priority = 80)
+    public void proxyPing(final ProxyPingEvent event) {
+        if (!settings.isMaintenance() || !settings.isEnablePingMessages()) return;
+
+        final ServerPing ping = event.getResponse();
+        ServerPing.Players players = ping.getPlayers();
+        if (players == null) {
+            ping.setPlayers(players = new ServerPing.Players(0, 0, null));
+        }
+
+        if (settings.hasCustomPlayerCountMessage()) {
+            ping.setVersion(new ServerPing.Protocol(settings.getPlayerCountMessage()
+                    .replace("%ONLINE%", Integer.toString(players.getOnline()))
+                    .replace("%MAX%", Integer.toString(players.getMax())), 1));
+        }
+
+        ping.setDescriptionComponent(ComponentUtil.toBadComponents(settings.getRandomPingMessage()));
+
+        final String[] lines = settings.getPlayerCountHoverLines();
+        final ServerPing.PlayerInfo[] samplePlayers = new ServerPing.PlayerInfo[lines.length];
+        for (int i = 0; i < lines.length; i++) {
+            samplePlayers[i] = new ServerPing.PlayerInfo(lines[i], "");
+        }
+        players.setSample(samplePlayers);
+
+        if (settings.hasCustomIcon() && plugin.getFavicon() != null) {
+            ping.setFavicon(plugin.getFavicon());
+        }
+    }
+}
@@ -0,0 +1,119 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.listener;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.bungee.MaintenanceBungeePlugin;
+import eu.kennytv.maintenance.bungee.util.BungeeSenderInfo;
+import eu.kennytv.maintenance.bungee.util.BungeeServer;
+import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import eu.kennytv.maintenance.core.proxy.listener.ProxyJoinListenerBase;
+import eu.kennytv.maintenance.core.proxy.util.ServerConnectResult;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.ServerConnectEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+import net.md_5.bungee.event.EventPriority;
+
+public final class ServerConnectListener extends ProxyJoinListenerBase implements Listener {
+    private final MaintenanceBungeePlugin plugin;
+
+    public ServerConnectListener(final MaintenanceBungeePlugin plugin, final SettingsProxy settings) {
+        super(plugin, settings);
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void initialServerConnect(final ServerConnectEvent event) {
+        // Global maintenance check
+        if (event.isCancelled() || event.getReason() != ServerConnectEvent.Reason.JOIN_PROXY) return;
+
+        final BungeeSenderInfo player = new BungeeSenderInfo(event.getPlayer());
+        if (plugin.isDebug()) {
+            plugin.getLogger().info("Join permission check for " + event.getPlayer().getName()
+                    + " - Permission: " + player.hasMaintenancePermission("bypass") + ", whitelist: " + settings.isWhitelisted(player.getUuid()));
+        }
+
+        if (shouldKick(player)) {
+            final Server waitingServer = shouldConnectToWaitingServer(player);
+            if (waitingServer != null) {
+                event.setTarget(((BungeeServer) waitingServer).getServer());
+                player.send(settings.getMessage("sentToWaitingServer"));
+
+                if (plugin.isDebug()) {
+                    plugin.getLogger().info("Join to waiting server for " + event.getPlayer().getName());
+                }
+                return;
+            }
+
+            event.setCancelled(true);
+
+            player.disconnect(settings.getKickMessage());
+            if (settings.isJoinNotifications()) {
+                broadcastJoinNotification(player.getName());
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void serverConnect(final ServerConnectEvent event) {
+        // Server specific maintenance check
+        if (event.isCancelled()) return;
+
+        final ProxiedPlayer proxiedPlayer = event.getPlayer();
+        final boolean normalServerConnect = event.getReason() != ServerConnectEvent.Reason.JOIN_PROXY && event.getReason() != ServerConnectEvent.Reason.KICK_REDIRECT
+                && event.getReason() != ServerConnectEvent.Reason.LOBBY_FALLBACK && event.getReason() != ServerConnectEvent.Reason.SERVER_DOWN_REDIRECT;
+        final BungeeSenderInfo player = new BungeeSenderInfo(proxiedPlayer);
+        final ServerConnectResult connectResult = serverConnect(player, new BungeeServer(event.getTarget()), normalServerConnect);
+        if (plugin.isDebug()) {
+            plugin.getLogger().info("Connectresult for " + player.getName() + " to " + event.getTarget().getName() + ": " + connectResult);
+        }
+
+        if (connectResult.isCancelled()) {
+            event.setCancelled(true);
+
+            // Player has no server to connect to
+            if (proxiedPlayer.getServer() == null) {
+                player.disconnect(settings.getKickMessage());
+            }
+        } else if (connectResult.getTarget() != null) {
+            event.setTarget(((BungeeServer) connectResult.getTarget()).getServer());
+        }
+    }
+
+    @Override
+    protected void broadcastJoinNotification(final String name) {
+        sendJoinMessage(ProxyServer.getInstance().getPlayers(), name);
+    }
+
+    @Override
+    protected void broadcastJoinNotification(final String name, final Server server) {
+        sendJoinMessage(((BungeeServer) server).getServer().getPlayers(), name);
+    }
+
+    private void sendJoinMessage(final Iterable<ProxiedPlayer> players, final String name) {
+        final Component component = settings.getMessage("joinNotification", "%PLAYER%", name);
+        for (final ProxiedPlayer player : players) {
+            if (plugin.hasPermission(player, "joinnotification")) {
+                plugin.audiences().player(player).sendMessage(component);
+            }
+        }
+    }
+}
@@ -0,0 +1,272 @@
+package eu.kennytv.maintenance.bungee.metrics;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.config.Configuration;
+import net.md_5.bungee.config.ConfigurationProvider;
+import net.md_5.bungee.config.YamlConfiguration;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+
+public final class MetricsLite {
+
+    public static final int B_STATS_VERSION = 1;
+    private static final int PLUGIN_ID = 742;
+    private static final String URL = "https://bStats.org/submitData/bungeecord";
+    private final Plugin plugin;
+    private boolean enabled;
+    private String serverUUID;
+    private boolean logFailedRequests;
+    private static boolean logSentData;
+    private static boolean logResponseStatusText;
+    private static final List<Object> knownMetricsInstances = new ArrayList<>();
+
+    public MetricsLite(final Plugin plugin) {
+        this.plugin = plugin;
+
+        try {
+            loadConfig();
+        } catch (final IOException e) {
+            plugin.getLogger().log(Level.WARNING, "Failed to load bStats config!", e);
+            return;
+        }
+
+        if (!enabled) {
+            return;
+        }
+
+        final Class<?> usedMetricsClass = getFirstBStatsClass();
+        if (usedMetricsClass == null) {
+            return;
+        }
+        if (usedMetricsClass == getClass()) {
+            linkMetrics(this);
+            startSubmitting();
+        } else {
+            try {
+                usedMetricsClass.getMethod("linkMetrics", Object.class).invoke(null, this);
+            } catch (final NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                if (logFailedRequests) {
+                    plugin.getLogger().log(Level.WARNING, "Failed to link to first metrics class " + usedMetricsClass.getName() + "!", e);
+                }
+            }
+        }
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public static void linkMetrics(final Object metrics) {
+        knownMetricsInstances.add(metrics);
+    }
+
+    public JsonObject getPluginData() {
+        final JsonObject data = new JsonObject();
+
+        //final String pluginName = plugin.getDescription().getName();
+        final String pluginName = "MaintenanceBungee"; // I cut off the suffix, not sure how bStats would like the name change
+        final String pluginVersion = plugin.getDescription().getVersion();
+
+        data.addProperty("pluginName", pluginName);
+        data.addProperty("id", PLUGIN_ID);
+        data.addProperty("pluginVersion", pluginVersion);
+
+        final JsonArray customCharts = new JsonArray();
+        data.add("customCharts", customCharts);
+
+        return data;
+    }
+
+    private void startSubmitting() {
+        plugin.getProxy().getScheduler().schedule(plugin, this::submitData, 2, 30, TimeUnit.MINUTES);
+    }
+
+    private JsonObject getServerData() {
+        final int playerAmount = Math.min(plugin.getProxy().getOnlineCount(), 500);
+        final int onlineMode = plugin.getProxy().getConfig().isOnlineMode() ? 1 : 0;
+        final String bungeecordVersion = plugin.getProxy().getVersion();
+        final int managedServers = plugin.getProxy().getServers().size();
+
+        final String javaVersion = System.getProperty("java.version");
+        final String osName = System.getProperty("os.name");
+        final String osArch = System.getProperty("os.arch");
+        final String osVersion = System.getProperty("os.version");
+        final int coreCount = Runtime.getRuntime().availableProcessors();
+
+        final JsonObject data = new JsonObject();
+
+        data.addProperty("serverUUID", serverUUID);
+
+        data.addProperty("playerAmount", playerAmount);
+        data.addProperty("managedServers", managedServers);
+        data.addProperty("onlineMode", onlineMode);
+        data.addProperty("bungeecordVersion", bungeecordVersion);
+
+        data.addProperty("javaVersion", javaVersion);
+        data.addProperty("osName", osName);
+        data.addProperty("osArch", osArch);
+        data.addProperty("osVersion", osVersion);
+        data.addProperty("coreCount", coreCount);
+
+        return data;
+    }
+
+    private void submitData() {
+        final JsonObject data = getServerData();
+
+        final JsonArray pluginData = new JsonArray();
+        for (final Object metrics : knownMetricsInstances) {
+            try {
+                final Object plugin = metrics.getClass().getMethod("getPluginData").invoke(metrics);
+                if (plugin instanceof JsonObject) {
+                    pluginData.add((JsonObject) plugin);
+                }
+            } catch (final NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) {
+            }
+        }
+
+        data.add("plugins", pluginData);
+
+        try {
+            sendData(plugin, data);
+        } catch (final Exception e) {
+            if (logFailedRequests) {
+                plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats!", e);
+            }
+        }
+    }
+
+    private void loadConfig() throws IOException {
+        final File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+        bStatsFolder.mkdirs();
+        final File configFile = new File(bStatsFolder, "config.yml");
+        if (!configFile.exists()) {
+            writeFile(configFile,
+                    "#bStats collects some data for plugin authors like how many servers are using their plugins.",
+                    "#To honor their work, you should not disable it.",
+                    "#This has nearly no effect on the server performance!",
+                    "#Check out https://bStats.org/ to learn more :)",
+                    "enabled: true",
+                    "serverUuid: \"" + UUID.randomUUID() + "\"",
+                    "logFailedRequests: false",
+                    "logSentData: false",
+                    "logResponseStatusText: false");
+        }
+
+        final Configuration configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
+
+        enabled = configuration.getBoolean("enabled", true);
+        serverUUID = configuration.getString("serverUuid");
+        logFailedRequests = configuration.getBoolean("logFailedRequests", false);
+        logSentData = configuration.getBoolean("logSentData", false);
+        logResponseStatusText = configuration.getBoolean("logResponseStatusText", false);
+    }
+
+    private Class<?> getFirstBStatsClass() {
+        final Path configPath = plugin.getDataFolder().toPath().getParent().resolve("bStats");
+        configPath.toFile().mkdirs();
+        final File tempFile = new File(configPath.toFile(), "temp.txt");
+
+        try {
+            final String className = readFile(tempFile);
+            if (className != null) {
+                try {
+                    return Class.forName(className);
+                } catch (final ClassNotFoundException ignored) {
+                }
+            }
+            writeFile(tempFile, getClass().getName());
+            return getClass();
+        } catch (final IOException e) {
+            if (logFailedRequests) {
+                plugin.getLogger().log(Level.WARNING, "Failed to get first bStats class!", e);
+            }
+            return null;
+        }
+    }
+
+    private String readFile(final File file) throws IOException {
+        if (!file.exists()) {
+            return null;
+        }
+        try (final BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
+            return bufferedReader.readLine();
+        }
+    }
+
+    private void writeFile(final File file, final String... lines) throws IOException {
+        if (!file.exists()) {
+            file.createNewFile();
+        }
+        try (final BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file))) {
+            for (final String line : lines) {
+                bufferedWriter.write(line);
+                bufferedWriter.newLine();
+            }
+        }
+    }
+
+    private static void sendData(final Plugin plugin, final JsonObject data) throws Exception {
+        if (data == null) {
+            throw new IllegalArgumentException("Data cannot be null");
+        }
+        if (logSentData) {
+            plugin.getLogger().info("Sending data to bStats: " + data);
+        }
+
+        final HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
+
+        final byte[] compressedData = compress(data.toString());
+
+        connection.setRequestMethod("POST");
+        connection.addRequestProperty("Accept", "application/json");
+        connection.addRequestProperty("Connection", "close");
+        connection.addRequestProperty("Content-Encoding", "gzip");
+        connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+        connection.setRequestProperty("Content-Type", "application/json");
+        connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
+
+        connection.setDoOutput(true);
+        try (final DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+            outputStream.write(compressedData);
+        }
+
+        if (logResponseStatusText) {
+            final StringBuilder builder = new StringBuilder();
+            try (final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                String line;
+                while ((line = bufferedReader.readLine()) != null) {
+                    builder.append(line);
+                }
+            }
+            plugin.getLogger().info("Sent data to bStats and received response: " + builder);
+        } else {
+            connection.getInputStream().close();
+        }
+    }
+
+    private static byte[] compress(final String str) throws IOException {
+        if (str == null) {
+            return null;
+        }
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try (final GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+            gzip.write(str.getBytes(StandardCharsets.UTF_8));
+        }
+        return outputStream.toByteArray();
+    }
+
+}
@@ -0,0 +1,85 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.util;
+
+import eu.kennytv.maintenance.api.MaintenanceProvider;
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.bungee.MaintenanceBungeePlugin;
+import eu.kennytv.maintenance.core.proxy.util.ProxySenderInfo;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.Connection;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+
+import java.util.UUID;
+
+public final class BungeeSenderInfo implements ProxySenderInfo {
+    private final CommandSender sender;
+
+    public BungeeSenderInfo(final CommandSender sender) {
+        this.sender = sender;
+    }
+
+    @Override
+    public UUID getUuid() {
+        return sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null;
+    }
+
+    @Override
+    public String getName() {
+        return sender.getName();
+    }
+
+    @Override
+    public boolean hasPermission(final String permission) {
+        return sender.hasPermission(permission);
+    }
+
+    @Override
+    @Deprecated
+    public void sendMessage(final String message) {
+        sender.sendMessage(message);
+    }
+
+    @Override
+    public void send(final Component component) {
+        ((MaintenanceBungeePlugin) MaintenanceProvider.get()).audiences().sender(sender).sendMessage(component);
+    }
+
+    @Override
+    public boolean isPlayer() {
+        return sender instanceof ProxiedPlayer;
+    }
+
+    public void sendMessage(final TextComponent textComponent) {
+        sender.sendMessage(textComponent);
+    }
+
+    @Override
+    public boolean canAccess(final Server server) {
+        return ((BungeeServer) server).getServer().canAccess(sender);
+    }
+
+    @Override
+    public void disconnect(final Component component) {
+        if (sender instanceof Connection) {
+            ((Connection) sender).disconnect(ComponentUtil.toBadComponent(component));
+        }
+    }
+}
@@ -0,0 +1,59 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.util;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+
+public final class BungeeServer implements Server {
+    private final ServerInfo server;
+
+    public BungeeServer(final ServerInfo server) {
+        this.server = server;
+    }
+
+    @Override
+    public String getName() {
+        return server.getName();
+    }
+
+    @Override
+    public boolean hasPlayers() {
+        return !server.getPlayers().isEmpty();
+    }
+
+    @Override
+    public void broadcast(final Component component) {
+        final BaseComponent[] components = ComponentUtil.toBadComponent(component);
+        for (final ProxiedPlayer player : server.getPlayers()) {
+            player.sendMessage(components);
+        }
+    }
+
+    @Override
+    public boolean isRegisteredServer() {
+        return true;
+    }
+
+    public ServerInfo getServer() {
+        return server;
+    }
+}
@@ -0,0 +1,34 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.util;
+
+import eu.kennytv.maintenance.core.util.Task;
+import net.md_5.bungee.api.ProxyServer;
+
+public final class BungeeTask implements Task {
+    private final int id;
+
+    public BungeeTask(final int id) {
+        this.id = id;
+    }
+
+    @Override
+    public void cancel() {
+        ProxyServer.getInstance().getScheduler().cancel(id);
+    }
+}
@@ -0,0 +1,35 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.bungee.util;
+
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.chat.ComponentSerializer;
+
+public final class ComponentUtil {
+
+    public static BaseComponent[] toBadComponent(final Component component) {
+        return ComponentSerializer.parse(GsonComponentSerializer.gson().serialize(component));
+    }
+
+    public static BaseComponent toBadComponents(final Component component) {
+        return new TextComponent(ComponentSerializer.parse(GsonComponentSerializer.gson().serialize(component)));
+    }
+}
@@ -0,0 +1,7 @@
+name: Maintenance
+version: ${version}
+main: eu.kennytv.maintenance.bungee.MaintenanceBungeeBase
+author: kennytv
+description: ${description}
+softDepends: [ServerListPlus, LuckPerms]
+website: https://www.spigotmc.org/resources/maintenance.40699/
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -28,17 +28,16 @@ import eu.kennytv.maintenance.core.proxy.runnable.SingleMaintenanceRunnable;
 import eu.kennytv.maintenance.core.proxy.runnable.SingleMaintenanceScheduleRunnable;
 import eu.kennytv.maintenance.core.proxy.util.ProfileLookup;
 import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
-import eu.kennytv.maintenance.core.util.RateLimitedException;
 import eu.kennytv.maintenance.core.util.SenderInfo;
 import eu.kennytv.maintenance.core.util.ServerType;
 import eu.kennytv.maintenance.core.util.Task;
+import org.jetbrains.annotations.Nullable;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
-import java.nio.charset.StandardCharsets;
-import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -46,8 +45,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
-import org.jetbrains.annotations.Blocking;
-import org.jetbrains.annotations.Nullable;
+import java.util.concurrent.TimeUnit;

 /**
 * @author kennytv
@@ -85,23 +83,11 @@ public abstract class MaintenanceProxyPlugin extends MaintenancePlugin implement
    @Override
    public boolean setMaintenanceToServer(final Server server, final boolean maintenance) {
        if (maintenance) {
-            if (!settingsProxy.addMaintenanceServer(server.getName())) {
-                return false;
-            }
-        } else if (!settingsProxy.removeMaintenanceServer(server.getName())) {
-            return false;
+            if (!settingsProxy.addMaintenanceServer(server.getName())) return false;
+        } else {
+            if (!settingsProxy.removeMaintenanceServer(server.getName())) return false;
        }
-
        serverActions(server, maintenance);
-
-        for (final String command : (maintenance ? settingsProxy.getCommandsOnMaintenanceEnable(server) : settingsProxy.getCommandsOnMaintenanceDisable(server))) {
-            try {
-                executeConsoleCommand(command.replace("%SERVER%", server.getName()));
-            } catch (final Exception e) {
-                getLogger().severe("Error while executing extra maintenance " + (maintenance ? "enable" : "disable") + " command: " + command);
-                e.printStackTrace();
-            }
-        }
        return true;
    }

@@ -145,15 +131,15 @@ public abstract class MaintenanceProxyPlugin extends MaintenancePlugin implement
        }
    }

-    public MaintenanceRunnableBase startSingleMaintenanceRunnable(final Server server, final Duration duration, final boolean enable) {
-        final MaintenanceRunnableBase runnable = new SingleMaintenanceRunnable(this, settingsProxy, (int) duration.getSeconds(), enable, server);
+    public MaintenanceRunnableBase startSingleMaintenanceRunnable(final Server server, final long duration, final TimeUnit unit, final boolean enable) {
+        final MaintenanceRunnableBase runnable = new SingleMaintenanceRunnable(this, settingsProxy, (int) unit.toSeconds(duration), enable, server);
        serverTasks.put(server.getName(), runnable.getTask());
        return runnable;
    }

-    public MaintenanceRunnableBase scheduleSingleMaintenanceRunnable(final Server server, final Duration enableIn, final Duration maintenanceDuration) {
+    public MaintenanceRunnableBase scheduleSingleMaintenanceRunnable(final Server server, final long duration, final long maintenanceDuration, final TimeUnit unit) {
        final MaintenanceRunnableBase runnable = new SingleMaintenanceScheduleRunnable(this, settingsProxy,
-                (int) enableIn.getSeconds(), (int) maintenanceDuration.getSeconds(), server);
+                (int) unit.toSeconds(duration), (int) unit.toSeconds(maintenanceDuration), server);
        serverTasks.put(server.getName(), runnable.getTask());
        return runnable;
    }
@@ -189,66 +175,9 @@ public abstract class MaintenanceProxyPlugin extends MaintenancePlugin implement
        kickPlayersFromProxy();
    }

-    @Blocking
-    @Nullable
    protected ProfileLookup doUUIDLookup(final String name) throws IOException {
-        ProfileLookup profileLookup;
-        try {
-            profileLookup = doUUIDLookupMojangAPI(name);
-        } catch (RateLimitedException e) {
-            // Use fallback API if rate limit is reached
-            profileLookup = doUUIDLookupAshconAPI(name);
-        }
-
-        if (settingsProxy.isFallbackToOfflineUUID() && profileLookup == null) {
-            // Use offline uuid
-            return new ProfileLookup(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(StandardCharsets.UTF_8)), name);
-        }
-
-        return profileLookup;
-    }
-
-    /**
-     * Official Mojang API
-     */
-    @Nullable
-    private ProfileLookup doUUIDLookupMojangAPI(final String name) throws IOException {
-        final URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + name);
-        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-        connection.setRequestMethod("GET");
-
-        int status = connection.getResponseCode();
-        if (status == 429) {
-            throw new RateLimitedException();
-        }
-        if (status == 404) {
-            // Return null if profile not found
-            return null;
-        }
-
-        try (final InputStream in = connection.getInputStream()) {
-            final String output = CharStreams.toString(new InputStreamReader(in));
-            final JsonObject json = GSON.fromJson(output, JsonObject.class);
-
-            final UUID uuid = fromStringUUIDWithoutDashes(json.getAsJsonPrimitive("id").getAsString());
-            final String username = json.getAsJsonPrimitive("name").getAsString();
-            return new ProfileLookup(uuid, username);
-        }
-    }
-
-    /**
-     * Fallback API (Ashcon API)
-     */
-    @Nullable
-    private ProfileLookup doUUIDLookupAshconAPI(final String name) throws IOException {
        final URL url = new URL("https://api.ashcon.app/mojang/v2/user/" + name);
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-
-        if (connection.getResponseCode() == 403) {
-            // Return null if profile not found
-            return null;
-        }
-
        try (final InputStream in = connection.getInputStream()) {
            final String output = CharStreams.toString(new InputStreamReader(in));
            final JsonObject json = GSON.fromJson(output, JsonObject.class);
@@ -259,14 +188,6 @@ public abstract class MaintenanceProxyPlugin extends MaintenancePlugin implement
        }
    }

-    private UUID fromStringUUIDWithoutDashes(String undashedUUID) {
-        return UUID.fromString(
-                undashedUUID.substring(0, 8) + "-" + undashedUUID.substring(8, 12) + "-" +
-                        undashedUUID.substring(12, 16) + "-" + undashedUUID.substring(16, 20) + "-" +
-                        undashedUUID.substring(20, 32)
-        );
-    }
-
    public SettingsProxy getSettingsProxy() {
        return settingsProxy;
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -27,11 +27,8 @@ import org.jetbrains.annotations.Nullable;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Locale;
-import java.util.Map;
 import java.util.Set;

 public final class SettingsProxy extends Settings {
@@ -39,10 +36,7 @@ public final class SettingsProxy extends Settings {
    private Set<String> maintenanceServers;
    private List<String> fallbackServers;
    private String waitingServer;
-    private boolean fallbackToOfflineUUID;

-    private Map<String, List<String>> commandsOnMaintenanceEnable;
-    private Map<String, List<String>> commandsOnMaintenanceDisable;
    private String mySQLTable;
    private String serverTable;
    private String maintenanceQuery;
@@ -98,25 +92,12 @@ public final class SettingsProxy extends Settings {
        }

        final Object fallback = config.getObject("fallback");
-        fallbackServers = fallback instanceof String ? Collections.singletonList((String) fallback) : config.getStringList("fallback", Collections.emptyList());
+        fallbackServers = fallback instanceof String ? Collections.singletonList((String) fallback) : config.getStringList("fallback");

        waitingServer = config.getString("waiting-server", "");
        if (waitingServer.isEmpty() || waitingServer.equalsIgnoreCase("none")) {
            waitingServer = null;
        }
-        fallbackToOfflineUUID = config.getBoolean("fallback-to-offline-uuid", false);
-
-        commandsOnMaintenanceEnable = new HashMap<>();
-        final ConfigSection enableCommandsSection = config.getSection("commands-on-single-maintenance-enable");
-        for (final String key : enableCommandsSection.getKeys()) {
-            commandsOnMaintenanceEnable.put(key.toLowerCase(Locale.ROOT), enableCommandsSection.getStringList(key));
-        }
-
-        commandsOnMaintenanceDisable = new HashMap<>();
-        final ConfigSection disableCommandsSection = config.getSection("commands-on-single-maintenance-disable");
-        for (final String key : disableCommandsSection.getKeys()) {
-            commandsOnMaintenanceDisable.put(key.toLowerCase(Locale.ROOT), disableCommandsSection.getStringList(key));
-        }

        if (hasMySQL()) {
            maintenance = loadMaintenance();
@@ -170,20 +151,20 @@ public final class SettingsProxy extends Settings {
    }

    public Component getServerKickMessage(final String server) {
-        String message = getLanguageStringOrNull("singleMaintenanceKicks." + server, "%SERVER%", server);
+        Component message = getMessageOrNull("singleMaintenanceKicks." + server, "%SERVER%", server);
        if (message == null) {
-            message = getLanguageString("singleMaintenanceKick", "%SERVER%", server);
+            message = getMessage("singleMaintenanceKick", "%SERVER%", server);
        }
-        return parse(plugin.replacePingVariables(message));
+        return plugin.replacePingVariables(message);
    }

    // Full = being kicked from the proxy, not just a proxied server
    public Component getFullServerKickMessage(final String server) {
-        String message = getLanguageStringOrNull("singleMaintenanceKicksComplete." + server, "%SERVER%", server);
+        Component message = getMessageOrNull("singleMaintenanceKicksComplete." + server, "%SERVER%", server);
        if (message == null) {
-            message = getLanguageString("singleMaintenanceKickComplete", "%SERVER%", server);
+            message = getMessage("singleMaintenanceKickComplete", "%SERVER%", server);
        }
-        return parse(plugin.replacePingVariables(message));
+        return plugin.replacePingVariables(message);
    }

    public boolean hasMySQL() {
@@ -281,28 +262,6 @@ public final class SettingsProxy extends Settings {
        return waitingServer;
    }

-    public boolean isFallbackToOfflineUUID() {
-        return fallbackToOfflineUUID;
-    }
-
-    public List<String> getCommandsOnMaintenanceEnable(final Server server) {
-        final List<String> enableCommands = commandsOnMaintenanceEnable.getOrDefault("all", new ArrayList<>());
-        final List<String> serverEnableCommands = commandsOnMaintenanceEnable.get(server.getName().toLowerCase(Locale.ROOT));
-        if (serverEnableCommands != null) {
-            enableCommands.addAll(serverEnableCommands);
-        }
-        return enableCommands;
-    }
-
-    public List<String> getCommandsOnMaintenanceDisable(final Server server) {
-        final List<String> disableCommands = commandsOnMaintenanceDisable.getOrDefault("all", new ArrayList<>());
-        final List<String> serverDisableCommands = commandsOnMaintenanceDisable.get(server.getName().toLowerCase(Locale.ROOT));
-        if (serverDisableCommands != null) {
-            disableCommands.addAll(serverDisableCommands);
-        }
-        return disableCommands;
-    }
-
    @Nullable
    MySQL getMySQL() {
        return mySQL;
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -60,7 +60,7 @@ public final class AbortSingleTimerCommand extends ProxyCommandInfo {
            }

            plugin.cancelSingleTask(server);
-            sender.send(getMessage("singleTimerCancelled", "%SERVER%", server.getName()));
+            sender.send(getMessage("singleTimerCancelled"));
        } else
            sender.send(getHelpMessage());
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,9 +22,10 @@ import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
 import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import java.time.Duration;
+
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.TimeUnit;

 public final class SingleEndtimerCommand extends ProxyCommandInfo {

@@ -41,9 +42,7 @@ public final class SingleEndtimerCommand extends ProxyCommandInfo {
    public void execute(final SenderInfo sender, final String[] args) {
        if (args.length == 2) {
            if (checkPermission(sender, "timer")) return;
-
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-            if (duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
                sender.send(getHelpMessage());
                return;
            }
@@ -52,13 +51,11 @@ public final class SingleEndtimerCommand extends ProxyCommandInfo {
                return;
            }

-            plugin.startMaintenanceRunnable(duration, false);
+            plugin.startMaintenanceRunnable(Integer.parseInt(args[1]), TimeUnit.MINUTES, false);
            sender.send(getMessage("endtimerStarted", "%TIME%", plugin.getRunnable().getTime()));
        } else if (args.length == 3) {
            if (checkPermission(sender, "singleserver.timer")) return;
-
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[2], false);
-            if (duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[2], false)) {
                sender.send(getHelpMessage());
                return;
            }
@@ -70,12 +67,8 @@ public final class SingleEndtimerCommand extends ProxyCommandInfo {
                return;
            }

-            final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, duration, false);
-            sender.send(getMessage(
-                    "singleEndtimerStarted",
-                    "%TIME%", runnable.getTime(),
-                    "%SERVER%", server.getName()
-            ));
+            final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, Integer.parseInt(args[2]), TimeUnit.MINUTES, false);
+            sender.send(getMessage("endtimerStarted", "%TIME%", runnable.getTime()));
        } else {
            sender.send(getHelpMessage());
        }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,9 +22,10 @@ import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
 import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import java.time.Duration;
+
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.TimeUnit;

 public final class SingleScheduleTimerCommand extends ProxyCommandInfo {

@@ -41,10 +42,8 @@ public final class SingleScheduleTimerCommand extends ProxyCommandInfo {
    public void execute(final SenderInfo sender, final String[] args) {
        if (args.length == 3) {
            if (checkPermission(sender, "timer")) return;
-
-            final Duration enableIn = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[2], false);
-            if (enableIn == null || duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[1])
+                    || plugin.getCommandManager().checkTimerArgs(sender, args[2], false)) {
                sender.send(getHelpMessage());
                return;
            }
@@ -53,18 +52,12 @@ public final class SingleScheduleTimerCommand extends ProxyCommandInfo {
                return;
            }

-            plugin.scheduleMaintenanceRunnable(duration, enableIn);
-            sender.send(getMessage(
-                    "scheduletimerStarted",
-                    "%TIME%", plugin.getRunnable().getTime(),
-                    "%DURATION%", plugin.getFormattedTime((int) duration.getSeconds())
-            ));
+            plugin.scheduleMaintenanceRunnable(Integer.parseInt(args[1]), Integer.parseInt(args[2]), TimeUnit.MINUTES);
+            sender.send(getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime()));
        } else if (args.length == 4) {
            if (checkPermission(sender, "singleserver.timer")) return;
-
-            final Duration enableIn = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[2], false);
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[3], false);
-            if (enableIn == null || duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[2], false)
+                    || plugin.getCommandManager().checkTimerArgs(sender, args[3], false)) {
                sender.send(getHelpMessage());
                return;
            }
@@ -76,13 +69,8 @@ public final class SingleScheduleTimerCommand extends ProxyCommandInfo {
                return;
            }

-            final MaintenanceRunnableBase runnable = plugin.scheduleSingleMaintenanceRunnable(server, enableIn, duration);
-            sender.send(getMessage(
-                    "singleScheduletimerStarted",
-                    "%TIME%", runnable.getTime(),
-                    "%DURATION%", plugin.getFormattedTime((int) duration.getSeconds()),
-                    "%SERVER%", server.getName()
-            ));
+            final MaintenanceRunnableBase runnable = plugin.scheduleSingleMaintenanceRunnable(server, Integer.parseInt(args[2]), Integer.parseInt(args[3]), TimeUnit.MINUTES);
+            sender.send(getMessage("starttimerStarted", "%TIME%", runnable.getTime()));
        } else {
            sender.send(getHelpMessage());
        }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,9 +22,10 @@ import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
 import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import java.time.Duration;
+
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.TimeUnit;

 public final class SingleStarttimerCommand extends ProxyCommandInfo {

@@ -41,9 +42,7 @@ public final class SingleStarttimerCommand extends ProxyCommandInfo {
    public void execute(final SenderInfo sender, final String[] args) {
        if (args.length == 2) {
            if (checkPermission(sender, "timer")) return;
-
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-            if (duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
                sender.send(getHelpMessage());
                return;
            }
@@ -52,13 +51,11 @@ public final class SingleStarttimerCommand extends ProxyCommandInfo {
                return;
            }

-            plugin.startMaintenanceRunnable(duration, true);
+            plugin.startMaintenanceRunnable(Integer.parseInt(args[1]), TimeUnit.MINUTES, true);
            sender.send(getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime()));
        } else if (args.length == 3) {
            if (checkPermission(sender, "singleserver.timer")) return;
-
-            final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[2], false);
-            if (duration == null) {
+            if (plugin.getCommandManager().checkTimerArgs(sender, args[2], false)) {
                sender.send(getHelpMessage());
                return;
            }
@@ -70,12 +67,8 @@ public final class SingleStarttimerCommand extends ProxyCommandInfo {
                return;
            }

-            final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, duration, true);
-            sender.send(getMessage(
-                    "singleStarttimerStarted",
-                    "%TIME%", runnable.getTime(),
-                    "%SERVER%", server.getName()
-            ));
+            final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, Integer.parseInt(args[2]), TimeUnit.MINUTES, true);
+            sender.send(getMessage("starttimerStarted", "%TIME%", runnable.getTime()));
        } else {
            sender.send(getHelpMessage());
        }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -31,7 +31,7 @@ import java.util.function.Function;
 public final class LuckPermsProxyHook {

    public static <T> void register(final MaintenanceProxyPlugin plugin, final Function<T, String> function) {
-        LuckPermsProvider.get().getContextManager().registerCalculator(new MaintenanceProxyCalculator<>(plugin, function));
+        LuckPermsProvider.get().getContextManager().registerCalculator(new MaintenanceProxyCalculator<T>(plugin, function));
    }

    public static final class MaintenanceProxyCalculator<T> implements ContextCalculator<T> {
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,26 +22,27 @@ import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import java.time.Duration;
+
+import java.util.concurrent.TimeUnit;

 public final class SingleMaintenanceScheduleRunnable extends SingleMaintenanceRunnable {
-    private final int maintenanceDurationSeconds;
+    private final int maintenanceDuration;

    public SingleMaintenanceScheduleRunnable(final MaintenancePlugin plugin, final Settings settings, final int seconds, final int maintenanceDuration, final Server server) {
        super(plugin, settings, seconds, true, server);
-        this.maintenanceDurationSeconds = maintenanceDuration;
+        this.maintenanceDuration = maintenanceDuration;
    }

    @Override
    protected void finish() {
        super.finish();
-        ((MaintenanceProxyPlugin) plugin).startSingleMaintenanceRunnable(server, Duration.ofSeconds(maintenanceDurationSeconds), false);
+        ((MaintenanceProxyPlugin) plugin).startSingleMaintenanceRunnable(server, maintenanceDuration, TimeUnit.SECONDS, false);
    }

    @Override
    protected Component getStartMessage() {
        return settings.getMessage("singleScheduletimerBroadcast",
                "%SERVER%", server.getName(),
-                "%TIME%", getTime(), "%DURATION%", plugin.getFormattedTime(maintenanceDurationSeconds));
+                "%TIME%", getTime(), "%DURATION%", plugin.getFormattedTime(maintenanceDuration));
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -55,6 +55,11 @@ public final class ProxyOfflineSenderInfo implements ProxySenderInfo {
        return false;
    }

+    @Override
+    @Deprecated
+    public void sendMessage(final String message) {
+    }
+
    @Override
    public void send(final Component component) {
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,17 +1,10 @@
 plugins {
    id("net.kyori.blossom")
-    id("org.jetbrains.gradle.plugin.idea-ext")
 }

-sourceSets {
-    main {
-        blossom {
-            javaSources {
-                property("version", project.version.toString())
-                property("impl_version", "git-Maintenance-${project.version}:${rootProject.latestCommitHash()}")
-            }
-        }
-    }
+blossom {
+    replaceToken("\$VERSION", project.version)
+    replaceToken("\$IMPL_VERSION", "git-Maintenance-${project.version}:${rootProject.latestCommitHash()}")
 }

 dependencies {
@@ -1,37 +0,0 @@
-/*
- * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
- * Copyright (C) 2016-2023 ViaVersion and contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-package eu.kennytv.maintenance.core.util;
-
-public final class MaintenanceVersion {
-
-    public static final String VERSION = "{{ version }}";
-    private static final String IMPLEMENTATION_VERSION = "{{ impl_version }}";
-
-    public static String getVersion() {
-        return VERSION;
-    }
-
-    public static String getImplementationVersion() {
-        return IMPLEMENTATION_VERSION;
-    }
-}
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
 */
 package eu.kennytv.maintenance.core;

+import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
 import com.google.common.io.CharStreams;
 import com.google.gson.Gson;
@@ -37,11 +38,14 @@ import eu.kennytv.maintenance.core.util.ServerType;
 import eu.kennytv.maintenance.core.util.Task;
 import eu.kennytv.maintenance.core.util.Version;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.format.NamedTextColor;
+import org.jetbrains.annotations.Nullable;
+
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -50,31 +54,23 @@ import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
 import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.regex.Pattern;
-import org.jetbrains.annotations.Nullable;

 public abstract class MaintenancePlugin implements Maintenance {
    public static final Gson GSON = new GsonBuilder().create();
-    public static final String HANGAR_URL = "https://hangar.papermc.io/kennytv/Maintenance";
-    private static final Pattern INT_PATTERN = Pattern.compile("[0-9]+");
-    protected final EventManager eventManager;
+    protected final eu.kennytv.maintenance.core.event.EventManager eventManager;
    protected final Version version;
    protected Settings settings;
    protected ServerListPlusHook serverListPlusHook;
    protected MaintenanceRunnable runnable;
    protected MaintenanceCommand commandManager;
-    private final Component prefix;
+    private final String prefix;
    private final ServerType serverType;
    private Version newestVersion;
    private boolean debug;
@@ -82,12 +78,7 @@ public abstract class MaintenancePlugin implements Maintenance {
    protected MaintenancePlugin(final String version, final ServerType serverType) {
        this.version = new Version(version);
        this.serverType = serverType;
-        this.prefix = Component.text()
-                .append(Component.text().content("[").color(NamedTextColor.DARK_GRAY))
-                .append(Component.text().content("Maintenance").color(NamedTextColor.YELLOW))
-                .append(Component.text().content("]").color(NamedTextColor.DARK_GRAY))
-                .append(Component.text(" "))
-                .build();
+        this.prefix = "§8[§eMaintenance" + serverType + "§8] ";
        this.eventManager = new eu.kennytv.maintenance.core.event.EventManager();
        MaintenanceProvider.setMaintenance(this);
    }
@@ -106,7 +97,8 @@ public abstract class MaintenancePlugin implements Maintenance {
            try {
                executeConsoleCommand(command);
            } catch (final Exception e) {
-                getLogger().log(Level.SEVERE, "Error while executing extra maintenance " + (maintenance ? "enable" : "disable") + " command: " + command, e);
+                getLogger().severe("Error while executing extra maintenance " + (maintenance ? "enable" : "disable") + " command: " + command);
+                e.printStackTrace();
            }
        }
    }
@@ -131,24 +123,21 @@ public abstract class MaintenancePlugin implements Maintenance {
        eventManager.callEvent(new MaintenanceChangedEvent(maintenance));
    }

-    public String replacePingVariables(String component) {
-        if (component.contains("%TIMER%")) {
-            component = component.replace("%TIMER%", getTimerMessage());
-        }
-        component = component.replace("%ONLINE%", String.valueOf(getOnlinePlayers()));
-        component = component.replace("%MAX%", String.valueOf(getMaxPlayers()));
-        return component;
+    public Component replacePingVariables(final Component component) {
+        return component.replaceText(builder -> builder.matchLiteral("%TIMER%").replacement(c -> getTimerMessage()))
+                .replaceText(builder -> builder.matchLiteral("%ONLINE%").replacement(c -> Component.text(getOnlinePlayers())))
+                .replaceText(builder -> builder.matchLiteral("%MAX%").replacement(c -> Component.text(getMaxPlayers())));
    }

-    public String getTimerMessage() {
+    public Component getTimerMessage() {
        if (!isTaskRunning()) {
-            return settings.getLanguageString("motdTimerNotRunning");
+            return settings.getMessage("motdTimerNotRunning");
        }

        final int preHours = runnable.getSecondsLeft() / 60;
        final int minutes = preHours % 60;
        final int seconds = runnable.getSecondsLeft() % 60;
-        return settings.getLanguageString("motdTimer",
+        return settings.getMessage("motdTimer",
                "%HOURS%", String.format("%02d", preHours / 60),
                "%MINUTES%", String.format("%02d", minutes),
                "%SECONDS%", String.format("%02d", seconds));
@@ -174,22 +163,22 @@ public abstract class MaintenancePlugin implements Maintenance {
        builder.append(time).append(' ').append(settings.language.getString(time == 1 ? timeUnit : timeUnit + "s"));
    }

-    public void startMaintenanceRunnable(final Duration duration, final boolean enable) {
-        runnable = new MaintenanceRunnable(this, settings, (int) duration.getSeconds(), enable);
+    public void startMaintenanceRunnable(final long duration, final TimeUnit unit, final boolean enable) {
+        runnable = new MaintenanceRunnable(this, settings, (int) unit.toSeconds(duration), enable);
        // Save the endtimer to be able to continue it after a server stop
        if (settings.isSaveEndtimerOnStop() && !runnable.shouldEnable()) {
            settings.setSavedEndtimer(System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(runnable.getSecondsLeft()));
        }
    }

-    public void scheduleMaintenanceRunnable(final Duration enableIn, final Duration maintenanceDuration) {
-        runnable = new MaintenanceScheduleRunnable(this, settings, (int) enableIn.getSeconds(), (int) maintenanceDuration.getSeconds());
+    public void scheduleMaintenanceRunnable(final long duration, final int maintenanceDuration, final TimeUnit unit) {
+        runnable = new MaintenanceScheduleRunnable(this, settings, (int) unit.toSeconds(duration), (int) unit.toSeconds(maintenanceDuration));
    }

    public boolean updateAvailable() {
        try {
            checkNewestVersion();
-            return version.compareTo(newestVersion) < 0;
+            return version.compareTo(newestVersion) == -1;
        } catch (final Exception e) {
            return false;
        }
@@ -209,7 +198,7 @@ public abstract class MaintenancePlugin implements Maintenance {
            setMaintenance(false);
            settings.setSavedEndtimer(0);
        } else {
-            startMaintenanceRunnable(Duration.ofMillis(settings.getSavedEndtimer() - current), false);
+            startMaintenanceRunnable(settings.getSavedEndtimer() - current, TimeUnit.MILLISECONDS, false);
            getLogger().info("The timer has been continued - maintenance will be disabled in: " + getTimerMessage());
        }
    }
@@ -220,48 +209,45 @@ public abstract class MaintenancePlugin implements Maintenance {
            try {
                checkNewestVersion();
            } catch (final Exception e) {
+                getLogger().warning("An error occured during update checking!");
                return;
            }

            final int compare = version.compareTo(newestVersion);
-            if (compare < 0) {
-                getLogger().warning("Newest version available: Version " + newestVersion + ", you're on " + version);
-            } else if (compare > 0) {
+            if (compare == -1) {
+                //TODO mmmmmmmm legacy chat
+                getLogger().info("§cNewest version available: §aVersion " + newestVersion + "§c, you're on §a" + version);
+            } else if (compare == 1) {
                if (version.getTag().equalsIgnoreCase("snapshot")) {
-                    getLogger().info("You're running a development version, please report bugs on the Discord server (https://discord.gg/vGCUzHq) or the GitHub issue tracker (https://github.com/kennytv/Maintenance/issues)");
+                    getLogger().info("§cYou're running a development version, please report bugs on the Discord server (https://discord.gg/vGCUzHq) or the GitHub issue tracker (https://github.com/kennytv/Maintenance/issues)");
                } else {
-                    getLogger().info("You're running a version, that doesn't exist!");
+                    getLogger().info("§cYou're running a version, that doesn't exist! §cN§ai§dc§ee§5!");
                }
            }
        });
    }

-    public boolean installUpdate() throws Exception {
-        // Sponge and Velocity need their own jar
-        final String platformInfix = serverType == ServerType.VELOCITY ? "Velocity-" : serverType == ServerType.SPONGE ? "Sponge-" : "";
-        final String fileName = "Maintenance-" + platformInfix + newestVersion + ".jar";
-        final Path tempFilePath = Paths.get(getPluginFolder() + "Maintenance.tmp");
-        final URLConnection connection = new URL("https://github.com/kennytv/Maintenance/releases/download/" + newestVersion + "/" + fileName).openConnection();
-        try (final BufferedInputStream is = new BufferedInputStream(connection.getInputStream());
-             final BufferedOutputStream os = new BufferedOutputStream(Files.newOutputStream(tempFilePath))) {
-            writeFile(is, os);
-        }
+    public boolean installUpdate() {
+        // Ore sad :(
+        Preconditions.checkArgument(serverType != ServerType.SPONGE);
+        try {
+            final String fileSuffix = serverType == ServerType.VELOCITY ? "Velocity" : "";
+            final URLConnection conn = new URL("https://github.com/kennytv/Maintenance/releases/download/" + newestVersion + "/Maintenance" + fileSuffix + ".jar").openConnection();
+            writeFile(new BufferedInputStream(conn.getInputStream()), new BufferedOutputStream(new FileOutputStream(getPluginFolder() + "Maintenance.tmp")));
+            final File file = new File(getPluginFolder() + "Maintenance.tmp");
+            final long newlength = file.length();
+            if (newlength < 10000) {
+                file.delete();
+                return false;
+            }

-        final File file = tempFilePath.toFile();
-        final long newlength = file.length();
-        if (newlength < 10_000) {
-            // Sanity check the file length
+            writeFile(new FileInputStream(file), new BufferedOutputStream(new FileOutputStream(getPluginFile())));
            file.delete();
+            return true;
+        } catch (final Exception e) {
+            e.printStackTrace();
            return false;
        }
-
-        try (final InputStream is = Files.newInputStream(file.toPath());
-             final BufferedOutputStream os = new BufferedOutputStream(Files.newOutputStream(getPluginFile().toPath()))) {
-            writeFile(is, os);
-        }
-
-        file.delete();
-        return true;
    }

    private void writeFile(final InputStream is, final OutputStream os) throws IOException {
@@ -270,12 +256,13 @@ public abstract class MaintenancePlugin implements Maintenance {
        while ((chunkSize = is.read(chunk)) != -1) {
            os.write(chunk, 0, chunkSize);
        }
+        is.close();
+        os.close();
    }

    private void checkNewestVersion() throws Exception {
-        final URLConnection connection = new URL("https://hangar.papermc.io/api/v1/projects/Maintenance/latestrelease").openConnection();
-        connection.setRequestProperty("User-Agent", "Maintenance/" + getVersion());
-        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+        final HttpURLConnection c = (HttpURLConnection) new URL("https://api.spigotmc.org/legacy/update.php?resource=40699").openConnection();
+        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(c.getInputStream()))) {
            final String newVersionString = reader.readLine();
            final Version newVersion = new Version(newVersionString);
            if (!newVersion.equals(version)) {
@@ -287,7 +274,7 @@ public abstract class MaintenancePlugin implements Maintenance {
    public String pasteDump() {
        final MaintenanceDump dump = new MaintenanceDump(this, settings);
        try {
-            final HttpURLConnection connection = (HttpURLConnection) new URL("https://api.pastes.dev/post").openConnection();
+            final HttpURLConnection connection = (HttpURLConnection) new URL("https://hastebin.com/documents").openConnection();
            connection.setDoOutput(true);
            connection.setRequestMethod("POST");
            connection.setRequestProperty("User-Agent", "Maintenance/" + getVersion());
@@ -298,7 +285,7 @@ public abstract class MaintenancePlugin implements Maintenance {
            }

            if (connection.getResponseCode() == 503) {
-                getLogger().warning("Could not paste dump, pastes.dev down?");
+                getLogger().warning("Could not paste dump, hastebin.com down?");
                return null;
            }

@@ -313,7 +300,8 @@ public abstract class MaintenancePlugin implements Maintenance {
                return jsonOutput.get("key").getAsString();
            }
        } catch (final IOException e) {
-            getLogger().log(Level.WARNING, "Could not paste dump :(", e);
+            getLogger().log(Level.WARNING, "Could not paste dump :(");
+            e.printStackTrace();
            return null;
        }
    }
@@ -361,7 +349,7 @@ public abstract class MaintenancePlugin implements Maintenance {
    }

    public boolean isNumeric(final String string) {
-        return INT_PATTERN.matcher(string).matches();
+        return string.matches("[0-9]+");
    }

    @Override
@@ -412,7 +400,7 @@ public abstract class MaintenancePlugin implements Maintenance {
        return newestVersion;
    }

-    public Component prefix() {
+    public String getPrefix() {
        return prefix;
    }

@@ -442,6 +430,8 @@ public abstract class MaintenancePlugin implements Maintenance {

    public abstract void broadcast(Component component);

+    public abstract void sendUpdateNotification(SenderInfo sender);
+
    public abstract Task startMaintenanceRunnable(Runnable runnable);

    /**
@@ -450,14 +440,14 @@ public abstract class MaintenancePlugin implements Maintenance {
     *
     * @param name name of the player
     */
-    public abstract CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(String name);
+    public abstract void getOfflinePlayer(String name, Consumer<@Nullable SenderInfo> consumer);

-    public abstract CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(UUID uuid);
+    public abstract void getOfflinePlayer(UUID uuid, Consumer<@Nullable SenderInfo> consumer);

    public abstract File getDataFolder();

    @Nullable
-    public InputStream getResource(final String name) {
+    public InputStream getResource(String name) {
        return this.getClass().getClassLoader().getResourceAsStream(name);
    }

@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -23,8 +23,11 @@ import eu.kennytv.maintenance.core.config.ConfigSection;
 import eu.kennytv.maintenance.core.util.ServerType;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.TextComponent;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.TextReplacementConfig;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.minimessage.MiniMessage;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.jetbrains.annotations.Nullable;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -33,37 +36,31 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
 import java.util.Set;
 import java.util.UUID;
-import java.util.logging.Level;
-import org.jetbrains.annotations.Nullable;

 public class Settings implements eu.kennytv.maintenance.api.Settings {
    public static final String NEW_LINE_REPLACEMENT = "<br>";
-    private static final int CONFIG_VERSION = 9;
-    private static final int LANGUAGE_VERSION = 2;
+    private static final int CONFIG_VERSION = 6;
+    private static final int LANGUAGE_VERSION = 1;
    private static final Random RANDOM = new Random();
    protected final MaintenancePlugin plugin;
    private final Map<UUID, String> whitelistedPlayers = new HashMap<>();
    private final String[] unsupportedFields;
    protected boolean maintenance;
    private Set<Integer> broadcastIntervals;
-    private List<String> pingMessages;
-    private List<String> timerSpecificPingMessages;
+    private List<Component> pingMessages;
+    private List<Component> timerSpecificPingMessages;
    private List<String> commandsOnMaintenanceEnable;
    private List<String> commandsOnMaintenanceDisable;
-    private String legacyParsedPlayerCountMessage;
-    private String legacyParsedTimerPlayerCountMessage;
-    private List<String> legacyParsedPlayerCountHoverLines;
-    private List<String> legacyParsedTimerPlayerCountHoverLines;
-    private String prefixString;
+    private Component playerCountMessage;
+    private List<Component> playerCountHoverLines;
+    private Component prefix;
    private String languageName;
    private boolean enablePingMessages;
    private boolean customPlayerCountMessage;
-    private boolean customPlayerCountHoverMessage;
    private boolean customMaintenanceIcon;
    private boolean joinNotifications;
    private boolean updateChecks;
@@ -115,10 +112,11 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        try {
            updateLanguageFile();
        } catch (final IOException e) {
-            plugin.getLogger().log(Level.SEVERE, "Couldn't update language file", e);
+            plugin.getLogger().severe("Couldn't update language file");
+            e.printStackTrace();
        }

-        prefixString = language.getString("prefix");
+        prefix = MiniMessage.miniMessage().deserialize(language.getString("prefix"));

        plugin.getEventManager().callEvent(new MaintenanceReloadedEvent());
    }
@@ -127,7 +125,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        try {
            config.save();
        } catch (final IOException e) {
-            plugin.getLogger().log(Level.SEVERE, "Couldn't save the config file!", e);
+            e.printStackTrace();
        }
    }

@@ -151,7 +149,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        try {
            whitelist.save();
        } catch (final IOException e) {
-            plugin.getLogger().log(Level.SEVERE, "Couldn't save the whitelisted players file!", e);
+            e.printStackTrace();
        }
    }

@@ -176,48 +174,26 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
    private void loadSettings() {
        updateConfig();

-        final ConfigSection pingMessageSection = config.getSection("ping-message");
-        enablePingMessages = pingMessageSection.getBoolean("enabled", true);
-        // Can't store this pre-parsed as components because gradients will break replacements
-        pingMessages = loadPingMessages(pingMessageSection.getStringList("messages"));
-        if (pingMessageSection.getBoolean("enable-timer-specific-messages")) {
-            timerSpecificPingMessages = loadPingMessages(pingMessageSection.getStringList("timer-messages"));
-        } else {
-            timerSpecificPingMessages = null;
+        enablePingMessages = config.getBoolean("enable-pingmessages", true);
+        pingMessages = loadPingMessages("pingmessages");
+        if (config.getBoolean("enable-timerspecific-messages")) {
+            timerSpecificPingMessages = loadPingMessages("timerspecific-pingmessages");
        }
-
        maintenance = config.getBoolean("maintenance-enabled");
        commandsOnMaintenanceEnable = config.getStringList("commands-on-maintenance-enable");
        commandsOnMaintenanceDisable = config.getStringList("commands-on-maintenance-disable");
+        customPlayerCountMessage = config.getBoolean("enable-playercountmessage");
        customMaintenanceIcon = config.getBoolean("custom-maintenance-icon");
        joinNotifications = config.getBoolean("send-join-notification");
        broadcastIntervals = new HashSet<>(config.getIntList("timer-broadcast-for-seconds"));
-
-        // Player count and player list hover messages are only accepted and rendered as legacy chat
        if (plugin.getServerType() != ServerType.SPONGE) {
-            final ConfigSection playerCountMessageSection = config.getSection("player-count-message");
-            customPlayerCountMessage = playerCountMessageSection.getBoolean("enabled");
-            legacyParsedPlayerCountMessage = toLegacy(parse(getConfigMessage(playerCountMessageSection, "message")));
-            if (playerCountMessageSection.getBoolean("enable-timer-specific-message")) {
-                legacyParsedTimerPlayerCountMessage = toLegacy(parse(getConfigMessage(playerCountMessageSection, "timer-message")));
-            } else {
-                legacyParsedTimerPlayerCountMessage = null;
-            }
+            playerCountMessage = getConfigMessage("playercountmessage");
        }

-        final ConfigSection listHoverMessageSection = config.getSection("player-list-hover-message");
-        customPlayerCountHoverMessage = listHoverMessageSection.getBoolean("enabled");
-        legacyParsedPlayerCountHoverLines = new ArrayList<>();
-        for (final String line : listHoverMessageSection.getString("message").split("<br>")) {
-            legacyParsedPlayerCountHoverLines.add(toLegacy(parse(line)));
-        }
-        if (listHoverMessageSection.getBoolean("enable-timer-specific-message")) {
-            legacyParsedTimerPlayerCountHoverLines = new ArrayList<>();
-            for (final String line : listHoverMessageSection.getString("timer-message").split("<br>")) {
-                legacyParsedTimerPlayerCountHoverLines.add(toLegacy(parse(line)));
-            }
-        } else {
-            legacyParsedTimerPlayerCountHoverLines = null;
+        playerCountHoverLines = new ArrayList<>();
+        final String playerHoverMessage = config.getString("playercounthovermessage");
+        for (final String line : playerHoverMessage.split("<br>")) {
+            playerCountHoverLines.add(MiniMessage.miniMessage().deserialize(line));
        }

        languageName = config.getString("language").toLowerCase();
@@ -236,9 +212,9 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        whitelistedPlayers.clear();
        for (final Map.Entry<String, Object> entry : whitelist.getValues().entrySet()) {
            try {
-                whitelistedPlayers.put(UUID.fromString(entry.getKey()), String.valueOf(entry.getValue()));
-            } catch (final IllegalArgumentException e) {
-                plugin.getLogger().warning("Invalid WhitelistedPlayers entry: " + entry.getKey());
+                whitelistedPlayers.put(UUID.fromString(entry.getKey()), (String) entry.getValue());
+            } catch (final Exception e) {
+                plugin.getLogger().warning("invalid WhitelistedPlayers entry: " + entry.getKey());
            }
        }

@@ -249,9 +225,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        // All plugin identifiers were changed to 'Maintenance' ('maintenance' for Sponge and Velocity) in 3.0.5
        String oldDirName = "Maintenance" + plugin.getServerType();
        if (plugin.getServerType() == ServerType.SPONGE || plugin.getServerType() == ServerType.VELOCITY) {
-            oldDirName = oldDirName.toLowerCase(Locale.ROOT);
-        } else if (plugin.getServerType() == ServerType.SPIGOT) {
-            oldDirName = "MaintenanceSpigot";
+            oldDirName = oldDirName.toLowerCase();
        }

        final File oldDir = new File(plugin.getDataFolder().getParentFile(), oldDirName);
@@ -263,7 +237,8 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
            Files.move(oldDir.toPath(), plugin.getDataFolder().toPath());
            plugin.getLogger().info("Moved old " + oldDirName + " to new " + plugin.getDataFolder().getName() + " directory!");
        } catch (final IOException e) {
-            plugin.getLogger().log(Level.SEVERE, "Error while copying " + oldDirName + " to new " + plugin.getDataFolder().getName() + " directory!", e);
+            plugin.getLogger().severe("Error while copying " + oldDirName + " to new " + plugin.getDataFolder().getName() + " directory!");
+            e.printStackTrace();
        }
    }

@@ -273,23 +248,11 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
            plugin.getLogger().info("Updating config to the latest version...");
            if (version < 6) {
                // Legacy text to MiniMessage
-                config.getStringList("pingmessages").replaceAll(this::legacyToMinimessage);
-                config.getStringList("timerspecific-pingmessages").replaceAll(this::legacyToMinimessage);
+                legacyToMinimessage(config.getStringList("pingmessages"));
+                legacyToMinimessage(config.getStringList("timerspecific-pingmessages"));
                config.set("playercounthovermessage", legacyToMinimessage(config.getString("playercounthovermessage")));
                config.set("playercountmessage", legacyToMinimessage(config.getString("playercountmessage")));
            }
-            if (version < 9) {
-                config.move("enable-pingmessages", "ping-message.enabled");
-                config.move("pingmessages", "ping-message.messages");
-                config.move("enable-timerspecific-messages", "ping-message.enable-timer-specific-messages");
-                config.move("timerspecific-pingmessages", "ping-message.timer-messages");
-
-                config.move("enable-playercountmessage", "player-count-message.enabled");
-                config.move("playercountmessage", "player-count-message.message");
-
-                config.move("enable-playercounthovermessage", "player-list-hover-message.enabled");
-                config.move("playercounthovermessage", "player-list-hover-message.message");
-            }

            createFile("config-new.yml", "config.yml");
            final File file = new File(plugin.getDataFolder(), "config-new.yml");
@@ -300,8 +263,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
                e.printStackTrace();
            }

-            config.addMissingFields(tempConfig);
-            config.replaceComments(tempConfig);
+            config.addMissingFields(tempConfig.getValues(), tempConfig.getComments());
            config.set("config-version", CONFIG_VERSION);

            file.delete();
@@ -344,8 +306,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
            file.delete();
        }

-        language.addMissingFields(tempConfig);
-        language.replaceComments(tempConfig);
+        language.addMissingFields(tempConfig.getValues(), tempConfig.getComments());
        tempConfig.clear();

        language.set("language-version", LANGUAGE_VERSION);
@@ -361,24 +322,26 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return serialized.replaceAll("</[a-z_]+>", "");
    }

-    private String getConfigMessage(final ConfigSection section, final String path) {
-        final String s = section.getString(path);
+    private void legacyToMinimessage(final List<String> list) {
+        for (int i = 0; i < list.size(); i++) {
+            list.set(i, legacyToMinimessage(list.get(i)));
+        }
+    }
+
+    public Component getConfigMessage(final String path) {
+        final String s = config.getString(path);
        if (s == null) {
            plugin.getLogger().warning("The config file is missing the following string: " + path);
-            return path;
+            return Component.text("null");
        }
-        return replaceNewlineVar(s);
+        return MiniMessage.miniMessage().deserialize(replaceNewlineVar(s));
    }

-    public String getConfigMessage(final String path) {
-        return getConfigMessage(config, path);
-    }
-
-    public String getLanguageString(final String path, final String... replacements) {
+    public Component getMessage(final String path, final String... replacements) {
        String s = language.getString(path);
        if (s == null) {
            plugin.getLogger().warning("The language file is missing the following string: " + path);
-            return path;
+            return Component.text("null");
        }
        if (replacements.length != 0) {
            if (replacements.length % 2 != 0) {
@@ -390,18 +353,15 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
                s = s.replace(key, replacements[i + 1]);
            }
        }
-        return replaceNewlineVar(s).replace("<prefix>", prefixString);
+
+        return MiniMessage.miniMessage().deserialize(replaceNewlineVar(s))
+                .replaceText(TextReplacementConfig.builder().matchLiteral("<prefix>").replacement(prefix).build());
    }

-    public @Nullable String getLanguageStringOrNull(final String path, final String... replacements) {
-        return language.contains(path) ? getLanguageString(path, replacements) : null;
+    public @Nullable Component getMessageOrNull(final String path, final String... replacements) {
+        return language.contains(path) ? getMessage(path, replacements) : null;
    }

-    public Component getMessage(final String path, final String... replacements) {
-        return parse(getLanguageString(path, replacements));
-    }
-
-    // TODO Cache platform components if there are no replacements
    public Component getRandomPingMessage() {
        if (plugin.isTaskRunning() && !plugin.getRunnable().shouldEnable()
                && hasTimerSpecificPingMessages() && !timerSpecificPingMessages.isEmpty()) {
@@ -410,15 +370,16 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return pingMessages.isEmpty() ? Component.empty() : getPingMessage(pingMessages);
    }

-    private Component getPingMessage(final List<String> list) {
-        final String component = list.size() == 1 ? list.get(0) : list.get(RANDOM.nextInt(list.size()));
-        return parse(plugin.replacePingVariables(component));
+    private Component getPingMessage(final List<Component> list) {
+        final Component component = list.size() == 1 ? list.get(0) : list.get(RANDOM.nextInt(list.size()));
+        return plugin.replacePingVariables(component);
    }

-    private List<String> loadPingMessages(final List<String> list) {
-        final List<String> components = new ArrayList<>(list.size());
+    private List<Component> loadPingMessages(final String path) {
+        final List<String> list = config.getStringList(path);
+        final List<Component> components = new ArrayList<>(list.size());
        for (final String s : list) {
-            components.add(replaceNewlineVar(s));
+            components.add(MiniMessage.miniMessage().deserialize(replaceNewlineVar(s)));
        }
        return components;
    }
@@ -434,6 +395,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return true;
    }

+    @Deprecated
    @Override
    public boolean removeWhitelistedPlayer(final String name) {
        UUID uuid = null;
@@ -522,10 +484,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
    }

    public void setSavedEndtimer(final long millis) {
-        if (savedEndtimer == millis) {
-            return;
-        }
-
+        if (savedEndtimer == millis) return;
        this.savedEndtimer = millis;
        config.getSection("continue-endtimer-after-restart").set("end", millis);
        saveConfig();
@@ -535,7 +494,7 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return config;
    }

-    public List<String> getPingMessages() {
+    public List<Component> getPingMessages() {
        return pingMessages;
    }

@@ -547,7 +506,8 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return commandsOnMaintenanceDisable;
    }

-    public @Nullable List<String> getTimerSpecificPingMessages() {
+    @Nullable
+    public List<Component> getTimerSpecificPingMessages() {
        return timerSpecificPingMessages;
    }

@@ -555,26 +515,22 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return broadcastIntervals;
    }

-    public String getLegacyParsedPlayerCountMessage() {
-        final String message = timerDependent(legacyParsedPlayerCountMessage, legacyParsedTimerPlayerCountMessage);
-        return plugin.replacePingVariables(message);
+    // Yikeseroo
+    public String getPlayerCountMessage() {
+        return LegacyComponentSerializer.legacySection().serialize(plugin.replacePingVariables(playerCountMessage));
    }

-    public String[] getLegacyParsedPlayerCountHoverLines() {
-        final List<String> lines = timerDependent(legacyParsedPlayerCountHoverLines, legacyParsedTimerPlayerCountHoverLines);
-        final String[] parsedLines = new String[lines.size()];
-        for (int i = 0; i < lines.size(); i++) {
-            parsedLines[i] = plugin.replacePingVariables(lines.get(i));
+    public String[] getPlayerCountHoverLines() {
+        final String[] lines = new String[playerCountHoverLines.size()];
+        for (int i = 0; i < playerCountHoverLines.size(); i++) {
+            final Component component = plugin.replacePingVariables(playerCountHoverLines.get(i));
+            lines[i] = LegacyComponentSerializer.legacySection().serialize(component);
        }
-        return parsedLines;
-    }
-
-    private <T> T timerDependent(final T normal, final @Nullable T timerSpecific) {
-        return timerSpecific != null && plugin.isTaskRunning() && !plugin.getRunnable().shouldEnable() ? timerSpecific : normal;
+        return lines;
    }

    public Component getKickMessage() {
-        return parse(plugin.replacePingVariables(getLanguageString("kickmessage")));
+        return plugin.replacePingVariables(getMessage("kickmessage"));
    }

    public String getLanguage() {
@@ -585,18 +541,6 @@ public class Settings implements eu.kennytv.maintenance.api.Settings {
        return customPlayerCountMessage;
    }

-    public boolean hasCustomPlayerCountHoverMessage() {
-        return customPlayerCountHoverMessage;
-    }
-
-    protected Component parse(final String s) {
-        return MiniMessage.miniMessage().deserialize(s);
-    }
-
-    protected String toLegacy(final Component component) {
-        return LegacyComponentSerializer.legacySection().serialize(component);
-    }
-
    /*
     * Note on why this even exists: Yaml will force save all strings containing line breaks '\n' in this rather chunky format:
     *   key: |-
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -36,19 +36,15 @@ import eu.kennytv.maintenance.core.command.subcommand.WhitelistAddCommand;
 import eu.kennytv.maintenance.core.command.subcommand.WhitelistCommand;
 import eu.kennytv.maintenance.core.command.subcommand.WhitelistRemoveCommand;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import java.time.Duration;
-import java.time.format.DateTimeParseException;
+import eu.kennytv.maintenance.core.util.ServerType;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import org.jetbrains.annotations.Nullable;

 public abstract class MaintenanceCommand {
-    private static final long MAX_TASK_DURATION_SECONDS = TimeUnit.DAYS.toSeconds(28);
    protected final MaintenancePlugin plugin;
    protected final Settings settings;
    private final Map<String, CommandInfo> commandExecutors = new LinkedHashMap<>();
@@ -129,41 +125,29 @@ public abstract class MaintenanceCommand {
        return info != null && info.hasPermission(sender) ? info.getTabCompletion(sender, args) : Collections.emptyList();
    }

-    public @Nullable Duration parseDurationAndCheckTask(final SenderInfo sender, final String time, final boolean taskCheck) {
-        final Duration duration;
-        if (plugin.isNumeric(time)) {
-            // Assume minutes by default as per old command behavior
-            duration = Duration.ofMinutes(Integer.parseInt(time));
-        } else {
-            try {
-                // Only accept hours, minutes, and seconds
-                duration = Duration.parse("PT" + time.toUpperCase(Locale.ROOT));
-            } catch (final DateTimeParseException e) {
-                return null;
-            }
-        }
-
+    public boolean checkTimerArgs(final SenderInfo sender, final String time, final boolean taskCheck) {
+        if (!plugin.isNumeric(time)) return true;
        if (taskCheck) {
            if (plugin.isTaskRunning()) {
                sender.send(settings.getMessage("timerAlreadyRunning"));
-                return null;
+                return true;
            }
        }

-        final long seconds = duration.getSeconds();
-        if (seconds > MAX_TASK_DURATION_SECONDS) {
+        final int minutes = Integer.parseInt(time);
+        if (minutes > 40320) {
            sender.send(settings.getMessage("timerTooLong"));
-            return null;
+            return true;
        }
-        if (seconds < 1) {
-            sender.sendRich("<i><dark_gray>[kennytv whispers to you] <gray>Think about running a timer for a negative amount of minutes. Doesn't work <b>that</b> <gray>well.");
-            return null;
+        if (minutes < 1) {
+            sender.sendMessage("§8§o[kennytv whispers to you] §7§oThink about running a timer for a negative amount of minutes. Doesn't work §lthat §7§owell.");
+            return true;
        }
-        return duration;
+        return false;
    }

-    public @Nullable Duration parseDurationAndCheckTask(final SenderInfo sender, final String time) {
-        return parseDurationAndCheckTask(sender, time, true);
+    public boolean checkTimerArgs(final SenderInfo sender, final String time) {
+        return checkTimerArgs(sender, time, true);
    }

    protected void addToggleAndTimerCommands() {
@@ -175,6 +159,24 @@ public abstract class MaintenanceCommand {
        add(new AbortTimerCommand(plugin), "aborttimer", "abort");
    }

+    public void checkForUpdate(final SenderInfo sender) {
+        if (plugin.updateAvailable()) {
+            sender.sendMessage(plugin.getPrefix() + "§cNewest version available: §aVersion " + plugin.getNewestVersion() + "§c, you're on §a" + plugin.getVersion());
+            // Ore sad :(
+            if (plugin.getServerType() != ServerType.SPONGE) {
+                sender.sendMessage(plugin.getPrefix() + "§c§lWARNING: §cYou will have to restart the server to prevent further issues and to complete the update! If you can't do that, don't update!");
+                sendUpdateMessage(sender);
+            } else {
+                sender.sendMessage(plugin.getPrefix() + "§aDownload the latest version on the Ore plugin page: §bhttps://ore.spongepowered.org/KennyTV/Maintenance");
+            }
+        } else
+            sender.sendMessage(plugin.getPrefix() + "§aYou already have the latest version of the plugin!");
+    }
+
+    protected void sendUpdateMessage(final SenderInfo sender) {
+        sender.sendMessage(plugin.getPrefix() + "§eUse §c§l/maintenance forceupdate §eto update!");
+    }
+
    public List<String> getServersCompletion(final String s) {
        return null;
    }
@@ -187,6 +189,8 @@ public abstract class MaintenanceCommand {
        return null;
    }

+    public abstract void sendDumpMessage(final SenderInfo sender, final String url);
+
    public List<CommandInfo> getCommands() {
        return commands;
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -32,6 +32,6 @@ public final class DebugCommand extends CommandInfo {
        if (checkArgs(sender, args, 1)) return;

        plugin.setDebug(!plugin.isDebug());
-        sender.sendPrefixedRich("<gray>Debug mode is now " + (plugin.isDebug() ? "<green>enabled" : "<red>disabled"));
+        sender.sendMessage("Debug mode is now " + (plugin.isDebug() ? "enabled" : "disabled"));
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,11 +20,7 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.TextComponent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.ClickEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.HoverEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.format.NamedTextColor;
+
 import java.util.concurrent.TimeUnit;

 public final class DumpCommand extends CommandInfo {
@@ -38,29 +34,25 @@ public final class DumpCommand extends CommandInfo {
    public void execute(final SenderInfo sender, final String[] args) {
        if (checkArgs(sender, args, 1)) return;
        if (System.currentTimeMillis() - lastDump < TimeUnit.MINUTES.toMillis(5)) {
-            sender.sendPrefixedRich("<red>You can only create a dump every 5 minutes!");
+            sender.sendMessage(plugin.getPrefix() + "§cYou can only create a dump every 5 minutes!");
            return;
        }

        lastDump = System.currentTimeMillis();
-        sender.sendPrefixedRich("<gray>The dump is being created, this might take a moment.");
+        sender.sendMessage(plugin.getPrefix() + "§7The dump is being created, this might take a moment.");
        plugin.async(() -> {
            final String key = plugin.pasteDump();
            if (key == null) {
                if (sender.isPlayer()) {
-                    sender.sendPrefixedRich("<red>Could not paste dump (see the console for details)");
+                    sender.sendMessage(plugin.getPrefix() + "§cCould not paste dump (see the console for details)");
                }
                return;
            }

-            final String url = "https://pastes.dev/" + key;
-            sender.sendPrefixedRich("<red><click:open_url:'" + url + "'>" + url + "</click>");
+            final String url = "https://hastebin.com/" + key;
+            sender.sendMessage(plugin.getPrefix() + "§c" + url);
            if (sender.isPlayer()) {
-                final TextComponent text = Component.text().content("Click here to copy the link").color(NamedTextColor.GRAY)
-                        .clickEvent(ClickEvent.clickEvent(ClickEvent.Action.COPY_TO_CLIPBOARD, url))
-                        .hoverEvent(HoverEvent.showText(Component.text("Click here to copy the link to your clipboard").color(NamedTextColor.GREEN)))
-                        .build();
-                sender.send(plugin.prefix().append(text));
+                plugin.getCommandManager().sendDumpMessage(sender, url);
            }
        });
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@ import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;

-import java.time.Duration;
+import java.util.concurrent.TimeUnit;

 public final class EndtimerCommand extends CommandInfo {

@@ -32,9 +32,7 @@ public final class EndtimerCommand extends CommandInfo {
    @Override
    public void execute(final SenderInfo sender, final String[] args) {
        if (checkArgs(sender, args, 2)) return;
-
-        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-        if (duration == null) {
+        if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
            sender.send(getHelpMessage());
            return;
        }
@@ -43,7 +41,7 @@ public final class EndtimerCommand extends CommandInfo {
            return;
        }

-        plugin.startMaintenanceRunnable(duration, false);
+        plugin.startMaintenanceRunnable(Integer.parseInt(args[1]), TimeUnit.MINUTES, false);
        sender.send(getMessage("endtimerStarted", "%TIME%", plugin.getRunnable().getTime()));
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,6 +22,7 @@ import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+
 import java.util.ArrayList;
 import java.util.List;

@@ -85,7 +86,7 @@ public final class HelpCommand extends CommandInfo {
        if (page * COMMANDS_PER_PAGE < commands.size()) {
            sender.send(getMessage("helpNextPage", "%PAGE%", Integer.toString(page + 1)));
        } else {
-            sender.sendRich("<dark_gray>× <yellow>Version: " + plugin.getVersion() + " <gray>by <aqua>kennytv");
+            sender.sendMessage("§8× §eVersion " + plugin.getVersion() + " §7by §bkennytv");
        }

        sender.send(header);
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,6 +20,8 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;

 import java.util.Collections;
 import java.util.List;
@@ -46,7 +48,7 @@ public final class MotdCommand extends CommandInfo {
        }
    }

-    private void sendList(final SenderInfo sender, final List<String> list) {
+    private void sendList(final SenderInfo sender, final List<Component> list) {
        if (list == null || list.isEmpty()) {
            sender.send(getMessage("motdListEmpty"));
            return;
@@ -54,17 +56,15 @@ public final class MotdCommand extends CommandInfo {

        sender.send(getMessage("motdList"));
        for (int i = 0; i < list.size(); i++) {
-            sender.sendRich("<aqua>" + (i + 1) + "<dark_gray><st>---------");
-            sender.sendRich(list.get(i));
+            sender.sendMessage("§b" + (i + 1) + "§8§m---------");
+            sender.send(list.get(i));
        }
-        sender.sendRich("<dark_gray><st>----------");
+        sender.sendMessage("§8§m----------");
    }

    @Override
    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
-        if (args.length != 2 || !getSettings().hasTimerSpecificPingMessages()) {
-            return Collections.emptyList();
-        }
+        if (args.length != 2 || !getSettings().hasTimerSpecificPingMessages()) return Collections.emptyList();
        return Collections.singletonList("timer");
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,8 +20,8 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.core.command.CommandInfo;
-import eu.kennytv.maintenance.core.config.ConfigSection;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;

 import java.util.ArrayList;
 import java.util.Collections;
@@ -52,8 +52,7 @@ public final class RemoveMotdCommand extends CommandInfo {
        }

        final Settings settings = getSettings();
-        final ConfigSection section = settings.getConfig().getSection("ping-message");
-        final List<String> pingMessages = section.getStringList(timerPingMessages ? "timer-messages" : "messages");
+        final List<String> pingMessages = settings.getConfig().getStringList(timerPingMessages ? "timerspecific-pingmessages" : "pingmessages");
        if (pingMessages.size() < 2) {
            sender.send(getMessage("removeMotdError"));
            return;
@@ -67,10 +66,10 @@ public final class RemoveMotdCommand extends CommandInfo {
            return;
        }

-        final List<String> pingComponents = timerPingMessages ? settings.getTimerSpecificPingMessages() : settings.getPingMessages();
+        final List<Component> pingComponents = timerPingMessages ? settings.getTimerSpecificPingMessages() : settings.getPingMessages();
        pingComponents.remove(index - 1);
        pingMessages.remove(index - 1);
-        section.set(timerPingMessages ? "timer-messages" : "messages", pingMessages);
+        settings.getConfig().set(timerPingMessages ? "timerspecific-pingmessages" : "pingmessages", pingMessages);
        settings.saveConfig();
        sender.send(getMessage("removedMotd", "%INDEX%", args[1]));
    }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,8 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import java.time.Duration;
+
+import java.util.concurrent.TimeUnit;

 public final class ScheduleTimerCommand extends CommandInfo {

@@ -31,10 +32,8 @@ public final class ScheduleTimerCommand extends CommandInfo {
    @Override
    public void execute(final SenderInfo sender, final String[] args) {
        if (checkArgs(sender, args, 3)) return;
-
-        final Duration enableIn = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-        final Duration maintenanceDuration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[2], false);
-        if (enableIn == null || maintenanceDuration == null) {
+        if (plugin.getCommandManager().checkTimerArgs(sender, args[1])
+                || plugin.getCommandManager().checkTimerArgs(sender, args[2], false)) {
            sender.send(getHelpMessage());
            return;
        }
@@ -43,11 +42,7 @@ public final class ScheduleTimerCommand extends CommandInfo {
            return;
        }

-        plugin.scheduleMaintenanceRunnable(enableIn, maintenanceDuration);
-        sender.send(getMessage(
-                "scheduletimerStarted",
-                "%TIME%", plugin.getRunnable().getTime(),
-                "%DURATION%", plugin.getFormattedTime((int) maintenanceDuration.getSeconds())
-        ));
+        plugin.scheduleMaintenanceRunnable(Integer.parseInt(args[1]), Integer.parseInt(args[2]), TimeUnit.MINUTES);
+        sender.send(getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime()));
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,8 +20,10 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.core.command.CommandInfo;
-import eu.kennytv.maintenance.core.config.ConfigSection;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
+import eu.kennytv.maintenance.lib.kyori.adventure.text.minimessage.MiniMessage;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -54,9 +56,8 @@ public final class SetMotdCommand extends CommandInfo {
        }

        final Settings settings = getSettings();
-        final List<String> pingComponents = timerPingMessages ? settings.getTimerSpecificPingMessages() : settings.getPingMessages();
-        final ConfigSection section = settings.getConfig().getSection("ping-message");
-        final List<String> pingMessages = section.getStringList(timerPingMessages ? "timer-messages" : "messages");
+        final List<Component> pingComponents = timerPingMessages ? settings.getTimerSpecificPingMessages() : settings.getPingMessages();
+        final List<String> pingMessages = settings.getConfig().getStringList(timerPingMessages ? "timerspecific-pingmessages" : "pingmessages");
        final int index = Integer.parseInt(args[1]);
        if (index == 0 || index > pingMessages.size() + 1) {
            sender.send(getMessage("setMotdIndexError",
@@ -88,23 +89,20 @@ public final class SetMotdCommand extends CommandInfo {
        }

        // Replace component in config and the cached list
-        final String componentString = newMessage.replace(NEW_LINE_REPLACEMENT, "\n");
+        final Component component = MiniMessage.miniMessage().deserialize(newMessage.replace(NEW_LINE_REPLACEMENT, "\n"));
        if (index > pingMessages.size()) {
            pingMessages.add(newMessage);
-            pingComponents.add(componentString);
+            pingComponents.add(component);
        } else {
            pingMessages.set(index - 1, newMessage);
-            pingComponents.set(index - 1, componentString);
+            pingComponents.set(index - 1, component);
        }

-        section.set(timerPingMessages ? "timer-messages" : "messages", pingMessages);
+        settings.getConfig().set(timerPingMessages ? "timerspecific-pingmessages" : "pingmessages", pingMessages);
        settings.saveConfig();
-        sender.send(settings.getMessage(
-                "setMotd",
+        sender.send(settings.getMessage("setMotd",
                "%LINE%", args[2],
-                "%INDEX%", args[1],
-                "%MOTD%", componentString
-        ));
+                "%INDEX%", args[1]).replaceText(builder -> builder.matchLiteral("%MOTD%").replacement(component)));
    }

    @Override
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@ import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;

-import java.time.Duration;
+import java.util.concurrent.TimeUnit;

 public final class StarttimerCommand extends CommandInfo {

@@ -32,9 +32,7 @@ public final class StarttimerCommand extends CommandInfo {
    @Override
    public void execute(final SenderInfo sender, final String[] args) {
        if (checkArgs(sender, args, 2)) return;
-
-        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
-        if (duration == null) {
+        if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
            sender.send(getHelpMessage());
            return;
        }
@@ -43,7 +41,7 @@ public final class StarttimerCommand extends CommandInfo {
            return;
        }

-        plugin.startMaintenanceRunnable(duration, true);
+        plugin.startMaintenanceRunnable(Integer.parseInt(args[1]), TimeUnit.MINUTES, true);
        sender.send(getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime()));
    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,11 +20,7 @@ package eu.kennytv.maintenance.core.command.subcommand;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.ClickEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.HoverEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.format.NamedTextColor;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.minimessage.MiniMessage;
+import eu.kennytv.maintenance.core.util.ServerType;

 public final class UpdateCommand extends CommandInfo {

@@ -36,41 +32,24 @@ public final class UpdateCommand extends CommandInfo {
    public void execute(final SenderInfo sender, final String[] args) {
        if (checkArgs(sender, args, 1)) return;
        if (args[0].equalsIgnoreCase("update")) {
-            plugin.async(() -> checkForUpdate(sender));
-            return;
-        }
+            plugin.async(() -> plugin.getCommandManager().checkForUpdate(sender));
+        } else {
+            if (!plugin.updateAvailable()) {
+                sender.sendMessage(plugin.getPrefix() + "§aYou already have the latest version of the plugin!");
+                return;
+            }
+            // Ore very sad :(
+            if (plugin.getServerType() == ServerType.SPONGE) {
+                sender.sendMessage(plugin.getPrefix() + "§cSorry, automated downloading of the plugin is not supported on Sponge! Please download the latest version manually! :(");
+                return;
+            }

-        if (!plugin.updateAvailable()) {
-            sender.sendPrefixedRich("<green>You already have the latest version of the plugin!");
-            return;
-        }
-
-        sender.send(getMessage("updateDownloading"));
-        try {
+            sender.send(getMessage("updateDownloading"));
            if (plugin.installUpdate()) {
                sender.send(getMessage("updateFinished"));
            } else {
                sender.send(getMessage("updateFailed"));
            }
-        } catch (final Exception e) {
-            sender.send(getMessage("updateFailed"));
-            e.printStackTrace();
        }
    }
-
-    private void checkForUpdate(final SenderInfo sender) {
-        if (!plugin.updateAvailable()) {
-            sender.sendPrefixedRich("<green>You already have the latest version of the plugin!");
-            return;
-        }
-
-        sender.sendPrefixedRich("<red>Newest version available: <green>Version " + plugin.getNewestVersion() + "<red>, you're on <green>" + plugin.getVersion());
-        sender.sendPrefixedRich("<b><red>WARNING: <red>You will have to restart the server to prevent further issues and to complete the update! If you can't do that, don't update!");
-
-        sender.send(Component.text().append(MiniMessage.miniMessage().deserialize("<gold>× <dark_gray>[<green>Update<dark_gray>]"))
-                .clickEvent(ClickEvent.runCommand("/maintenance forceupdate"))
-                .hoverEvent(HoverEvent.showText(Component.text().content("Click here to update the plugin").color(NamedTextColor.GREEN)))
-                .append(Component.text().content(", or manually run ").color(NamedTextColor.GRAY))
-                .append(Component.text().content("/maintenance forceupdate").color(NamedTextColor.RED)).build());
-    }
 }
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -25,7 +25,6 @@ import eu.kennytv.maintenance.core.util.SenderInfo;
 import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
-import java.util.logging.Level;

 public final class WhitelistAddCommand extends CommandInfo {

@@ -65,13 +64,7 @@ public final class WhitelistAddCommand extends CommandInfo {
    }

    private void addPlayerToWhitelist(final SenderInfo sender, final String name) {
-        plugin.getOfflinePlayer(name).whenComplete((selected, ex) -> {
-            if (ex != null) {
-                plugin.getLogger().log(Level.SEVERE, "Error while fetching offline player", ex);
-                sender.send(getMessage("offlinePlayerFetchError"));
-                return;
-            }
-
+        plugin.getOfflinePlayer(name, selected -> {
            if (selected == null) {
                sender.send(getMessage("playerNotOnline"));
                return;
@@ -82,13 +75,7 @@ public final class WhitelistAddCommand extends CommandInfo {
    }

    private void addPlayerToWhitelist(final SenderInfo sender, final UUID uuid) {
-        plugin.getOfflinePlayer(uuid).whenComplete((selected, ex) -> {
-            if (ex != null) {
-                plugin.getLogger().log(Level.SEVERE, "Error while fetching offline player", ex);
-                sender.send(getMessage("offlinePlayerFetchError"));
-                return;
-            }
-
+        plugin.getOfflinePlayer(uuid, selected -> {
            if (selected == null) {
                sender.send(getMessage("playerNotFoundUuid"));
                return;
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -50,9 +50,8 @@ public final class WhitelistRemoveCommand extends CommandInfo {
        if (args.length != 2) return Collections.emptyList();

        final List<String> list = new ArrayList<>();
-        String matchNameLowerCase = args[1].toLowerCase();
        for (final String name : getSettings().getWhitelistedPlayers().values()) {
-            if (name.toLowerCase().startsWith(matchNameLowerCase)) {
+            if (name.toLowerCase().startsWith(args[1])) {
                list.add(name);
            }
        }
@@ -60,7 +59,7 @@ public final class WhitelistRemoveCommand extends CommandInfo {
    }

    private void removePlayerFromWhitelist(final SenderInfo sender, final String name) {
-        plugin.getOfflinePlayer(name).whenComplete((selected, ex) -> {
+        plugin.getOfflinePlayer(name, selected -> {
            if (selected == null) {
                if (getSettings().removeWhitelistedPlayer(name)) {
                    sender.send(getMessage("whitelistRemoved", "%PLAYER%", name));
@@ -75,7 +74,7 @@ public final class WhitelistRemoveCommand extends CommandInfo {
    }

    private void removePlayerFromWhitelist(final SenderInfo sender, final UUID uuid) {
-        plugin.getOfflinePlayer(uuid).whenComplete((selected, ex) -> {
+        plugin.getOfflinePlayer(uuid, selected -> {
            if (selected == null) {
                removePlayerFromWhitelist(sender, uuid, uuid.toString());
            } else {
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,6 +18,10 @@
 package eu.kennytv.maintenance.core.config;

 import com.google.common.collect.Sets;
+import org.jetbrains.annotations.Nullable;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -27,12 +31,9 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
-import org.jetbrains.annotations.Nullable;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.Yaml;

 /**
- * Further modified version of the <a href="https://github.com/PSandro/SimpleConfig">SimpleConfig</a>SimpleConfig project of PSandro.
+ * Further modified version of the SimpleConfig project of PSandro (https://github.com/PSandro/SimpleConfig).
 *
 * @author PSandro on 26.01.19
 * @author kennytv
@@ -109,8 +110,30 @@ public final class Config extends ConfigSection {
        Files.write(file.toPath(), bytes);
    }

-    public void replaceComments(final Config fromConfig) {
-        this.comments = new HashMap<>(fromConfig.comments);
+    public boolean addMissingFields(final Map<String, Object> fields, final Map<String, String[]> comments) {
+        // Note: Only scans for the first two levels
+        boolean changed = false;
+        for (final Map.Entry<String, Object> entry : fields.entrySet()) {
+            final Object o = values.get(entry.getKey());
+            if (o != null) {
+                final Object o2 = entry.getValue();
+                if (!(o instanceof Map) || !(o2 instanceof Map)) continue;
+
+                final Map<String, Object> deepMap = (Map<String, Object>) o2;
+                for (final Map.Entry<String, Object> deepEntry : ((Map<String, Object>) o2).entrySet()) {
+                    if (deepMap.containsKey(deepEntry.getKey())) continue;
+                    deepMap.put(deepEntry.getKey(), deepEntry.getValue());
+                    changed = true;
+                }
+                continue;
+            }
+
+            values.put(entry.getKey(), entry.getValue());
+            changed = true;
+        }
+
+        this.comments = new HashMap<>(comments);
+        return changed;
    }

    private static Yaml createYaml() {
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -17,15 +17,15 @@
 */
 package eu.kennytv.maintenance.core.config;

+import org.jetbrains.annotations.Nullable;
+
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import org.jetbrains.annotations.Nullable;

 /**
- * Further modified version of the <a href="https://github.com/PSandro/SimpleConfig">SimpleConfig</a>SimpleConfig project of PSandro.
+ * Further modified version of the SimpleConfig project of PSandro (https://github.com/PSandro/SimpleConfig).
 *
 * @author kennytv
 */
@@ -63,15 +63,15 @@ public class ConfigSection {

    @Nullable
    public Object getObject(final String key, final Object def) {
-        int nextSeparatorIndex = -1;
-        int sectionStartIndex;
+        int i1 = -1;
+        int i2;
        ConfigSection section = this;
-        while ((nextSeparatorIndex = key.indexOf('.', sectionStartIndex = nextSeparatorIndex + 1)) != -1) {
-            section = section.getSection(key.substring(sectionStartIndex, nextSeparatorIndex));
+        while ((i1 = key.indexOf('.', i2 = i1 + 1)) != -1) {
+            section = section.getSection(key.substring(i2, i1));
            if (section == null) return def;
        }

-        final String subKey = key.substring(sectionStartIndex);
+        final String subKey = key.substring(i2);
        if (section == this) {
            final Object result = values.get(subKey);
            return result != null ? result : def;
@@ -97,41 +97,17 @@ public class ConfigSection {
        return new ConfigSection(getRoot(), getFullKeyInPath(key), (Map<String, Object>) o);
    }

-    public ConfigSection getOrCreateSection(final String key) {
-        final Object o = getObject(key);
-        if (!(o instanceof Map)) {
-            set(key, new LinkedHashMap<>());
-            return getSection(key);
-        }
-        return new ConfigSection(getRoot(), getFullKeyInPath(key), (Map<String, Object>) o);
-    }
-
    public boolean contains(final String key) {
        return getObject(key) != null;
    }

    public void set(final String key, @Nullable final Object value) {
-        int nextSeparatorIndex = -1;
-        int sectionStartIndex;
-        ConfigSection section = this;
-        while ((nextSeparatorIndex = key.indexOf('.', sectionStartIndex = nextSeparatorIndex + 1)) != -1) {
-            section = section.getOrCreateSection(key.substring(sectionStartIndex, nextSeparatorIndex));
-        }
-
-        final String sectionKey = key.substring(sectionStartIndex);
+        //TODO go deep if necessary
        if (value == null) {
-            section.values.remove(sectionKey);
+            values.remove(key);
            getRoot().getComments().remove(getFullKeyInPath(key));
        } else {
-            section.values.put(sectionKey, value);
-        }
-    }
-
-    public void move(final String key, final String toKey) {
-        final Object o = getObject(key);
-        if (o != null) {
-            remove(key);
-            set(toKey, o);
+            values.put(key, value);
        }
    }

@@ -216,28 +192,6 @@ public class ConfigSection {
        return list != null ? list : def;
    }

-    public boolean addMissingFields(final ConfigSection fromSection) {
-        boolean changed = false;
-        for (final Map.Entry<String, Object> entry : fromSection.values.entrySet()) {
-            final String key = entry.getKey();
-            final Object value = this.values.get(key);
-            if (value != null) {
-                // Go deeper for sections
-                final Object newValue = entry.getValue();
-                if (!(value instanceof Map) || !(newValue instanceof Map)) {
-                    continue;
-                }
-
-                changed |= this.getSection(key).addMissingFields(fromSection.getSection(key));
-            } else {
-                // Value is missing
-                this.values.put(key, entry.getValue());
-                changed = true;
-            }
-        }
-        return changed;
-    }
-
    /**
     * @return root config
     */
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@ import java.util.Map;
 import java.util.regex.Pattern;

 /**
- * Further modified version of the <a href="https://github.com/PSandro/SimpleConfig">SimpleConfig</a>SimpleConfig project of PSandro.
+ * Further modified version of the SimpleConfig project of PSandro (https://github.com/PSandro/SimpleConfig).
 *
 * @author PSandro on 26.01.19
 * @author kennytv
@@ -146,11 +146,6 @@ public final class ConfigSerializer {
                multiLineValue = false;
            }

-            // YAML list items are values, not keys - skip without touching key/indent state
-            if (line.length() > indent && line.charAt(indent) == '-') {
-                continue;
-            }
-
            // Check if this is a level lower
            if (indents <= currentIndents) {
                final String[] array = key.split(PATH_SEPARATOR_QUOTED);
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -25,7 +25,6 @@ import java.io.File;
 import java.util.LinkedHashMap;
 import java.util.Map;

-@SuppressWarnings({"FieldCanBeLocal", "unused"})
 public final class MaintenanceDump {
    private final ServerDump general;
    private final Map<String, Object> configuration;
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@ package eu.kennytv.maintenance.core.dump;

 import java.util.List;

-@SuppressWarnings({"FieldCanBeLocal", "unused"})
 public final class PluginDump {
    private final String name;
    private final String version;
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@ package eu.kennytv.maintenance.core.dump;

 import java.util.List;

-@SuppressWarnings({"FieldCanBeLocal", "unused"})
 public final class ServerDump {
    private final String pluginVersion;
    private final String platform;
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,12 +21,6 @@ import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.core.util.SenderInfo;

-import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.TextComponent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.ClickEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.event.HoverEvent;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.format.NamedTextColor;
-import eu.kennytv.maintenance.lib.kyori.adventure.text.format.TextDecoration;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
@@ -66,20 +60,11 @@ public abstract class JoinListenerBase {
        if (!settings.hasUpdateChecks()) return;
        if (!sender.hasPermission("maintenance.admin") || notifiedPlayers.contains(sender.getUuid())) return;
        plugin.async(() -> {
-            if (!plugin.updateAvailable()) {
-                return;
-            }
+            if (!plugin.updateAvailable()) return;

            notifiedPlayers.add(sender.getUuid());
-            sender.sendPrefixedRich("<red>There is a newer version available: <green>Version " + plugin.getNewestVersion() + "<red>, you're on <green>" + plugin.getVersion());
-
-            final TextComponent text = Component.text().content("Download it at: ").color(NamedTextColor.RED)
-                    .append(Component.text().content(MaintenancePlugin.HANGAR_URL).color(NamedTextColor.GOLD))
-                    .append(Component.text().content(" (CLICK ME)").color(NamedTextColor.GRAY).decorate(TextDecoration.BOLD))
-                    .clickEvent(ClickEvent.clickEvent(ClickEvent.Action.OPEN_URL, MaintenancePlugin.HANGAR_URL))
-                    .hoverEvent(HoverEvent.showText(Component.text("Download the latest version").color(NamedTextColor.GREEN)))
-                    .build();
-            sender.send(plugin.prefix().append(text));
+            sender.sendMessage(plugin.getPrefix() + "§cThere is a newer version available: §aVersion " + plugin.getNewestVersion() + "§c, you're on §a" + plugin.getVersion());
+            plugin.sendUpdateNotification(sender);
        });
    }

@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -25,8 +25,8 @@ import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
 public abstract class MaintenanceRunnableBase implements Runnable {
    protected final MaintenancePlugin plugin;
    protected final Settings settings;
-    protected final boolean enable;
    private final Task task;
+    protected boolean enable;
    protected int seconds;

    protected MaintenanceRunnableBase(final MaintenancePlugin plugin, final Settings settings, final int seconds, final boolean enable) {
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,8 @@ package eu.kennytv.maintenance.core.runnable;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.lib.kyori.adventure.text.Component;
-import java.time.Duration;
+
+import java.util.concurrent.TimeUnit;

 public final class MaintenanceScheduleRunnable extends MaintenanceRunnable {
    private final int maintenanceDuration;
@@ -35,7 +36,7 @@ public final class MaintenanceScheduleRunnable extends MaintenanceRunnable {
        super.finish();

        // Start the timer to disable maintenance again
-        plugin.startMaintenanceRunnable(Duration.ofSeconds(maintenanceDuration), false);
+        plugin.startMaintenanceRunnable(maintenanceDuration, TimeUnit.SECONDS, false);
    }

    @Override
@@ -1,6 +1,6 @@
 /*
 * This file is part of Maintenance - https://github.com/kennytv/Maintenance
- * Copyright (C) 2018-2024 kennytv (https://github.com/kennytv)
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -45,6 +45,11 @@ public final class DummySenderInfo implements SenderInfo {
        return false;
    }

+    @Override
+    @Deprecated
+    public void sendMessage(final String message) {
+    }
+
    @Override
    public void send(final Component component) {
    }
@@ -0,0 +1,23 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2022 kennytv (https://github.com/kennytv)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package eu.kennytv.maintenance.core.util;
+
+public final class MaintenanceVersion {
+
+    public static final String VERSION = "$VERSION";
+}
@@ -1,9 +0,0 @@
-package eu.kennytv.maintenance.core.util;
-
-import java.io.IOException;
-
-/**
- * Exception thrown when an API rate limit is reached.
- */
-public class RateLimitedException extends IOException {
-}
				`@@ -1 +0,0 @@`
				`.gitea/CODEOWNERS linguist-detectable=false`