Update changelog

Fixes #220

.github/CHANGELOG.md

@@ -1,6 +1,180 @@
 # 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.
 
+## 5.1.1 - October 17th 2026
+
+### Changed
+- Velocity/Bungee: Timer commands now accept `global` as the server argument, with an optional mode: `/maintenance starttimer global [mode] <time>`, `/maintenance scheduletimer global [mode] <time> <duration>`, `/maintenance endtimer global <time>`
+- Timer durations now also accept days, e.g. `2d` or `1d12h`
+- Folia: Now supports timers
+
+### Fixed
+- Folia: Fixed the update check stalling the global region thread
+- Velocity/Bungee: Fixed the `redis.enabled` confg key
+- Velocity/Bungee: `/maintenance reload` now keeps the maintenance status from Redis instead of overriding it with the local config
+- Velocity/Bungee: Fixed `/maintenance aborttimer` tab completion not suggesting servers with running timers
+
+---
+## 5.1.0 - May 17th 2026
+
+### Changed
+- Made Discord webhooks configurable separately from command messages, including a new `%TIMESTAMP%` parameter for Discord timestamps (e.g. `<t:%TIMESTAMP%:R>`)
+
+### Fixed
+- Velocity/Bungee: Fixed proxied-maintenance-servers config loading
+---
+## 5.0.0 - April 17th 2026
+
+This update removes *a lot* of legacy code, making the code-base a great bit more simple and a lot more performant.
+
+### Requirements
+- The Paper part now **requires at least Paper 1.20.1** and no longer supports Spigot
+- The universal jar has been removed. Each platform now has its own jar (that is as small as possible)
+- Maintenance now **requires at least Java 21**
+
+### Changed
+- **Added mode-based maintenance messages** for `ping-message`, `player-count-message`, and `player-list-hover-message`
+  - You can have different MOTDs depending on the pre-configured mode, e.g. a generic `default` or one for `upcoming-release`.
+  - Updated proxy/global toggle syntax: `/maintenance on [mode]`
+    - For proxy servers: `/maintenance on global [mode]`, `/maintenance on <server> [mode]`
+  - Other updated commands: `/maintenance motd [timer] [mode]`, `/maintenance setmotd [timer] [mode] ...`, `/maintenance removemotd [timer] [mode] ...`
+- **Added `webhook` config option for Discord webhooks** when the maintenance status changes, a timer is started or a join is blocked
+- **Added `%REASON%` variable to messages**, using the `active-reason` config option. This allows for dynamic MOTD and other messages via a quick command without modifying the messages themselves
+  - Can be changed via the `/maintenance setreason <reason>` command
+- **Added `/maintenance status` command** on Paper/Sponge to display the current maintenance status as well as any running start or end timers.
+- Velocity/Bungee: **The existing timer command now displays start and end timers** for proxied servers.
+- Velocity/Bungee: **Replaced `mysql` section with `redis`**. This is a more suitable database for such reading and sharing of data and no longer means some server pings can take multiple seconds, if you have multiple proxies linked
+
+### Fixed
+- Velocity/Bungee: Fixed the `/maintenance schedule` command for single servers having swapped time arguments
+---
+## 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
+* Fixed the config header sometimes breaking the config on upgrading/saving
+---
+## 4.0.0 - March 17th 2022
+### Changed
+* Added support for hex colors in messages and replaced the component parsing with adventure-minimessage
+  * This means that section symbols (`§`) are no longer the intended/supported format
+  * You can use the following page to edit and preview formatted text: https://webui.advntr.dev/
+  * You can find full documentation on the format (including normal colors and formatting, rgb, click/hover events, and more) here: https://docs.papermc.io/adventure/minimessage/format/
+  * Your config and language file will be updated to the new format automatically, you won't have to change anything manually!
+  * Note that the player count and player count hover messages do not support rgb colors
+* Updated Sponge module to SpongeAPI v8 (Minecraft 1.15+)
+* Changed `%NEWLINE%` replacement to `<br>`
+* Changed `enable-timerspecific-messages` to default to `true` in newly generated config files
+* Added `prefix` entry in language file to use the placeholder `<prefix>` instead of copy-pasting the actual prefix every time
+* Added `singleServerMaintenanceListEntry` language string
+* Added Polish translations (thanks to Slasherss1)
+* Updated French translations (thanks to Aurelien30000)
+* Updated Spanish translations (thanks to Jaximo)
+* If you were using the MaintenanceAddon, you need to update it to [version 1.2.0](https://github.com/kennytv/MaintenanceAddon/releases/tag/1.2.0)
+### Fixed
+* Fixed missing language key warning for the scheduletimer command
+* Fixed typo in `singleServerMaintenanceListEmpty` default language string
+* Fixed typo in language key `whitelistEmpty` in the German language file (by Ceddix)
+---
+## 3.0.7 - August 17th 2021
+### Changed
+* Bungee/Velocity: `/maintenance add <name>` now works for offline players as well
+* Added config options `commands-on-maintenance-enable` and `commands-on-maintenance-disable` to define commands to be executed after maintenance has been toggled
+* Added config option `enable-pingmessages` to can change whether a custom maintenance motd should be displayed during maintenance
+* Added language fields `scheduletimerBroadcast` and `singleScheduletimerBroadcast` with the variables `%SERVER%`, `%TIME%`, and `%DURATION%` instead of using the normal starttimer broadcasts
+### Fixed
+* Fixed SQL loading issues on some platforms
+* Fixed missing language key warning for the debug command
+* Velocity: Fixed the update message
+---
+## 3.0.6 - February 17th 2021
+### Changed
+* Updated the Velocity version to be compatible with Velocity 1.1.0 (use Maintenance 3.0.5 if you use an older version of Velocity)
+* Added `maintenance schedule <minutes> <duration> command`
+  * This starts a timer for maintenance to be enabled, after which another timer will be started to disable it again (in contrast to `starttimer` and `endtimer`, which each only do one of)
+  * On proxies, you can use `maintenance schedule [server] <minutes> <duration> command` to schedule maintenance on a proxied server
+* Added command alias `mt` for the Maintenance command
+* Added secret argument to the whitelist add command: You can use `maintenance add <uuid> <name>` to add offline entries per command
+* The maintenance's base command is now properly registered with a permission on each platform, so that it is excluded from tabcomplection to unauthorized players
+* Some improvements to the French language file (thanks to @Aurelien30000)
+* API addition: Added MaintenanceReloadedEvent
+  * If you are using the MaintenancePlaceholderAddon, you need to [update it to 1.1.0](https://github.com/KennyTV/MaintenanceAddon/releases)
+### Fixed
+* Fixed not setting custom singleserver kickmessages throwing warnings
+* Bungee: Fixed linebreaks in the playercount hovermessage for 1.16+ clients
+---
+## 3.0.5 - June 17th 2020
+### Changed
+* The plugin identifiers are now `Maintenance` instead of the previous `MaintenanceSpigot` and `MaintenanceBungee`,
+ and `maintenance` instead of `maintenancesponge` and `maintenancevelocity`
+  * The plugin directory will automatically be renamed accordingly when starting the server
+  * If you are using the MaintenancePlaceholderAddon, you need to [update it to 1.0.3](https://github.com/KennyTV/MaintenanceAddon/releases)
+* Bungee/Velocity: The `fallback` field can now also be set as a list to define multiple fallback servers
+* 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
+* 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
+### Fixed
+* Fixed the `use-ssl` option being inverted
+* Fixed disabling the playercount-message still hiding online/max players
+* Fixed config parsing with multi line strings
+* Bungee: Fixed compatibility with other motd changing plugins using the 'HIGHEST' ping listener priority
+---
 ## 3.0.4 - March 17th 2020
 ### Changed
 * Bungee/Velocity: Added config option `waiting-server` to send players to a waiting server when global maintenance is enabled (instead of kicking them)
@@ -10,6 +184,7 @@ This file contains update logs for this project. The top may contain a `Unreleas
 * Updated bStats metrics
 ### Fixed
 * Fixed singleserver timers using input as seconds instead of minutes (by mxs42)
+* Fixed singleserver timers broadcasting globally
 * Fixed language updating with an unknown/self-translated language file
 * Fixed Velocity server autocompletion in the maintenance command
 ---
@@ -198,4 +373,4 @@ This file contains update logs for this project. The top may contain a `Unreleas
 ### Fixed
 * Fixed some permission and message bugs
 * Fixed problems with adding and removing players from the maintenance whitelist
-* Fixed update checks
+* Fixed update checks

.github/ISSUE_TEMPLATE/bug_report.md

@@ -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://pastebin.com/ and link paste the link.**
+**Is there an error? Save it via https://mclo.gs/ and link paste the link.**
 
 ## Server information
 **Type '/maintenance dump' and paste the given link here**

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    cooldown:
+      default-days: 7
+    directory: "/"
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: "gradle"
+    cooldown:
+      default-days: 7
+    directory: "/"
+    schedule:
+      interval: "monthly"

.github/workflows/gradle.yml

@@ -0,0 +1,28 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v6
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v6
+        with:
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Build with Gradle
+        run: ./gradlew build
+
+      - name: Upload a Build Artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: Maintenance Files
+          path: build/libs

.gitignore

@@ -1,6 +1,8 @@
 .metadata
-dependencies/
+build/
+.gradle
 bin/
+run/
 tmp/
 *.tmp
 *.bak
@@ -14,7 +16,6 @@ local.properties
 .externalToolBuilders/
 *.launch
 *.pydevproject
-*.jar
 .cproject
 .classpath
 .factorypath
@@ -92,4 +93,6 @@ $RECYCLE.BIN/
 *.msm
 *.msp
 *.lnk
-!MaintenanceAPI.jar
+!MaintenanceAPI.jar
+**/src/test/resources/
+!core/src/test/resources/dirty-config.yml

.travis.yml

@@ -1,7 +0,0 @@
-language: java
-jdk:
-  - oraclejdk8
-dist: trusty
-cache:
-  directories:
-    - '$HOME/.m2/repository'

LICENSE.txt

@@ -1,7 +1,7 @@
-GNU GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -645,7 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
     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/>.
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -664,11 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
+<https://www.gnu.org/licenses/>.
 
   The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,10 +1,10 @@
 # Maintenance
-[![Version](https://img.shields.io/github/release/KennyTV/Maintenance.svg)](https://github.com/KennyTV/Maintenance/releases)
-[![Build Status](https://travis-ci.org/KennyTV/Maintenance.svg?branch=master)](https://travis-ci.org/KennyTV/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)
 [![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 probably the most customizable free maintenance plugin for your Minecraft server you can find. It runs on Bukkit/Spigot, BungeeCord, Sponge as well as Velocity.
+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.
 
 Its features include:
 * A custom motd as well as server icon, that will be shown during maintenance
@@ -14,24 +14,26 @@ Its features include:
 * Nearly all messages are editable via the language file, given in a multitude of different languages
 * 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://github.com/KennyTV/Maintenance/wiki/MaintenanceAddon) (only for Bungee)
+  * Link multiple proxy instances through a Redis connection, so you don't have to change maintenance status or whitelisted players on each proxy by hand
+  * Use PlaceholderAPI placeholders with the [**MaintenanceAddon**](https://hangar.papermc.io/kennytv/MaintenanceAddon) (for Velocity and Bungee)
 
 A full list of commands, permissions and configuration options can be found in the wiki listed below.
-* [Wiki](https://github.com/KennyTV/Maintenance/wiki)
-* [Downloads](https://github.com/KennyTV/Maintenance/releases) (GitHub)
-* [Development builds](https://kennytv.eu/maintenance/snapshot/) (out of order at the moment)
-* [Changelogs](https://github.com/KennyTV/Maintenance/blob/master/.github/CHANGELOG.md)
-* [Issue tracker/bug reports](https://github.com/KennyTV/Maintenance/issues)
+* [Hangar Downloads](https://hangar.papermc.io/kennytv/Maintenance)
+* [Wiki](https://github.com/kennytv/Maintenance/wiki) (configuration, permissions, API usage)
+* [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)
 
-Other forum threads
-* [Spigot forums](https://www.spigotmc.org/resources/maintenance.40699/)
-* [Ore/Sponge Forums](https://ore.spongepowered.org/KennyTV/Maintenance)
-* [Velocity forums](https://forums.velocitypowered.com/t/maintenance/129)
+
+## 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!
 
 ## Compiling
-To create a working jar yourself, simply clone the project and compile it with maven (by using `mvn clean package` in your IDE console).
+To create a working jar yourself, simply clone the project and compile it with Gradle (`gradlew build`). To compile, you need a JDK 21+ (although it targets 17).
 
-## Licence
-When modifying the project's code, do that on a public repository while also keeping it under the same license (see [GNU General Public License](http://www.gnu.org/licenses/gpl-3.0)).
+## License
+This project is licensed under the [GNU General Public License v3](LICENSE.txt).

api-proxy/build.gradle.kts

@@ -0,0 +1,12 @@
+plugins {
+    id("maintenance.shadow-conventions")
+}
+
+dependencies {
+    api(projects.maintenanceApi)
+    compileOnly(libs.adventureApi)
+}
+
+java {
+    withJavadocJar()
+}

api-proxy/src/main/java/eu/kennytv/maintenance/api/event/proxy/ServerMaintenanceChangedEvent.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.api.event.proxy;
 
 import eu.kennytv.maintenance.api.event.manager.MaintenanceEvent;
@@ -23,9 +22,6 @@ import eu.kennytv.maintenance.api.proxy.Server;
 
 /**
  * Notification event fired when maintenance mode has been changed on a proxied server.
- *
- * @author KennyTV
- * @since 3.0.1
  */
 public final class ServerMaintenanceChangedEvent implements MaintenanceEvent {
     private final Server server;
@@ -37,7 +33,12 @@ public final class ServerMaintenanceChangedEvent implements MaintenanceEvent {
     }
 
     /**
-     * @return wrapped server object for the proxied server
+     * Returns wrapped server object for the server.
+     * <br>
+     * This does not necessarily have to be an existing server:
+     * If maintenance is disabled on a *previously* registered server, see {@link Server#isRegisteredServer()}.
+     *
+     * @return wrapped server object for the server
      */
     public Server getServer() {
         return server;

api-proxy/src/main/java/eu/kennytv/maintenance/api/proxy/DummyServer.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,17 +15,11 @@
  * 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.api.proxy;
 
-package eu.kennytv.maintenance.core.proxy.server;
+import net.kyori.adventure.text.Component;
 
-import eu.kennytv.maintenance.api.proxy.Server;
-
-public final class DummyServer implements Server {
-    private final String name;
-
-    public DummyServer(final String name) {
-        this.name = name;
-    }
+public record DummyServer(String name) implements Server {
 
     @Override
     public String getName() {
@@ -38,6 +32,11 @@ public final class DummyServer implements Server {
     }
 
     @Override
-    public void broadcast(final String s) {
+    public void broadcast(final Component component) {
+    }
+
+    @Override
+    public boolean isRegisteredServer() {
+        return false;
     }
 }

api-proxy/src/main/java/eu/kennytv/maintenance/api/proxy/MaintenanceProxy.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,30 +15,29 @@
  * 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.api.proxy;
 
-import eu.kennytv.maintenance.api.IMaintenance;
-
+import eu.kennytv.maintenance.api.Maintenance;
 import java.util.Set;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author KennyTV
- * @since 3.0
- */
-public interface IMaintenanceProxy extends IMaintenance {
+public interface MaintenanceProxy extends Maintenance {
 
     /**
      * Enables/disables maintenance mode on a proxied server.
      * If enabled, all non-permitted players will be kicked.
-     * If MySQL is enabled, it will also be written into the database.
+     * If Redis is enabled, it will also be written into the database.
      *
      * @param server      server to apply the maintenance status to
      * @param maintenance true to enable, false to disable maintenance mode
      * @return true if the mode was changed
      * @see #getServer(String)
      */
-    boolean setMaintenanceToServer(Server server, boolean maintenance);
+    boolean setMaintenanceToServer(Server server, boolean maintenance, @Nullable String mode);
+
+    default boolean setMaintenanceToServer(final Server server, final boolean maintenance) {
+        return setMaintenanceToServer(server, maintenance, null);
+    }
 
     /**
      * @param server server to check
@@ -60,8 +59,28 @@ public interface IMaintenanceProxy extends IMaintenance {
      * @param server name of the proxied server
      * @return wrapped server object if present, else null
      */
+    @Nullable
     Server getServer(String server);
 
+    /**
+     * Returns a wrapped {@link Server} object of a proxied server, or a dummy server if not registered.
+     *
+     * @param serverName name of the proxied server
+     * @return wrapped server object, or a dummy if not registered
+     * @see Server#isRegisteredServer()
+     */
+    default Server getServerOrDummy(final String serverName) {
+        final Server server = getServer(serverName);
+        return server != null ? server : new DummyServer(serverName);
+    }
+
+    /**
+     * Returns the currently registered proxied servers.
+     *
+     * @return set of proxied servers
+     */
+    Set<String> getServers();
+
     /**
      * @return immutable set with names of all proxied server that are currently under maintenance
      */

api-proxy/src/main/java/eu/kennytv/maintenance/api/proxy/Server.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,15 +15,13 @@
  * 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.api.proxy;
 
+import net.kyori.adventure.text.Component;
+
 /**
  * Wrapper for a proxied server.
- * Use {@link IMaintenanceProxy#getServer(String)} to get a server instance.
- *
- * @author KennyTV
- * @since 3.0
+ * Use {@link MaintenanceProxy#getServer(String)} to get a server instance.
  */
 public interface Server {
 
@@ -40,7 +38,15 @@ public interface Server {
     /**
      * Sends a message to all players on the server.
      *
-     * @param message message to be broadcasted
+     * @param component message to be broadcasted
      */
-    void broadcast(String message);
+    void broadcast(Component component);
+
+    /**
+     * Returns whether the server is registered under the proxy.
+     * This will only ever be false if maintenance is disabled on a *previously* registered server.
+     *
+     * @return whether the server is registered under the proxy
+     */
+    boolean isRegisteredServer();
 }

api/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    id("maintenance.shadow-conventions")
+}
+
+dependencies {
+    compileOnlyApi(libs.jetbrainsAnnotations)
+}
+
+java {
+    withJavadocJar()
+}

api/src/main/java/eu/kennytv/maintenance/api/Maintenance.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,28 +15,29 @@
  * 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.api;
 
-import eu.kennytv.maintenance.api.event.manager.IEventManager;
+import eu.kennytv.maintenance.api.event.manager.EventManager;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author KennyTV
- * @since 2.1
- */
-public interface IMaintenance {
+public interface Maintenance {
 
     /**
      * Enables/disables maintenance mode.
      * If enabled, all non-permitted players will be kicked.
      * <p>
-     * If using the BungeeCord version and MySQL is enabled,
+     * If using the BungeeCord version and Redis is enabled,
      * it will also be written into the database.
      * </p>
      *
      * @param maintenance true to enable, false to disable maintenance mode
+     * @param mode        mode, used for custom messages
      */
-    void setMaintenance(boolean maintenance);
+    void setMaintenance(boolean maintenance, @Nullable String mode);
+
+    default void setMaintenance(boolean maintenance) {
+        setMaintenance(maintenance, null);
+    }
 
     /**
      * @return true if maintenance is currently enabled
@@ -54,16 +55,28 @@ public interface IMaintenance {
     String getVersion();
 
     /**
-     * Returns the {@link ISettings} instance, which gives further insight into settings set in the config files.
+     * Returns the {@link Settings} instance, which gives further insight into settings set in the config files.
      *
-     * @return {@link ISettings} instance
+     * @return {@link Settings} instance
      */
-    ISettings getSettings();
+    Settings getSettings();
 
     /**
-     * Returns the {@link IEventManager} instance to register listeners to maintenance events.
+     * Returns the {@link EventManager} instance to register listeners to maintenance events.
      *
-     * @return {@link IEventManager} instance
+     * @return {@link EventManager} instance
      */
-    IEventManager getEventManager();
+    EventManager getEventManager();
+
+    /**
+     * @return true if debug mode is enabled, currently only implemented on Bungee
+     */
+    boolean isDebug();
+
+    /**
+     * Sets the debug mode.
+     *
+     * @param debug debug state
+     */
+    void setDebug(boolean debug);
 }

api/src/main/java/eu/kennytv/maintenance/api/MaintenanceProvider.java

@@ -0,0 +1,49 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.api;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Provider to get the maintenance api instance.
+ */
+public final class MaintenanceProvider {
+    private static Maintenance maintenance;
+
+    private MaintenanceProvider() {
+        throw new IllegalArgumentException();
+    }
+
+    @ApiStatus.Internal
+    public static void setMaintenance(final Maintenance maintenance) {
+        if (MaintenanceProvider.maintenance != null) {
+            throw new IllegalArgumentException("MaintenanceProvider is already set!");
+        }
+        MaintenanceProvider.maintenance = maintenance;
+    }
+
+    /**
+     * Returns the maintenance api instance, or null if not loaded yet.
+     *
+     * @return maintenance api instance
+     */
+    public static @Nullable Maintenance get() {
+        return maintenance;
+    }
+}

api/src/main/java/eu/kennytv/maintenance/api/Settings.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,25 +15,48 @@
  * 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.api;
 
 import java.util.Map;
 import java.util.UUID;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author KennyTV
- * @since 2.1
- */
-public interface ISettings {
+public interface Settings {
 
     /**
-     * Note that the value might need a few seconds to update, if you're on BungeeCord with MySQL enabled
+     * Returns whether maintenance is currently enabled.
      *
      * @return true if maintenance is currently enabled
      */
     boolean isMaintenance();
 
+    /**
+     * Returns the current active maintenance mode, or null is set to default.
+     * Used when getting MOTD/player count messages.
+     *
+     * @return the current active maintenance mode, or null if set to default
+     */
+    @Nullable String activeMode();
+
+    /**
+     * Returns the reason for the current active mode.
+     *
+     * @return variable reason for the current active mode, or empty if no reason is set
+     */
+    String activeReason();
+
+    /**
+     * Sets the reason for the current active mode, used in %REASON% message placeholders.
+     *
+     * @param reason reason to set for the current active mode, or null to remove the reason
+     */
+    void setActiveReason(@Nullable String reason);
+
+    /**
+     * @return true if custom ping messages during maintenance should be used
+     */
+    boolean isEnablePingMessages();
+
     /**
      * @return value of the 'send-join-notification' config field
      */
@@ -73,8 +96,8 @@ public interface ISettings {
      *
      * @param name name of the player to remove with original lower-/uppercase letters
      * @return true if removing the player was successful
-     * @deprecated if a player changes their name, the list will still contain the old one
      * @see #removeWhitelistedPlayer(UUID)
+     * @deprecated if a player changes their name, the list will still contain the old one
      */
     @Deprecated
     boolean removeWhitelistedPlayer(String name);
@@ -84,7 +107,7 @@ public interface ISettings {
      *
      * @param uuid uuid of the player to add
      * @param name of the player to add
-     * @return true if adding the player was successful
+     * @return true if adding the player was successful, false if already on the whitelist
      */
     boolean addWhitelistedPlayer(UUID uuid, String name);
 

api/src/main/java/eu/kennytv/maintenance/api/event/MaintenanceChangedEvent.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,28 +15,12 @@
  * 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.api.event;
 
 import eu.kennytv.maintenance.api.event.manager.MaintenanceEvent;
 
 /**
  * Notification event fired when maintenance mode has been changed.
- *
- * @author KennyTV
- * @since 3.0.1
  */
-public final class MaintenanceChangedEvent implements MaintenanceEvent {
-    private final boolean maintenance;
-
-    public MaintenanceChangedEvent(final boolean maintenance) {
-        this.maintenance = maintenance;
-    }
-
-    /**
-     * @return true if maintenance has been enabled, false otherwise
-     */
-    public boolean isMaintenance() {
-        return maintenance;
-    }
+public record MaintenanceChangedEvent(boolean isMaintenance) implements MaintenanceEvent {
 }

api/src/main/java/eu/kennytv/maintenance/api/event/MaintenanceReloadedEvent.java

@@ -0,0 +1,31 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.api.event;
+
+import eu.kennytv.maintenance.api.Maintenance;
+import eu.kennytv.maintenance.api.event.manager.MaintenanceEvent;
+
+/**
+ * Notification event fired when Maintenance configuration is reloaded.
+ *
+ * @author kennytv
+ * @see Maintenance#isMaintenance() for the new maintenance status
+ * //@see MaintenanceProxy#getMaintenanceServers() for the new list of servers under maintenance
+ */
+public final class MaintenanceReloadedEvent implements MaintenanceEvent {
+}

api/src/main/java/eu/kennytv/maintenance/api/event/manager/EventListener.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,15 +15,12 @@
  * 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.api.event.manager;
 
 /**
  * Abstract class representing a maintenance eventlistener.
  *
  * @param <T> event to be listened to
- * @author KennyTV
- * @since 3.0.1
  */
 public abstract class EventListener<T extends MaintenanceEvent> {
 

api/src/main/java/eu/kennytv/maintenance/api/event/manager/EventManager.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,14 +15,9 @@
  * 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.api.event.manager;
 
-/**
- * @author KennyTV
- * @since 3.0.1
- */
-public interface IEventManager {
+public interface EventManager {
 
     /**
      * Registers an eventlistener for the given maintenance event.
@@ -31,4 +26,11 @@ public interface IEventManager {
      * @param eventClass class of the event that should be registered
      */
     void registerListener(EventListener listener, Class<? extends MaintenanceEvent> eventClass);
+
+    /**
+     * Fires a maintenance event.
+     *
+     * @param event event to fire
+     */
+    void callEvent(MaintenanceEvent event);
 }

api/src/main/java/eu/kennytv/maintenance/api/event/manager/MaintenanceEvent.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,14 +15,10 @@
  * 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.api.event.manager;
 
 /**
  * Dummy interface representing a maintenance event.
- *
- * @author KennyTV
- * @since 3.0.1
  */
 public interface MaintenanceEvent {
 }

build-logic/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+}
+
+dependencies {
+    // version must be manually kept in sync with the one in root project settings.gradle.kts
+    implementation("com.gradleup.shadow:shadow-gradle-plugin:9.6.1")
+    implementation("com.gradleup.nmcp:com.gradleup.nmcp.gradle.plugin:1.6.2")
+}

build-logic/src/main/kotlin/extensions.kt

@@ -0,0 +1,36 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.named
+
+fun Project.publishShadowJar() {
+    configurePublication {
+        artifact(tasks["shadowJar"])
+        artifact(tasks["sourcesJar"])
+        artifact(tasks["javadocJar"])
+    }
+}
+
+fun Project.publishJavaComponents() {
+    configurePublication {
+        from(components["java"])
+    }
+}
+
+private fun Project.configurePublication(configurer: MavenPublication.() -> Unit) {
+    extensions.configure<PublishingExtension> {
+        publications.named<MavenPublication>("mavenJava") {
+            apply(configurer)
+        }
+    }
+}
+
+fun Project.latestCommitHash(): String {
+    return providers.exec {
+        commandLine = listOf("git", "rev-parse", "--short", "HEAD")
+    }.standardOutput.asBytes.get().toString(Charsets.UTF_8).trim()
+}

build-logic/src/main/kotlin/maintenance.base-conventions.gradle.kts

@@ -0,0 +1,70 @@
+plugins {
+    `java-library`
+    `maven-publish`
+    signing
+    id("com.gradleup.nmcp")
+}
+
+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(mapOf("version" to ver, "description" to desc))
+        }
+    }
+    javadoc {
+        options.encoding = Charsets.UTF_8.name()
+        (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
+    }
+    compileJava {
+        options.encoding = Charsets.UTF_8.name()
+        options.compilerArgs.addAll(listOf("-nowarn", "-Xlint:-unchecked", "-Xlint:-deprecation"))
+    }
+    test {
+        useJUnitPlatform()
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+    withSourcesJar()
+    withJavadocJar()
+}
+
+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")
+            scm {
+                url.set("https://github.com/kennytv/Maintenance")
+                connection.set("scm:git:https://github.com/kennytv/Maintenance.git")
+                developerConnection.set("scm:git:ssh://git@github.com/kennytv/Maintenance.git")
+            }
+            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")
+                }
+            }
+        }
+    }
+}

build-logic/src/main/kotlin/maintenance.platform-conventions.gradle.kts

@@ -0,0 +1,12 @@
+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")
+        destinationDirectory.set(rootProject.layout.buildDirectory.dir("libs"))
+    }
+}

build-logic/src/main/kotlin/maintenance.shadow-conventions.gradle.kts

@@ -0,0 +1,32 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.jvm.tasks.Jar
+
+plugins {
+    id("maintenance.base-conventions")
+    id("com.gradleup.shadow")
+}
+
+tasks {
+    named<Jar>("jar") {
+        archiveClassifier.set("unshaded")
+        from(project.rootProject.file("LICENSE.txt"))
+    }
+    val shadowJar = named<ShadowJar>("shadowJar") {
+        archiveClassifier.set("")
+        configureRelocations()
+    }
+    named("build") {
+        dependsOn(shadowJar)
+    }
+}
+
+publishShadowJar()
+
+fun ShadowJar.configureRelocations() {
+    relocate("org.bstats", "eu.kennytv.maintenance.lib.bstats")
+
+    // Proxy
+    relocate("redis.client", "eu.kennytv.maintenance.lib.redis.client")
+    relocate("org.json", "eu.kennytv.maintenance.lib.json")
+    relocate("org.apache.commons.pool2", "eu.kennytv.maintenance.lib.apache.commons.pool2")
+}

build-logic/src/main/kotlin/maintenance.standard-conventions.gradle.kts

@@ -0,0 +1,5 @@
+plugins {
+    id("maintenance.base-conventions")
+}
+
+publishJavaComponents()

build.gradle.kts

@@ -0,0 +1,56 @@
+import org.gradle.api.plugins.JavaPlugin.TEST_IMPLEMENTATION_CONFIGURATION_NAME
+import org.gradle.api.plugins.JavaPlugin.TEST_RUNTIME_ONLY_CONFIGURATION_NAME
+
+plugins {
+    base
+    id("maintenance.build-logic")
+    id("com.gradleup.nmcp.aggregation") version "1.6.2"
+}
+
+allprojects {
+    group = "eu.kennytv.maintenance"
+    version = property("projectVersion") as String // from gradle.properties
+    description = "Enable maintenance mode with a custom maintenance motd and icon."
+}
+
+val platforms = setOf(
+    projects.maintenancePaper,
+    projects.maintenanceBungee,
+    projects.maintenanceSponge,
+    projects.maintenanceVelocity
+).map { it.path }
+
+val special = setOf(
+    projects.maintenanceApi,
+    projects.maintenanceApiProxy
+).map { it.path }
+
+subprojects {
+    when (path) {
+        in platforms -> plugins.apply("maintenance.platform-conventions")
+        in special -> plugins.apply("maintenance.base-conventions")
+        else -> plugins.apply("maintenance.standard-conventions")
+    }
+
+    dependencies {
+        TEST_IMPLEMENTATION_CONFIGURATION_NAME(rootProject.libs.bundles.junit)
+        TEST_IMPLEMENTATION_CONFIGURATION_NAME(rootProject.libs.snakeyaml)
+        TEST_RUNTIME_ONLY_CONFIGURATION_NAME("org.junit.platform:junit-platform-launcher")
+    }
+}
+
+dependencies {
+    allprojects {
+        nmcpAggregation(project(path))
+    }
+}
+
+nmcpAggregation {
+    centralPortal {
+        username = System.getenv("MAVEN_CENTRAL_USERNAME")
+        password = System.getenv("MAVEN_CENTRAL_PASSWORD")
+        publishingType = "USER_MANAGED"
+        publicationName = "maintenance:$version"
+        publishingTimeout = java.time.Duration.ZERO
+    }
+}

bungee/build.gradle.kts

@@ -0,0 +1,19 @@
+dependencies {
+    implementation(projects.maintenanceCoreProxy)
+    implementation(libs.bstatsBungee)
+    compileOnly(libs.bungee)
+}
+
+tasks {
+    shadowJar {
+        relocate("net.kyori", "eu.kennytv.maintenance.lib.kyori")
+    }
+}
+
+dependencies {
+    api(libs.bundles.adventureBungee) {
+        exclude("com.google.code.gson", "gson")
+        exclude("org.slf4j", "slf4j-api")
+        exclude("net.kyori", "adventure-bom")
+    }
+}

bungee/src/main/java/eu/kennytv/maintenance/bungee/MaintenanceBungeeBase.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,16 +15,15 @@
  * 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.IMaintenance;
-import eu.kennytv.maintenance.api.IMaintenanceBase;
+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 IMaintenanceBase {
+public final class MaintenanceBungeeBase extends Plugin implements MaintenanceBase {
     private MaintenanceBungeePlugin maintenance;
 
     @Override
@@ -38,7 +37,7 @@ public final class MaintenanceBungeeBase extends Plugin implements IMaintenanceB
     }
 
     @Override
-    public IMaintenance getApi() {
+    public Maintenance getApi() {
         return maintenance;
     }
 

bungee/src/main/java/eu/kennytv/maintenance/bungee/MaintenanceBungeePlugin.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,61 +15,60 @@
  * 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.bungee.MaintenanceBungeeAPI;
-import eu.kennytv.maintenance.api.proxy.IMaintenanceProxy;
 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 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.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 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.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
+import javax.imageio.ImageIO;
+import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
+import net.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.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.bstats.bungeecord.Metrics;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author KennyTV
- * @since 1.0
- */
 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;
@@ -83,32 +82,24 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
         pm.registerCommand(plugin, new MaintenanceBungeeCommandBase(commandManager));
 
         continueLastEndtimer();
-        new MetricsLite(plugin);
+        new Metrics(plugin, 742);
 
-        // ServerListPlus integration
         final Plugin serverListPlus = pm.getPlugin("ServerListPlus");
         if (serverListPlus != null) {
             serverListPlusHook = new ServerListPlusHook(serverListPlus);
-            serverListPlusHook.setEnabled(!settingsProxy.isMaintenance());
+            if (settings.isEnablePingMessages()) {
+                serverListPlusHook.setEnabled(!settingsProxy.isMaintenance());
+            }
             plugin.getLogger().info("Enabled ServerListPlus integration!");
         }
-    }
 
-    @Deprecated
-    public static IMaintenanceProxy getAPI() {
-        return MaintenanceBungeeAPI.getAPI();
-    }
-
-    @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 ComponentBuilder("§aDownload the latest version").create()));
-        tc1.addExtra(tc2);
-        tc1.addExtra(click);
-        ((BungeeSenderInfo) sender).sendMessage(tc1);
+        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");
+        }
     }
 
     public boolean isMaintenance(final ServerInfo serverInfo) {
@@ -117,42 +108,46 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
 
     @Override
     protected void kickPlayersFromProxy() {
-        for (final ProxiedPlayer p : getProxy().getPlayers()) {
-            if (!hasPermission(p, "bypass") && !settingsProxy.isWhitelisted(p.getUniqueId())) {
-                p.disconnect(settingsProxy.getKickMessage());
+        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) {
-        final ServerInfo fallbackServer = fallback != null ? ((BungeeServer) fallback).getServer() : null;
+        // Kick players from a proxied server
+        final ServerInfo fallbackServer = fallback != null ? ((BungeeServer) fallback).server() : null;
         final boolean checkForFallback = fallbackServer != null && !isMaintenance(fallback);
-        for (final ProxiedPlayer player : ((BungeeServer) server).getServer().getPlayers()) {
+        for (final ProxiedPlayer player : ((BungeeServer) server).server().getPlayers()) {
             if (!hasPermission(player, "bypass") && !settingsProxy.isWhitelisted(player.getUniqueId())) {
                 if (checkForFallback && fallbackServer.canAccess(player)) {
-                    player.sendMessage(settingsProxy.getMessage("singleMaintenanceActivated").replace("%SERVER%", server.getName()));
+                    audiences.player(player).sendMessage(settingsProxy.getMessage("singleMaintenanceActivated", "%SERVER%", server.getName()));
                     player.connect(fallbackServer);
-                } else
-                    player.disconnect(settingsProxy.getMessage("singleMaintenanceKickComplete").replace("%NEWLINE%", "\n").replace("%SERVER%", server.getName()));
+                } else {
+                    player.disconnect(ComponentUtil.toBadComponents(settingsProxy.getFullServerKickMessage(server.getName())));
+                }
             } else {
-                player.sendMessage(settingsProxy.getMessage("singleMaintenanceActivated").replace("%SERVER%", server.getName()));
+                audiences.player(player).sendMessage(settingsProxy.getMessage("singleMaintenanceActivated", "%SERVER%", server.getName()));
             }
         }
     }
 
     @Override
     protected void kickPlayersTo(final Server server) {
-        final ServerInfo serverInfo = ((BungeeServer) server).getServer();
+        // Kick all players to a single waiting server
+        final ServerInfo serverInfo = ((BungeeServer) server).server();
         // 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 (player.getServer() != null && player.getServer().getInfo().getName().equals(serverInfo.getName()))
+                continue;
             if (serverInfo.canAccess(player) && !isMaintenance(serverInfo)) {
-                player.sendMessage(settingsProxy.getMessage("sentToWaitingServer").replace("%SERVER%", server.getName()));
+                audiences.player(player).sendMessage(settingsProxy.getMessage("sentToWaitingServer", "%SERVER%", server.getName()));
                 player.connect(serverInfo);
             } else {
-                player.disconnect(settingsProxy.getKickMessage());
+                player.disconnect(ComponentUtil.toBadComponents(settingsProxy.getKickMessage()));
             }
         }
     }
@@ -163,26 +158,44 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
     }
 
     @Override
+    public CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(final String name) {
+        final ProxiedPlayer player = getProxy().getPlayer(name);
+        if (player != null) {
+            return CompletableFuture.completedFuture(new BungeeSenderInfo(player));
+        }
+
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                final ProfileLookup profile = doUUIDLookup(name);
+                return new ProxyOfflineSenderInfo(profile.uuid(), profile.name());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(final UUID uuid) {
+        final ProxiedPlayer player = getProxy().getPlayer(uuid);
+        return CompletableFuture.completedFuture(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 SenderInfo getOfflinePlayer(final String name) {
-        final ProxiedPlayer player = getProxy().getPlayer(name);
-        return player != null ? new BungeeSenderInfo(player) : null;
+    public Set<String> getServers() {
+        return getProxy().getServers().keySet();
     }
 
     @Override
-    public SenderInfo getOfflinePlayer(final UUID uuid) {
-        final ProxiedPlayer player = getProxy().getPlayer(uuid);
-        return player != null ? new BungeeSenderInfo(player) : null;
-    }
-
-    @Override
-    public String getServer(final SenderInfo sender) {
-        final ProxiedPlayer player = getProxy().getPlayer(sender.getUuid());
+    @Nullable
+    public String getServerNameOf(final SenderInfo sender) {
+        final ProxiedPlayer player = getProxy().getPlayer(sender.uuid());
         if (player == null || player.getServer() == null) return null;
         return player.getServer().getInfo().getName();
     }
@@ -193,8 +206,13 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
     }
 
     @Override
-    public void broadcast(final String message) {
-        getProxy().broadcast(message);
+    protected void executeConsoleCommand(final String command) {
+        getProxy().getPluginManager().dispatchCommand(getProxy().getConsole(), command);
+    }
+
+    @Override
+    public void broadcast(final Component component) {
+        audiences.all().sendMessage(component);
     }
 
     @Override
@@ -207,6 +225,16 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
         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);
@@ -244,4 +272,8 @@ public final class MaintenanceBungeePlugin extends MaintenanceProxyPlugin {
     public Favicon getFavicon() {
         return favicon;
     }
+
+    public BungeeAudiences audiences() {
+        return audiences;
+    }
 }

bungee/src/main/java/eu/kennytv/maintenance/bungee/command/MaintenanceBungeeCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,23 +15,17 @@
  * 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.Locale;
 import java.util.Map;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 public final class MaintenanceBungeeCommand extends MaintenanceProxyCommand {
     private final MaintenanceBungeePlugin plugin;
@@ -42,36 +36,18 @@ public final class MaintenanceBungeeCommand extends MaintenanceProxyCommand {
         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)) {
+            if (entry.getKey().toLowerCase(Locale.ROOT).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<>();

bungee/src/main/java/eu/kennytv/maintenance/bungee/command/MaintenanceBungeeCommandBase.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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;
@@ -28,10 +27,15 @@ public final class MaintenanceBungeeCommandBase extends Command implements TabEx
     private final MaintenanceCommand command;
 
     public MaintenanceBungeeCommandBase(final MaintenanceCommand command) {
-        super("maintenance", "", "maintenancebungee");
+        super("maintenance", "maintenance.command", "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);

bungee/src/main/java/eu/kennytv/maintenance/bungee/listener/ProxyPingListener.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,16 +15,15 @@
  * 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;
-import net.md_5.bungee.event.EventPriority;
 
 public final class ProxyPingListener implements Listener {
     private final MaintenanceBungeePlugin plugin;
@@ -35,26 +34,38 @@ public final class ProxyPingListener implements Listener {
         this.settings = settings;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = 80)
     public void proxyPing(final ProxyPingEvent event) {
-        if (!settings.isMaintenance()) return;
+        if (!settings.isMaintenance()) {
+            return;
+        }
 
         final ServerPing ping = event.getResponse();
         if (settings.hasCustomPlayerCountMessage()) {
-            ping.getVersion().setProtocol(1);
-            ping.getVersion().setName(settings.getPlayerCountMessage()
-                    .replace("%ONLINE%", Integer.toString(ping.getPlayers().getOnline()))
-                    .replace("%MAX%", Integer.toString(ping.getPlayers().getMax())));
+            ping.setVersion(new ServerPing.Protocol(settings.getLegacyParsedPlayerCountMessage(), 1));
         }
 
-        ping.setDescription(settings.getRandomPingMessage());
-        ping.getPlayers().setOnline(0);
-        ping.getPlayers().setMax(0);
-        ping.getPlayers().setSample(new ServerPing.PlayerInfo[]{
-                new ServerPing.PlayerInfo(settings.getPlayerCountHoverMessage().replace("%NEWLINE%", "\n"), "")
-        });
+        if (settings.isEnablePingMessages()) {
+            ping.setDescriptionComponent(ComponentUtil.toBadComponents(settings.getRandomPingMessage()));
+        }
 
-        if (settings.hasCustomIcon() && plugin.getFavicon() != null)
+        if (settings.hasCustomPlayerCountHoverMessage()) {
+            ServerPing.Players players = ping.getPlayers();
+            if (players == null) {
+                players = new ServerPing.Players(0, 0, null);
+                ping.setPlayers(players);
+            }
+
+            final String[] lines = settings.getLegacyParsedPlayerCountHoverLines();
+            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());
+        }
     }
 }

bungee/src/main/java/eu/kennytv/maintenance/bungee/listener/ServerConnectListener.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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;
@@ -25,9 +24,8 @@ 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 net.kyori.adventure.text.Component;
 import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.event.ServerConnectEvent;
 import net.md_5.bungee.api.plugin.Listener;
@@ -47,19 +45,29 @@ public final class ServerConnectListener extends ProxyJoinListenerBase implement
         // Global maintenance check
         if (event.isCancelled() || event.getReason() != ServerConnectEvent.Reason.JOIN_PROXY) return;
 
-        final BungeeSenderInfo sender = new BungeeSenderInfo(event.getPlayer());
-        if (shouldKick(sender)) {
-            final Server waitingServer = shouldConnectToWaitingServer(sender);
+        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.uuid()));
+        }
+
+        if (shouldKick(player)) {
+            final Server waitingServer = shouldConnectToWaitingServer(player);
             if (waitingServer != null) {
-                event.setTarget(((BungeeServer) waitingServer).getServer());
-                sender.sendMessage(settings.getMessage("sentToWaitingServer"));
+                event.setTarget(((BungeeServer) waitingServer).server());
+                player.send(settings.getMessage("sentToWaitingServer"));
+
+                if (plugin.isDebug()) {
+                    plugin.getLogger().info("Join to waiting server for " + event.getPlayer().getName());
+                }
                 return;
             }
 
             event.setCancelled(true);
-            event.getPlayer().disconnect(settings.getKickMessage());
+
+            player.disconnect(settings.getKickMessage());
             if (settings.isJoinNotifications()) {
-                broadcastJoinNotification(sender.getName());
+                broadcastJoinNotification(player.name());
             }
         }
     }
@@ -69,19 +77,24 @@ public final class ServerConnectListener extends ProxyJoinListenerBase implement
         // Server specific maintenance check
         if (event.isCancelled()) return;
 
-        final ProxiedPlayer player = event.getPlayer();
+        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 ServerConnectResult connectResult = serverConnect(new BungeeSenderInfo(player), new BungeeServer(event.getTarget()), normalServerConnect);
+        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.name() + " to " + event.getTarget().getName() + ": " + connectResult);
+        }
+
         if (connectResult.isCancelled()) {
             event.setCancelled(true);
 
             // Player has no server to connect to
-            if (player.getServer() == null) {
+            if (proxiedPlayer.getServer() == null) {
                 player.disconnect(settings.getKickMessage());
             }
         } else if (connectResult.getTarget() != null) {
-            event.setTarget(((BungeeServer) connectResult.getTarget()).getServer());
+            event.setTarget(((BungeeServer) connectResult.getTarget()).server());
         }
     }
 
@@ -92,14 +105,14 @@ public final class ServerConnectListener extends ProxyJoinListenerBase implement
 
     @Override
     protected void broadcastJoinNotification(final String name, final Server server) {
-        sendJoinMessage(((BungeeServer) server).getServer().getPlayers(), name);
+        sendJoinMessage(((BungeeServer) server).server().getPlayers(), name);
     }
 
     private void sendJoinMessage(final Iterable<ProxiedPlayer> players, final String name) {
-        final BaseComponent[] message = TextComponent.fromLegacyText(settings.getMessage("joinNotification").replace("%PLAYER%", name));
+        final Component component = settings.getMessage("joinNotification", "%PLAYER%", name);
         for (final ProxiedPlayer player : players) {
             if (plugin.hasPermission(player, "joinnotification")) {
-                player.sendMessage(message);
+                plugin.audiences().player(player).sendMessage(component);
             }
         }
     }

bungee/src/main/java/eu/kennytv/maintenance/bungee/util/BungeeSenderInfo.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,11 +15,13 @@
  * 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 net.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;
@@ -35,12 +37,12 @@ public final class BungeeSenderInfo implements ProxySenderInfo {
     }
 
     @Override
-    public UUID getUuid() {
-        return sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null;
+    public UUID uuid() {
+        return sender instanceof ProxiedPlayer proxiedPlayer ? proxiedPlayer.getUniqueId() : null;
     }
 
     @Override
-    public String getName() {
+    public String name() {
         return sender.getName();
     }
 
@@ -50,8 +52,8 @@ public final class BungeeSenderInfo implements ProxySenderInfo {
     }
 
     @Override
-    public void sendMessage(final String message) {
-        sender.sendMessage(message);
+    public void send(final Component component) {
+        ((MaintenanceBungeePlugin) MaintenanceProvider.get()).audiences().sender(sender).sendMessage(component);
     }
 
     @Override
@@ -65,13 +67,13 @@ public final class BungeeSenderInfo implements ProxySenderInfo {
 
     @Override
     public boolean canAccess(final Server server) {
-        return ((BungeeServer) server).getServer().canAccess(sender);
+        return ((BungeeServer) server).server().canAccess(sender);
     }
 
     @Override
-    public void disconnect(final String message) {
-        if (sender instanceof Connection) {
-            ((Connection) sender).disconnect(message);
+    public void disconnect(final Component component) {
+        if (sender instanceof Connection connection) {
+            connection.disconnect(ComponentUtil.toBadComponent(component));
         }
     }
 }

bungee/src/main/java/eu/kennytv/maintenance/bungee/util/BungeeServer.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,21 +15,15 @@
  * 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 net.kyori.adventure.text.Component;
 import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
 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;
-    }
+public record BungeeServer(ServerInfo server) implements Server {
 
     @Override
     public String getName() {
@@ -42,14 +36,15 @@ public final class BungeeServer implements Server {
     }
 
     @Override
-    public void broadcast(final String message) {
-        final BaseComponent[] s = TextComponent.fromLegacyText(message);
-        for (final ProxiedPlayer p : server.getPlayers()) {
-            p.sendMessage(s);
+    public void broadcast(final Component component) {
+        final BaseComponent[] components = ComponentUtil.toBadComponent(component);
+        for (final ProxiedPlayer player : server.getPlayers()) {
+            player.sendMessage(components);
         }
     }
 
-    public ServerInfo getServer() {
-        return server;
+    @Override
+    public boolean isRegisteredServer() {
+        return true;
     }
 }

bungee/src/main/java/eu/kennytv/maintenance/bungee/util/BungeeTask.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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;

bungee/src/main/java/eu/kennytv/maintenance/bungee/util/ComponentUtil.java

@@ -0,0 +1,35 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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 net.kyori.adventure.text.Component;
+import net.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)));
+    }
+}

bungee/src/main/resources/bungee.yml

@@ -0,0 +1,7 @@
+name: Maintenance
+version: ${version}
+main: eu.kennytv.maintenance.bungee.MaintenanceBungeeBase
+author: kennytv
+description: ${description}
+softDepends: [ServerListPlus, LuckPerms]
+website: https://hangar.papermc.io/kennytv/Maintenance

core-proxy/build.gradle.kts

@@ -0,0 +1,18 @@
+dependencies {
+    api(projects.maintenanceApiProxy)
+    api(projects.maintenanceCore)
+
+    // Try to reasonably minimize it...
+    implementation(libs.jedis) {
+        exclude("com.google.code.gson", "gson")
+        exclude("org.slf4j", "slf4j-api")
+    }
+
+    compileOnly(libs.luckperms)
+    compileOnly(libs.guava)
+    compileOnly(libs.gson)
+}
+
+java {
+    withJavadocJar()
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/MaintenanceProxyPlugin.java

@@ -0,0 +1,323 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy;
+
+import com.google.common.io.CharStreams;
+import com.google.gson.JsonObject;
+import eu.kennytv.maintenance.api.event.proxy.ServerMaintenanceChangedEvent;
+import eu.kennytv.maintenance.api.proxy.MaintenanceProxy;
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.proxy.command.MaintenanceProxyCommand;
+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.DiscordWebhook;
+import eu.kennytv.maintenance.core.util.RateLimitedException;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import eu.kennytv.maintenance.core.util.ServerType;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URI;
+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;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Level;
+import java.util.regex.Pattern;
+import org.jetbrains.annotations.Blocking;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author kennytv
+ * @since 3.0
+ */
+public abstract class MaintenanceProxyPlugin extends MaintenancePlugin implements MaintenanceProxy {
+    private static final Pattern USERNAME_PATTERN = Pattern.compile("^[A-Za-z0-9_.]{1,16}$");
+    private final Map<String, MaintenanceRunnableBase> serverTasks = new HashMap<>();
+    protected SettingsProxy settingsProxy;
+
+    protected MaintenanceProxyPlugin(final String version, final ServerType serverType) {
+        super(version, serverType);
+    }
+
+    @Override
+    public void disable() {
+        super.disable();
+        if (settingsProxy.redisHandler() != null) {
+            settingsProxy.redisHandler().close();
+        }
+    }
+
+    @Override
+    public boolean isMaintenance(final Server server) {
+        return settingsProxy.isMaintenance(server.getName());
+    }
+
+    @Override
+    public boolean setMaintenanceToServer(final Server server, final boolean maintenance, @Nullable final String mode) {
+        if (maintenance) {
+            if (settingsProxy.addMaintenanceServer(server.getName(), mode)) {
+                serverActions(server, true);
+                return true;
+            }
+            return mode != null && settingsProxy.setMaintenanceServerMode(server.getName(), mode);
+        }
+
+        if (!settingsProxy.removeMaintenanceServer(server.getName())) {
+            return false;
+        }
+
+        serverActions(server, false);
+        return true;
+    }
+
+    @Override
+    public boolean setMaintenanceToServer(final Server server, final boolean maintenance) {
+        return setMaintenanceToServer(server, maintenance, null);
+    }
+
+    public boolean setMaintenanceModeToServer(final Server server, @Nullable final String mode) {
+        if (!settingsProxy.isMaintenance(server.getName())) {
+            return false;
+        }
+        return settingsProxy.setMaintenanceServerMode(server.getName(), mode);
+    }
+
+    public @Nullable String activeMode(final Server server) {
+        return settingsProxy.activeMode(server.getName());
+    }
+
+    public void serverActions(final Server server, final boolean maintenance) {
+        if (server == null) {
+            return;
+        }
+
+        // Skip to the even fire for dummy servers
+        if (server.isRegisteredServer()) {
+            if (maintenance) {
+                final Server fallback = settingsProxy.getFallbackServer();
+                if (fallback == null) {
+                    if (server.hasPlayers()) {
+                        getLogger().warning("The set fallback could not be found! Instead kicking players from that server off the network!");
+                    }
+                }
+                kickPlayers(server, fallback);
+            } else {
+                server.broadcast(settingsProxy.getMessage("singleMaintenanceDeactivated", "%SERVER%", server.getName()));
+            }
+
+            cancelSingleTask(server);
+        }
+
+        eventManager.callEvent(new ServerMaintenanceChangedEvent(server, maintenance));
+        if (maintenance) {
+            sendWebhookMessage("webhookSingleMaintenanceActivated", DiscordWebhook.EventType.MAINTENANCE_ENABLED, "%SERVER%", server.getName());
+        } else {
+            sendWebhookMessage("webhookSingleMaintenanceDeactivated", DiscordWebhook.EventType.MAINTENANCE_DISABLED, "%SERVER%", server.getName());
+        }
+
+        for (final String command : (maintenance ? settingsProxy.getCommandsOnMaintenanceEnable(server) : settingsProxy.getCommandsOnMaintenanceDisable(server))) {
+            try {
+                executeConsoleCommand(command.replace("%SERVER%", server.getName()));
+            } catch (final Exception e) {
+                getLogger().log(Level.SEVERE, "Error while executing extra maintenance " + (maintenance ? "enable" : "disable") + " command: " + command, e);
+            }
+        }
+    }
+
+    @Override
+    public boolean isServerTaskRunning(final Server server) {
+        return serverTasks.containsKey(server.getName());
+    }
+
+    public boolean hasServerTasks() {
+        return !serverTasks.isEmpty();
+    }
+
+    public Map<String, MaintenanceRunnableBase> getServerTasks() {
+        return serverTasks;
+    }
+
+    public MaintenanceRunnableBase getServerTask(final String server) {
+        return serverTasks.get(server);
+    }
+
+    @Override
+    public Set<String> getMaintenanceServers() {
+        return Collections.unmodifiableSet(settingsProxy.getMaintenanceServers());
+    }
+
+    public void cancelSingleTask(final Server server) {
+        final MaintenanceRunnableBase task = serverTasks.remove(server.getName());
+        if (task != null) {
+            task.getTask().cancel();
+        }
+    }
+
+    public MaintenanceRunnableBase startSingleMaintenanceRunnable(final Server server, final Duration duration, final boolean enable, @Nullable final String mode) {
+        final MaintenanceRunnableBase runnable = new SingleMaintenanceRunnable(this, settingsProxy, (int) duration.getSeconds(), enable, server, mode);
+        serverTasks.put(server.getName(), runnable);
+        return runnable;
+    }
+
+    public MaintenanceRunnableBase startSingleMaintenanceRunnable(final Server server, final Duration duration, final boolean enable) {
+        return startSingleMaintenanceRunnable(server, duration, enable, null);
+    }
+
+    public MaintenanceRunnableBase scheduleSingleMaintenanceRunnable(final Server server, final Duration enableIn,
+                                                                     final Duration maintenanceDuration, @Nullable final String mode) {
+        final MaintenanceRunnableBase runnable = new SingleMaintenanceScheduleRunnable(this, settingsProxy,
+                (int) enableIn.getSeconds(), (int) maintenanceDuration.getSeconds(), server, mode);
+        serverTasks.put(server.getName(), runnable);
+        return runnable;
+    }
+
+    @Override
+    @Nullable
+    public List<String> getMaintenanceServersDump() {
+        final List<String> list = new ArrayList<>();
+        if (isMaintenance()) {
+            list.add("global");
+        }
+        list.addAll(settingsProxy.getMaintenanceServers());
+        return list.isEmpty() ? null : list;
+    }
+
+    @Override
+    public MaintenanceProxyCommand getCommandManager() {
+        return (MaintenanceProxyCommand) commandManager;
+    }
+
+    @Override
+    protected void kickPlayers() {
+        // Send players to waiting server is set
+        if (settingsProxy.getWaitingServer() != null) {
+            final Server waitingServer = getServer(settingsProxy.getWaitingServer());
+            if (waitingServer != null) {
+                kickPlayersTo(waitingServer);
+                return;
+            }
+        }
+
+        // If not set, kick players from proxy
+        kickPlayersFromProxy();
+    }
+
+    @Blocking
+    @Nullable
+    protected ProfileLookup doUUIDLookup(final String name) throws IOException {
+        ProfileLookup profileLookup = null;
+        if (USERNAME_PATTERN.matcher(name).matches()) {
+            try {
+                profileLookup = doUUIDLookupMojangAPI(name);
+            } catch (RateLimitedException e) {
+                // Use fallback API if rate limit is reached
+                profileLookup = doUUIDLookupAshconAPI(name);
+            }
+        }
+
+        if (profileLookup == null && settingsProxy.isFallbackToOfflineUUID()) {
+            // 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 = URI.create("https://api.mojang.com/users/profiles/minecraft/" + name).toURL();
+        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 = URI.create("https://api.ashcon.app/mojang/v2/user/" + name).toURL();
+        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);
+
+            final UUID uuid = UUID.fromString(json.getAsJsonPrimitive("uuid").getAsString());
+            final String username = json.getAsJsonPrimitive("username").getAsString();
+            return new ProfileLookup(uuid, username);
+        }
+    }
+
+    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;
+    }
+
+    @Nullable
+    public abstract String getServerNameOf(SenderInfo sender);
+
+    protected abstract void kickPlayers(Server server, Server fallback);
+
+    protected abstract void kickPlayersTo(Server server);
+
+    protected abstract void kickPlayersFromProxy();
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/SettingsProxy.java

@@ -0,0 +1,318 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy;
+
+import eu.kennytv.maintenance.api.proxy.MaintenanceProxy;
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.Settings;
+import eu.kennytv.maintenance.core.config.ConfigSection;
+import eu.kennytv.maintenance.core.proxy.redis.RedisHandler;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Level;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
+
+public final class SettingsProxy extends Settings {
+
+    private Map<String, 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 RedisHandler redisHandler;
+
+    public SettingsProxy(final MaintenanceProxyPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    protected void loadExtraSettings() {
+        // Open Redis connection if enabled and not already done
+        final ConfigSection redisSection = config.getSection("redis");
+        if (!hasRedis() && redisSection.getBoolean("enabled")) {
+            connectToRedis(redisSection.getString("uri"));
+        }
+        if (hasRedis()) {
+            maintenance = redisHandler.loadMaintenanceStatus();
+            activeMode = normalizeMode(redisHandler.loadGlobalMode());
+            maintenanceServers = redisHandler.loadMaintenanceServers();
+        }
+
+        final Object fallback = config.getObject("fallback");
+        fallbackServers = fallback instanceof String s ? Collections.singletonList(s) : config.getStringList("fallback", Collections.emptyList());
+
+        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 (!hasRedis()) {
+            final ConfigSection maintenanceServersSection = config.getSection("proxied-maintenance-servers");
+            maintenanceServers = new LinkedHashMap<>();
+            for (final Map.Entry<String, ?> entry : maintenanceServersSection.getValues().entrySet()) {
+                if (entry.getKey() != null) {
+                    maintenanceServers.put(entry.getKey(), normalizeServerMode(entry.getValue()));
+                }
+            }
+        }
+    }
+
+    private void connectToRedis(final String redisUri) {
+        redisHandler = new RedisHandler((MaintenanceProxyPlugin) plugin, this);
+        try {
+            redisHandler.setup(redisUri);
+        } catch (final Exception e) {
+            plugin.getLogger().log(Level.SEVERE, "Error while trying to open Redis connection!", e);
+            e.printStackTrace();
+            redisHandler.close();
+            redisHandler = null;
+        }
+    }
+
+    public boolean isMaintenance(final String serverName) {
+        return maintenanceServers.containsKey(serverName);
+    }
+
+    public @Nullable String activeMode(final String serverName) {
+        final String mode = maintenanceServers.get(serverName);
+        return mode == null || mode.equals("default") ? null : mode;
+    }
+
+    public Component getServerKickMessage(final String server) {
+        String message = getLanguageStringOrNull("singleMaintenanceKicks." + server, "%SERVER%", server);
+        if (message == null) {
+            message = getLanguageString("singleMaintenanceKick", "%SERVER%", server);
+        }
+        return parse(plugin.replacePingVariables(message, activeMode(server)));
+    }
+
+    public Component getFullServerKickMessage(final String server) {
+        String message = getLanguageStringOrNull("singleMaintenanceKicksComplete." + server, "%SERVER%", server);
+        if (message == null) {
+            message = getLanguageString("singleMaintenanceKickComplete", "%SERVER%", server);
+        }
+        return parse(plugin.replacePingVariables(message, activeMode(server)));
+    }
+
+    public boolean hasRedis() {
+        return redisHandler != null;
+    }
+
+    @Override
+    protected void loadWhitelistedPlayers() {
+        if (hasRedis()) {
+            redisHandler.loadPlayers(getWhitelistedPlayers());
+        } else {
+            super.loadWhitelistedPlayers();
+        }
+    }
+
+    @Override
+    public void setMaintenance(final boolean maintenance, @Nullable final String mode) {
+        super.setMaintenance(maintenance, mode);
+        if (hasRedis()) {
+            redisHandler.set(maintenance, mode != null ? mode : "default");
+        }
+    }
+
+    @Override
+    public void setActiveMode(@Nullable final String activeMode) {
+        super.setActiveMode(activeMode);
+        if (hasRedis() && isMaintenance()) {
+            redisHandler.set(true, activeMode != null ? activeMode : "default");
+        }
+    }
+
+    public void setActiveModeDirect(@Nullable final String activeMode) {
+        super.setActiveMode(activeMode);
+    }
+
+    public void setMaintenanceDirect(final boolean maintenance, @Nullable final String mode) {
+        super.setMaintenance(maintenance, mode);
+    }
+
+    @Override
+    public boolean addWhitelistedPlayer(final UUID uuid, final String name) {
+        if (super.addWhitelistedPlayer(uuid, name)) {
+            if (hasRedis()) {
+                redisHandler.addPlayer(uuid, name);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean addWhitelistedPlayerDirect(final UUID uuid, final String name) {
+        return super.addWhitelistedPlayer(uuid, name);
+    }
+
+    @Override
+    public boolean removeWhitelistedPlayer(final UUID uuid) {
+        if (super.removeWhitelistedPlayer(uuid)) {
+            if (hasRedis()) {
+                redisHandler.removePlayer(uuid);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean removeWhitelistedPlayerDirect(final UUID uuid) {
+        return super.removeWhitelistedPlayer(uuid);
+    }
+
+    boolean addMaintenanceServer(final String server, @Nullable final String mode) {
+        final String normalizedMode = normalizeServerMode(mode);
+        if (hasRedis()) {
+            if (redisHandler.addServer(server, normalizedMode)) {
+                maintenanceServers.put(server, normalizedMode);
+                return true;
+            }
+        } else if (maintenanceServers.putIfAbsent(server, normalizedMode) == null) {
+            saveServersToConfig();
+            return true;
+        }
+        return false;
+    }
+
+    boolean setMaintenanceServerMode(final String server, @Nullable final String mode) {
+        final String normalizedMode = normalizeServerMode(mode);
+        final String oldMode = maintenanceServers.get(server);
+        if (oldMode == null || oldMode.equals(normalizedMode)) {
+            return false;
+        }
+
+        maintenanceServers.put(server, normalizedMode);
+        if (hasRedis()) {
+            redisHandler.setServerMode(server, normalizedMode);
+        } else {
+            saveServersToConfig();
+        }
+        return true;
+    }
+
+    boolean removeMaintenanceServer(final String server) {
+        if (hasRedis()) {
+            if (redisHandler.removeServer(server)) {
+                maintenanceServers.remove(server);
+                return true;
+            }
+        } else if (maintenanceServers.remove(server) != null) {
+            saveServersToConfig();
+            return true;
+        }
+        return false;
+    }
+
+    public boolean addMaintenanceServerDirect(final String server, @Nullable final String mode) {
+        return maintenanceServers.put(server, normalizeServerMode(mode)) == null;
+    }
+
+    public boolean removeMaintenanceServerDirect(final String server) {
+        return maintenanceServers.remove(server) != null;
+    }
+
+    public void setMaintenanceServerModeDirect(final String server, @Nullable final String mode) {
+        if (maintenanceServers.containsKey(server)) {
+            maintenanceServers.put(server, normalizeServerMode(mode));
+        }
+    }
+
+    private void saveServersToConfig() {
+        config.set("proxied-maintenance-servers", new LinkedHashMap<>(maintenanceServers));
+        saveConfig();
+    }
+
+    public Set<String> getMaintenanceServers() {
+        return maintenanceServers.keySet();
+    }
+
+    @Nullable
+    public Server getFallbackServer() {
+        for (final String fallbackServer : fallbackServers) {
+            final Server server = ((MaintenanceProxy) plugin).getServer(fallbackServer);
+            if (server != null && !isMaintenance(server.getName())) {
+                return server;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public String getWaitingServer() {
+        return waitingServer;
+    }
+
+    public boolean isFallbackToOfflineUUID() {
+        return fallbackToOfflineUUID;
+    }
+
+    public List<String> getCommandsOnMaintenanceEnable(final Server server) {
+        final List<String> enableCommands = new ArrayList<>(commandsOnMaintenanceEnable.getOrDefault("all", Collections.emptyList()));
+        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 = new ArrayList<>(commandsOnMaintenanceDisable.getOrDefault("all", Collections.emptyList()));
+        final List<String> serverDisableCommands = commandsOnMaintenanceDisable.get(server.getName().toLowerCase(Locale.ROOT));
+        if (serverDisableCommands != null) {
+            disableCommands.addAll(serverDisableCommands);
+        }
+        return disableCommands;
+    }
+
+    public @Nullable RedisHandler redisHandler() {
+        return redisHandler;
+    }
+
+    private static String normalizeServerMode(@Nullable final Object mode) {
+        if (mode == null) {
+            return "default";
+        }
+        final String value = String.valueOf(mode).toLowerCase(Locale.ROOT);
+        return value.isBlank() ? "default" : value;
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/MaintenanceProxyCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.proxy.command;
 
 import eu.kennytv.maintenance.api.proxy.Server;
@@ -27,6 +26,7 @@ import eu.kennytv.maintenance.core.util.SenderInfo;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
 public abstract class MaintenanceProxyCommand extends MaintenanceCommand {
     private final MaintenanceProxyPlugin plugin;
@@ -41,10 +41,11 @@ public abstract class MaintenanceProxyCommand extends MaintenanceCommand {
     @Override
     protected void addToggleAndTimerCommands() {
         add(new SingleToggleCommand(plugin), "on", "off");
-        add(new StatusCommand(plugin), "status");
+        add(new ProxyStatusCommand(plugin), "status");
 
         add(new SingleStarttimerCommand(plugin), "starttimer", "start");
         add(new SingleEndtimerCommand(plugin), "endtimer", "end");
+        add(new SingleScheduleTimerCommand(plugin), "scheduletimer", "schedule");
         add(new AbortSingleTimerCommand(plugin), "aborttimer", "abort");
     }
 
@@ -52,21 +53,21 @@ public abstract class MaintenanceProxyCommand extends MaintenanceCommand {
     public List<String> getMaintenanceServersCompletion(final String s) {
         final List<String> list = new ArrayList<>();
         for (final String server : settingsBungee.getMaintenanceServers()) {
-            if (server.toLowerCase().startsWith(s)) {
+            if (server.toLowerCase(Locale.ROOT).startsWith(s)) {
                 list.add(server);
             }
         }
         return list;
     }
 
-    public Server checkSingleTimerArgs(final SenderInfo sender, final String[] args) {
-        final Server server = plugin.getServer(args[1]);
+    public Server checkSingleTimerServerArg(final SenderInfo sender, final String serverName) {
+        final Server server = plugin.getServer(serverName);
         if (server == null) {
-            sender.sendMessage(settings.getMessage("serverNotFound"));
+            sender.send(settings.getMessage("serverNotFound"));
             return null;
         }
         if (plugin.isServerTaskRunning(server)) {
-            sender.sendMessage(settings.getMessage("singleTimerAlreadyRunning"));
+            sender.send(settings.getMessage("singleTimerAlreadyRunning"));
             return null;
         }
         return server;

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/ProxyCommandInfo.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,12 +15,13 @@
  * 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.proxy.command;
 
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import java.util.ArrayList;
+import java.util.List;
 
 public abstract class ProxyCommandInfo extends CommandInfo {
     protected final MaintenanceProxyPlugin plugin;
@@ -34,4 +35,10 @@ public abstract class ProxyCommandInfo extends CommandInfo {
     protected SettingsProxy getSettings() {
         return plugin.getSettingsProxy();
     }
+
+    protected List<String> getModesCompletion() {
+        final List<String> modes = new ArrayList<>(getSettings().getPingMessages().getKeys());
+        modes.remove("default");
+        return modes;
+    }
 }

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/AbortSingleTimerCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.proxy.command.subcommand;
 
 import eu.kennytv.maintenance.api.proxy.Server;
@@ -23,8 +22,10 @@ import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
 import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 
 public final class AbortSingleTimerCommand extends ProxyCommandInfo {
 
@@ -42,32 +43,43 @@ public final class AbortSingleTimerCommand extends ProxyCommandInfo {
         if (args.length == 1) {
             if (checkPermission(sender, "timer")) return;
             if (!plugin.isTaskRunning()) {
-                sender.sendMessage(getMessage("timerNotRunning"));
+                sender.send(getMessage("timerNotRunning"));
                 return;
             }
 
             plugin.cancelTask();
-            sender.sendMessage(getMessage("timerCancelled"));
+            sender.send(getMessage("timerCancelled"));
         } else if (args.length == 2) {
             if (checkPermission(sender, "singleserver.timer")) return;
             final Server server = plugin.getServer(args[1]);
             if (server == null) {
-                sender.sendMessage(getMessage("serverNotFound"));
+                sender.send(getMessage("serverNotFound"));
                 return;
             }
             if (!plugin.isServerTaskRunning(server)) {
-                sender.sendMessage(getMessage("singleTimerNotRunning"));
+                sender.send(getMessage("singleTimerNotRunning"));
                 return;
             }
 
             plugin.cancelSingleTask(server);
-            sender.sendMessage(getMessage("singleTimerCancelled"));
+            sender.send(getMessage("singleTimerCancelled", "%SERVER%", server.getName()));
         } else
-            sender.sendMessage(getHelpMessage());
+            sender.send(getHelpMessage());
     }
 
     @Override
     public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
-        return args.length == 2 && sender.hasMaintenancePermission("singleserver.timer") ? plugin.getCommandManager().getServersCompletion(args[1]) : Collections.emptyList();
+        if (args.length != 2 || !sender.hasMaintenancePermission("singleserver.timer")) {
+            return Collections.emptyList();
+        }
+
+        final String prefix = args[1].toLowerCase(Locale.ROOT);
+        final List<String> list = new ArrayList<>();
+        for (final String server : plugin.getServerTasks().keySet()) {
+            if (server.toLowerCase(Locale.ROOT).startsWith(prefix)) {
+                list.add(server);
+            }
+        }
+        return list;
     }
 }

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/ProxyStatusCommand.java

@@ -0,0 +1,74 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.command.subcommand;
+
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
+import eu.kennytv.maintenance.core.runnable.MaintenanceRunnable;
+import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.util.Map;
+import net.kyori.adventure.text.Component;
+
+public final class ProxyStatusCommand extends ProxyCommandInfo {
+
+    public ProxyStatusCommand(final MaintenanceProxyPlugin plugin) {
+        super(plugin, "singleserver.status");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        final MaintenanceRunnable task = plugin.getCurrentTask();
+        if (task != null) {
+            final String key = task.shouldEnable() ? "maintenanceStatusOffWithStartTimer" : "maintenanceStatusOnWithEndTimer";
+            sender.send(getMessage(key, "%TIME%", task.getTime()));
+        } else {
+            sender.send(getMessage(plugin.isMaintenance() ? "maintenanceStatusOn" : "maintenanceStatusOff"));
+        }
+
+        if (getSettings().getMaintenanceServers().isEmpty() && !plugin.hasServerTasks()) {
+            sender.send(getMessage("singleServerMaintenanceListEmpty"));
+            return;
+        }
+
+        sender.send(getMessage("singleServerMaintenanceList"));
+        // Enabled servers first
+        for (final String server : getSettings().getMaintenanceServers()) {
+            final MaintenanceRunnableBase serverTask = plugin.getServerTask(server);
+            if (serverTask != null) {
+                sender.send(getMessage("singleServerMaintenanceListEntryWithEndTimer", "%SERVER%", server, "%TIME%", serverTask.getTime()));
+                continue;
+            }
+
+            sender.send(getMessage("singleServerMaintenanceListEntry", "%SERVER%", server));
+        }
+
+        // Then enabling tasks
+        for (final Map.Entry<String, MaintenanceRunnableBase> entry : plugin.getServerTasks().entrySet()) {
+            final MaintenanceRunnableBase serverTask = entry.getValue();
+            if (serverTask.shouldEnable()) {
+                sender.send(getMessage("singleServerMaintenanceListEntryWithStartTimer", "%SERVER%", entry.getKey(), "%TIME%", serverTask.getTime()));
+            }
+        }
+    }
+
+    @Override
+    public Component getHelpMessage() {
+        return getMessage("helpStatus");
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/SingleEndtimerCommand.java

@@ -0,0 +1,125 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.command.subcommand;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+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.DiscordWebhook;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import net.kyori.adventure.text.Component;
+
+public final class SingleEndtimerCommand extends ProxyCommandInfo {
+
+    public SingleEndtimerCommand(final MaintenanceProxyPlugin plugin) {
+        super(plugin, null);
+    }
+
+    @Override
+    public boolean hasPermission(final SenderInfo sender) {
+        return sender.hasMaintenancePermission("timer") || sender.hasPermission("maintenance.singleserver.timer");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            endGlobal(sender, args[1]);
+        } else if (args.length == 3) {
+            if (args[1].equalsIgnoreCase("global")) {
+                endGlobal(sender, args[2]);
+            } else {
+                endSingle(sender, args[1], args[2]);
+            }
+        } else {
+            sender.send(getHelpMessage());
+        }
+    }
+
+    private void endGlobal(final SenderInfo sender, final String durationArg) {
+        if (checkPermission(sender, "timer")) return;
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg);
+        if (duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+        if (!plugin.isMaintenance()) {
+            sender.send(getMessage("alreadyDisabled"));
+            return;
+        }
+
+        plugin.startMaintenanceRunnable(duration, false);
+
+        final Component message = getMessage("endtimerStarted", "%TIME%", plugin.getRunnable().getTime());
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookEndtimerStarted", DiscordWebhook.EventType.ENDTIMER_STARTED,
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
+    }
+
+    private void endSingle(final SenderInfo sender, final String serverArg, final String durationArg) {
+        if (checkPermission(sender, "singleserver.timer")) return;
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg, false);
+        if (duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final Server server = plugin.getCommandManager().checkSingleTimerServerArg(sender, serverArg);
+        if (server == null) return;
+        if (!plugin.isMaintenance(server)) {
+            sender.send(getMessage("singleServerAlreadyDisabled", "%SERVER%", server.getName()));
+            return;
+        }
+
+        final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, duration, false);
+        final Component message = getMessage(
+                "singleEndtimerStarted",
+                "%TIME%", runnable.getTime(),
+                "%SERVER%", server.getName()
+        );
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookSingleEndtimerStarted", DiscordWebhook.EventType.ENDTIMER_STARTED,
+                "%TIME%", runnable.getTime(),
+                "%SERVER%", server.getName(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length != 2) {
+            return Collections.emptyList();
+        }
+
+        final List<String> suggestions = new ArrayList<>();
+        if (sender.hasMaintenancePermission("timer") && plugin.isMaintenance()) {
+            suggestions.add("global");
+        }
+        if (sender.hasMaintenancePermission("singleserver.timer")) {
+            suggestions.addAll(plugin.getCommandManager().getMaintenanceServersCompletion(args[1].toLowerCase(Locale.ROOT)));
+        }
+        return suggestions;
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/SingleScheduleTimerCommand.java

@@ -0,0 +1,132 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.command.subcommand;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+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.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import org.jetbrains.annotations.Nullable;
+
+public final class SingleScheduleTimerCommand extends ProxyCommandInfo {
+
+    public SingleScheduleTimerCommand(final MaintenanceProxyPlugin plugin) {
+        super(plugin, null);
+    }
+
+    @Override
+    public boolean hasPermission(final SenderInfo sender) {
+        return sender.hasMaintenancePermission("timer") || sender.hasPermission("maintenance.singleserver.timer");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 3) {
+            scheduleGlobal(sender, null, args[1], args[2]);
+        } else if (args.length == 4 || args.length == 5) {
+            final String mode = args.length == 5 ? args[2] : null;
+            final String enableInArg = args.length == 5 ? args[3] : args[2];
+            final String durationArg = args.length == 5 ? args[4] : args[3];
+            if (args[1].equalsIgnoreCase("global")) {
+                scheduleGlobal(sender, mode, enableInArg, durationArg);
+            } else {
+                scheduleSingle(sender, args[1], mode, enableInArg, durationArg);
+            }
+        } else {
+            sender.send(getHelpMessage());
+        }
+    }
+
+    private void scheduleGlobal(final SenderInfo sender, @Nullable final String mode, final String enableInArg, final String durationArg) {
+        if (checkPermission(sender, "timer")) return;
+
+        final Duration enableIn = plugin.getCommandManager().parseDurationAndCheckTask(sender, enableInArg);
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg, false);
+        if (enableIn == null || duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+        if (plugin.isMaintenance()) {
+            sender.send(getMessage("alreadyEnabled"));
+            return;
+        }
+
+        plugin.scheduleMaintenanceRunnable(enableIn, duration, mode);
+        sender.send(getMessage(
+                "scheduletimerStarted",
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%DURATION%", plugin.getFormattedTime((int) duration.getSeconds())
+        ));
+    }
+
+    private void scheduleSingle(final SenderInfo sender, final String serverArg, @Nullable final String mode,
+                                final String enableInArg, final String durationArg) {
+        if (checkPermission(sender, "singleserver.timer")) return;
+
+        final Duration enableIn = plugin.getCommandManager().parseDurationAndCheckTask(sender, enableInArg, false);
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg, false);
+        if (enableIn == null || duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final Server server = plugin.getCommandManager().checkSingleTimerServerArg(sender, serverArg);
+        if (server == null) return;
+        if (plugin.isMaintenance(server)) {
+            sender.send(getMessage("singleServerAlreadyEnabled", "%SERVER%", server.getName()));
+            return;
+        }
+
+        final MaintenanceRunnableBase runnable = plugin.scheduleSingleMaintenanceRunnable(server, enableIn, duration, mode);
+        sender.send(getMessage(
+                "singleScheduletimerStarted",
+                "%TIME%", runnable.getTime(),
+                "%DURATION%", plugin.getFormattedTime((int) duration.getSeconds()),
+                "%SERVER%", server.getName()
+        ));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            final List<String> suggestions = new ArrayList<>();
+            if (sender.hasMaintenancePermission("timer")) {
+                suggestions.add("global");
+            }
+            if (sender.hasMaintenancePermission("singleserver.timer")) {
+                suggestions.addAll(plugin.getCommandManager().getServersCompletion(args[1].toLowerCase(Locale.ROOT)));
+            }
+            return suggestions;
+        }
+        if (args.length == 3) {
+            if (args[1].equalsIgnoreCase("global")) {
+                return sender.hasMaintenancePermission("timer") ? getModesCompletion() : Collections.emptyList();
+            }
+            if (sender.hasMaintenancePermission("singleserver.timer") && plugin.getServer(args[1]) != null) {
+                return getModesCompletion();
+            }
+        }
+        return Collections.emptyList();
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/SingleStarttimerCommand.java

@@ -0,0 +1,134 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.command.subcommand;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+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.DiscordWebhook;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
+
+public final class SingleStarttimerCommand extends ProxyCommandInfo {
+
+    public SingleStarttimerCommand(final MaintenanceProxyPlugin plugin) {
+        super(plugin, null);
+    }
+
+    @Override
+    public boolean hasPermission(final SenderInfo sender) {
+        return sender.hasMaintenancePermission("timer") || sender.hasPermission("maintenance.singleserver.timer");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            startGlobal(sender, null, args[1]);
+        } else if (args.length == 3 || args.length == 4) {
+            final String mode = args.length == 4 ? args[2] : null;
+            final String durationArg = args.length == 4 ? args[3] : args[2];
+            if (args[1].equalsIgnoreCase("global")) {
+                startGlobal(sender, mode, durationArg);
+            } else {
+                startSingle(sender, args[1], mode, durationArg);
+            }
+        } else {
+            sender.send(getHelpMessage());
+        }
+    }
+
+    private void startGlobal(final SenderInfo sender, @Nullable final String mode, final String durationArg) {
+        if (checkPermission(sender, "timer")) return;
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg);
+        if (duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+        if (plugin.isMaintenance()) {
+            sender.send(getMessage("alreadyEnabled"));
+            return;
+        }
+
+        plugin.startMaintenanceRunnable(duration, true, mode);
+        final Component message = getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime());
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookStarttimerStarted", DiscordWebhook.EventType.STARTTIMER_STARTED,
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
+    }
+
+    private void startSingle(final SenderInfo sender, final String serverArg, @Nullable final String mode, final String durationArg) {
+        if (checkPermission(sender, "singleserver.timer")) return;
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, durationArg, false);
+        if (duration == null) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final Server server = plugin.getCommandManager().checkSingleTimerServerArg(sender, serverArg);
+        if (server == null) return;
+        if (plugin.isMaintenance(server)) {
+            sender.send(getMessage("singleServerAlreadyEnabled", "%SERVER%", server.getName()));
+            return;
+        }
+
+        final MaintenanceRunnableBase runnable = plugin.startSingleMaintenanceRunnable(server, duration, true, mode);
+        final Component message = getMessage(
+                "singleStarttimerStarted",
+                "%TIME%", runnable.getTime(),
+                "%SERVER%", server.getName()
+        );
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookSingleStarttimerStarted", DiscordWebhook.EventType.STARTTIMER_STARTED,
+                "%TIME%", runnable.getTime(),
+                "%SERVER%", server.getName(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            final List<String> suggestions = new ArrayList<>();
+            if (sender.hasMaintenancePermission("timer")) {
+                suggestions.add("global");
+            }
+            if (sender.hasMaintenancePermission("singleserver.timer")) {
+                suggestions.addAll(plugin.getCommandManager().getServersCompletion(args[1].toLowerCase(Locale.ROOT)));
+            }
+            return suggestions;
+        }
+        if (args.length == 3) {
+            if (args[1].equalsIgnoreCase("global")) {
+                return sender.hasMaintenancePermission("timer") ? getModesCompletion() : Collections.emptyList();
+            }
+            if (sender.hasMaintenancePermission("singleserver.timer") && plugin.getServer(args[1]) != null) {
+                return getModesCompletion();
+            }
+        }
+        return Collections.emptyList();
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/command/subcommand/SingleToggleCommand.java

@@ -0,0 +1,160 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.command.subcommand;
+
+import eu.kennytv.maintenance.api.proxy.DummyServer;
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import eu.kennytv.maintenance.core.proxy.command.ProxyCommandInfo;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class SingleToggleCommand extends ProxyCommandInfo {
+
+    public SingleToggleCommand(final MaintenanceProxyPlugin plugin) {
+        super(plugin, null);
+    }
+
+    @Override
+    public boolean hasPermission(final SenderInfo sender) {
+        return sender.hasMaintenancePermission("toggle") || sender.hasPermission("maintenance.singleserver.toggle");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 0 || args.length > 3) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final boolean maintenance = args[0].equalsIgnoreCase("on");
+        if (args.length == 1) {
+            toggleGlobal(sender, maintenance, null);
+            return;
+        }
+
+        final String server = args[1];
+        final String mode = args.length == 3 ? args[2] : null;
+        if (server.equalsIgnoreCase("global")) {
+            if (!maintenance && args.length == 3) {
+                sender.send(getHelpMessage());
+                return;
+            }
+
+            toggleGlobal(sender, maintenance, mode);
+            return;
+        }
+
+        if (!maintenance && args.length != 2) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        toggleServer(sender, maintenance, server, mode);
+    }
+
+    private void toggleGlobal(final SenderInfo sender, final boolean maintenance, final String mode) {
+        if (checkPermission(sender, "toggle")) {
+            return;
+        }
+
+        if (maintenance && plugin.isMaintenance()) {
+            if (mode != null) {
+                plugin.getSettings().setActiveMode(mode);
+                return;
+            }
+
+            sender.send(getMessage("alreadyEnabled"));
+            return;
+        }
+
+        if (maintenance == plugin.isMaintenance()) {
+            sender.send(getMessage(maintenance ? "alreadyEnabled" : "alreadyDisabled"));
+            return;
+        }
+
+        plugin.setMaintenance(maintenance, mode);
+    }
+
+    private void toggleServer(final SenderInfo sender, final boolean maintenance, final String serverArg, final String mode) {
+        if (checkPermission(sender, "singleserver.toggle")) {
+            return;
+        }
+
+        Server server = plugin.getServer(serverArg);
+        if (server == null) {
+            if (maintenance) {
+                sender.send(getMessage("serverNotFound"));
+                return;
+            }
+            // Let servers be removed from the maintenance list, even if they don't exist on the proxy
+            server = new DummyServer(serverArg);
+            if (!plugin.isMaintenance(server)) {
+                sender.send(getMessage("serverNotFound"));
+                return;
+            }
+        }
+
+        if (maintenance && plugin.isMaintenance(server) && mode != null) {
+            if (plugin.setMaintenanceModeToServer(server, mode)) {
+                return;
+            }
+            sender.send(getMessage("singleServerAlreadyEnabled", "%SERVER%", server.getName()));
+            return;
+        }
+
+        if (plugin.setMaintenanceToServer(server, maintenance, mode)) {
+            if (!sender.isPlayer() || !server.getName().equals(plugin.getServerNameOf(sender))) {
+                sender.send(getMessage(maintenance ? "singleMaintenanceActivated" : "singleMaintenanceDeactivated", "%SERVER%", server.getName()));
+            }
+        } else {
+            sender.send(getMessage(maintenance ? "singleServerAlreadyEnabled" : "singleServerAlreadyDisabled", "%SERVER%", server.getName()));
+        }
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            final List<String> suggestions = new ArrayList<>();
+            if (sender.hasMaintenancePermission("toggle") && args[0].equalsIgnoreCase("on")) {
+                suggestions.add("global");
+            }
+
+            if (!sender.hasMaintenancePermission("singleserver.toggle")) {
+                return suggestions;
+            }
+
+            final List<String> serverSuggestions = args[0].equalsIgnoreCase("off")
+                    ? plugin.getCommandManager().getMaintenanceServersCompletion(args[1].toLowerCase(Locale.ROOT))
+                    : plugin.getCommandManager().getServersCompletion(args[1].toLowerCase(Locale.ROOT));
+            suggestions.addAll(serverSuggestions);
+            return suggestions;
+        }
+
+        if (args.length == 3 && args[0].equalsIgnoreCase("on") && (sender.hasMaintenancePermission("toggle") || sender.hasMaintenancePermission("singleserver.toggle"))) {
+            final List<String> modes = new ArrayList<>(getSettings().getPingMessages().getKeys());
+            modes.remove("default");
+            return modes;
+        }
+
+        return Collections.emptyList();
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/hook/LuckPermsProxyHook.java

@@ -0,0 +1,78 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.hook;
+
+import eu.kennytv.maintenance.core.hook.LuckPermsHook;
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import net.luckperms.api.LuckPermsProvider;
+import net.luckperms.api.context.ContextCalculator;
+import net.luckperms.api.context.ContextConsumer;
+import net.luckperms.api.context.ContextSet;
+import net.luckperms.api.context.ImmutableContextSet;
+import org.jetbrains.annotations.NotNull;
+
+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));
+    }
+
+    public static final class MaintenanceProxyCalculator<T> implements ContextCalculator<T> {
+
+        private static final String MAINTENANCE_ON_KEY = "is-maintenance-on-";
+        private static final String ON_MAINTENANCE_SERVER_KEY = "on-maintenance-server";
+        private final MaintenanceProxyPlugin maintenance;
+        private final Function<T, String> playerServerFunction;
+
+        private MaintenanceProxyCalculator(final MaintenanceProxyPlugin plugin, final Function<T, String> playerServerFunction) {
+            this.maintenance = plugin;
+            this.playerServerFunction = playerServerFunction;
+        }
+
+        @Override
+        public void calculate(@NotNull final T target, @NotNull final ContextConsumer consumer) {
+            consumer.accept(LuckPermsHook.MaintenanceCalculator.MAINTENANCE_KEY, Boolean.toString(maintenance.isMaintenance()));
+            /*for (final String serverName : maintenance.getServers()) {
+                final Server server = maintenance.getServer(serverName);
+                if (server != null) {
+                    consumer.accept(MAINTENANCE_ON_KEY + server, Boolean.toString(maintenance.isMaintenance(server)));
+                }
+            }*/
+            final String server = playerServerFunction.apply(target);
+            if (server != null) {
+                final String value = Boolean.toString(maintenance.getSettingsProxy().isMaintenance(server));
+                consumer.accept(MAINTENANCE_ON_KEY + server, value);
+                consumer.accept(ON_MAINTENANCE_SERVER_KEY, value);
+            }
+        }
+
+        @Override
+        public ContextSet estimatePotentialContexts() {
+            final ImmutableContextSet.Builder builder = ImmutableContextSet.builder();
+            for (final String serverName : maintenance.getServers()) {
+                final String key = MAINTENANCE_ON_KEY + serverName;
+                builder.add(key, "true").add(key, "false");
+            }
+            return builder.add(ON_MAINTENANCE_SERVER_KEY, "true").add(ON_MAINTENANCE_SERVER_KEY, "false")
+                    .add(LuckPermsHook.MaintenanceCalculator.MAINTENANCE_KEY, "true")
+                    .add(LuckPermsHook.MaintenanceCalculator.MAINTENANCE_KEY, "false").build();
+        }
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/listener/ProxyJoinListenerBase.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.proxy.listener;
 
 import eu.kennytv.maintenance.api.proxy.Server;
@@ -25,6 +24,8 @@ import eu.kennytv.maintenance.core.proxy.SettingsProxy;
 import eu.kennytv.maintenance.core.proxy.util.ProxySenderInfo;
 import eu.kennytv.maintenance.core.proxy.util.ServerConnectResult;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.util.Locale;
+import org.jetbrains.annotations.Nullable;
 
 public abstract class ProxyJoinListenerBase extends JoinListenerBase {
     private static final ServerConnectResult ALLOWED = new ServerConnectResult(false);
@@ -48,7 +49,7 @@ public abstract class ProxyJoinListenerBase extends JoinListenerBase {
     protected ServerConnectResult serverConnect(final ProxySenderInfo sender, final Server target, final boolean normalServerConnect) {
         // Check waiting server for global maintenance
         if (settings.isMaintenance()) {
-            if (sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.getUuid())) return ALLOWED;
+            if (sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.uuid())) return ALLOWED;
 
             final Server waitingServer = shouldConnectToWaitingServer(sender);
             // Should never be null, but just in case
@@ -58,37 +59,37 @@ public abstract class ProxyJoinListenerBase extends JoinListenerBase {
             if (target.getName().equals(waitingServer.getName())) return ALLOWED;
 
             // Player already is on the waiting server
-            final String currentServer = plugin.getServer(sender);
-            if (currentServer != null && currentServer.equals(waitingServer.getName())) {
-                sender.sendMessage(settings.getMessage("forceWaitingServer"));
+            final String currentServer = plugin.getServerNameOf(sender);
+            if (waitingServer.getName().equals(currentServer)) {
+                sender.send(settings.getMessage("forceWaitingServer"));
                 return DENIED;
             }
 
-            sender.sendMessage(settings.getMessage("sentToWaitingServer"));
+            sender.send(settings.getMessage("sentToWaitingServer"));
             return new ServerConnectResult(waitingServer);
         }
 
         // Single server maintenance
         if (!settings.isMaintenance(target.getName())) return ALLOWED;
-        if (sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.getUuid())
-                || sender.hasMaintenancePermission("singleserver.bypass." + target.getName().toLowerCase())) {
+        if (sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.uuid())
+                || sender.hasMaintenancePermission("singleserver.bypass." + target.getName().toLowerCase(Locale.ROOT))) {
             return ALLOWED;
         }
 
         if (settings.isJoinNotifications()) {
-            broadcastJoinNotification(sender.getName(), target);
+            broadcastJoinNotification(sender.name(), target);
         }
 
         if (normalServerConnect) {
-            sender.sendMessage(settings.getMessage("singleMaintenanceKick").replace("%SERVER%", target.getName()));
+            sender.send(settings.getServerKickMessage(target.getName()));
             return DENIED;
         }
 
         // If it's the initial proxy join or a kick from another server, go back to fallback server
-        final Server fallback = plugin.getServer(settings.getFallbackServer());
-        if (fallback == null || !sender.canAccess(fallback) || plugin.isMaintenance(fallback)) {
+        final Server fallback = settings.getFallbackServer();
+        if (fallback == null || !sender.canAccess(fallback)) {
             // Nothing to redirect to, player has to be kicked from the proxy
-            sender.disconnect(settings.getMessage("singleMaintenanceKickComplete").replace("%NEWLINE%", "\n").replace("%SERVER%", target.getName()));
+            sender.disconnect(settings.getFullServerKickMessage(target.getName()));
             if (!warned) {
                 plugin.getLogger().warning("Could not send player to the set fallback server; instead kicking player off the network!");
                 warned = true;
@@ -106,6 +107,7 @@ public abstract class ProxyJoinListenerBase extends JoinListenerBase {
      * @param sender sender
      * @return waiting server, null if player should be kicked
      */
+    @Nullable
     protected Server shouldConnectToWaitingServer(final ProxySenderInfo sender) {
         if (settings.getWaitingServer() == null) return null;
 

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/redis/RedisHandler.java

@@ -0,0 +1,258 @@
+package eu.kennytv.maintenance.core.proxy.redis;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import eu.kennytv.maintenance.core.proxy.SettingsProxy;
+import java.net.URI;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.Locale;
+import org.jetbrains.annotations.Nullable;
+import redis.clients.jedis.ConnectionPoolConfig;
+import redis.clients.jedis.RedisClient;
+import redis.clients.jedis.StreamEntryID;
+import redis.clients.jedis.params.XReadParams;
+import redis.clients.jedis.resps.StreamEntry;
+
+public final class RedisHandler {
+
+    private static final String REDIS_STREAM_KEY = "maintenance:stream";
+    private static final String REDIS_MAINTENANCE_KEY = "maintenance:status";
+    private static final String REDIS_MODE_KEY = "maintenance:mode";
+    private static final String REDIS_SERVERS_KEY = "maintenance:servers";
+    private static final String REDIS_SERVER_MODES_KEY = "maintenance:server_modes";
+    private static final String REDIS_WHITELIST_KEY = "maintenance:whitelist";
+
+    private static final String MSG_TYPE_MAINTENANCE_UPDATE = "status";
+    private static final String MSG_TYPE_SERVER_ADD = "server_add";
+    private static final String MSG_TYPE_SERVER_REMOVE = "server_remove";
+    private static final String MSG_TYPE_PLAYER_ADD = "player_add";
+    private static final String MSG_TYPE_PLAYER_REMOVE = "player_remove";
+    private static final String MSG_TYPE = "type";
+    private static final String MSG_VALUE = "val";
+
+    private final AtomicBoolean running = new AtomicBoolean(false);
+    private final MaintenanceProxyPlugin plugin;
+    private final SettingsProxy settings;
+    private RedisClient client;
+    private StreamEntryID lastStreamId = new StreamEntryID();
+
+    public RedisHandler(final MaintenanceProxyPlugin plugin, final SettingsProxy settings) {
+        this.plugin = plugin;
+        this.settings = settings;
+    }
+
+    public void setup(final String redisUri) {
+        plugin.getLogger().info("Trying to open Redis connection...");
+
+        final ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
+        poolConfig.setMaxWait(Duration.ofSeconds(5));
+        poolConfig.setMaxTotal(2);
+        client = RedisClient.builder().poolConfig(poolConfig).fromURI(URI.create(redisUri)).build();
+
+        // Get the latest stream ID to only receive new messages
+        final List<StreamEntry> messages = client.xrevrange(REDIS_STREAM_KEY, (StreamEntryID) null, null, 1);
+        if (!messages.isEmpty()) {
+            lastStreamId = messages.getFirst().getID();
+        }
+
+        running.set(true);
+        plugin.async(this::listenToStream);
+
+        plugin.getLogger().info("Connected to Redis!");
+    }
+
+    public boolean loadMaintenanceStatus() {
+        return Boolean.parseBoolean(client.get(REDIS_MAINTENANCE_KEY));
+    }
+
+    public @Nullable String loadGlobalMode() {
+        return client.get(REDIS_MODE_KEY);
+    }
+
+    public Map<String, String> loadMaintenanceServers() {
+        final Set<String> servers = client.smembers(REDIS_SERVERS_KEY);
+        final Map<String, String> serverModes = new HashMap<>();
+        if (servers == null) {
+            return serverModes;
+        }
+
+        final Map<String, String> persistedModes = client.hgetAll(REDIS_SERVER_MODES_KEY);
+        for (final String server : servers) {
+            serverModes.put(server, normalizeMode(persistedModes.get(server)));
+        }
+        return serverModes;
+    }
+
+    public void loadPlayers(final Map<UUID, String> players) {
+        for (final Map.Entry<String, String> entry : client.hgetAll(REDIS_WHITELIST_KEY).entrySet()) {
+            players.put(UUID.fromString(entry.getKey()), entry.getValue());
+        }
+    }
+
+    public void set(final boolean maintenance, final String mode) {
+        client.set(REDIS_MAINTENANCE_KEY, Boolean.toString(maintenance));
+        client.set(REDIS_MODE_KEY, mode);
+        client.xadd(REDIS_STREAM_KEY, StreamEntryID.NEW_ENTRY, Map.of(
+                MSG_TYPE, MSG_TYPE_MAINTENANCE_UPDATE,
+                MSG_VALUE, Boolean.toString(maintenance),
+                "mode", mode
+        ));
+    }
+
+    public boolean addServer(final String server, final String mode) {
+        if (client.sadd(REDIS_SERVERS_KEY, server) < 1) {
+            return false;
+        }
+        client.hset(REDIS_SERVER_MODES_KEY, server, mode);
+        client.xadd(REDIS_STREAM_KEY, StreamEntryID.NEW_ENTRY, Map.of(
+                MSG_TYPE, MSG_TYPE_SERVER_ADD,
+                MSG_VALUE, server,
+                "mode", mode
+        ));
+        return true;
+    }
+
+    public void setServerMode(final String server, final String mode) {
+        client.hset(REDIS_SERVER_MODES_KEY, server, mode);
+        client.xadd(REDIS_STREAM_KEY, StreamEntryID.NEW_ENTRY, Map.of(
+                MSG_TYPE, MSG_TYPE_SERVER_ADD,
+                MSG_VALUE, server,
+                "mode", mode
+        ));
+    }
+
+    public boolean removeServer(final String server) {
+        if (client.srem(REDIS_SERVERS_KEY, server) < 1) {
+            return false;
+        }
+        client.hdel(REDIS_SERVER_MODES_KEY, server);
+        send(MSG_TYPE_SERVER_REMOVE, server);
+        return true;
+    }
+
+    public void addPlayer(final UUID uuid, final String name) {
+        final String value = uuid.toString();
+        client.hset(REDIS_WHITELIST_KEY, value, name);
+        client.xadd(REDIS_STREAM_KEY, StreamEntryID.NEW_ENTRY, Map.of(
+                MSG_TYPE, MSG_TYPE_PLAYER_ADD,
+                MSG_VALUE, value,
+                "name", name
+        ));
+    }
+
+    public void removePlayer(final UUID uuid) {
+        final String value = uuid.toString();
+        client.hdel(REDIS_WHITELIST_KEY, value);
+        send(MSG_TYPE_PLAYER_REMOVE, value);
+    }
+
+    private void send(final String type, final String value) {
+        client.xadd(REDIS_STREAM_KEY, StreamEntryID.NEW_ENTRY, Map.of(MSG_TYPE, type, MSG_VALUE, value));
+    }
+
+    private void listenToStream() {
+        while (running.get()) {
+            try {
+                final List<Map.Entry<String, List<StreamEntry>>> result = client.xread(
+                        XReadParams.xReadParams().block(5000),
+                        Map.of(REDIS_STREAM_KEY, lastStreamId)
+                );
+                if (result != null) {
+                    for (final Map.Entry<String, List<StreamEntry>> streamEntries : result) {
+                        for (final StreamEntry entry : streamEntries.getValue()) {
+                            plugin.sync(() -> processStreamMessage(entry));
+                            lastStreamId = entry.getID();
+                        }
+                    }
+                }
+            } catch (final Exception e) {
+                if (running.get()) {
+                    plugin.getLogger().log(Level.WARNING, "Error reading from Redis stream", e);
+                    try {
+                        Thread.sleep(1000); // retry
+                    } catch (final InterruptedException ignored) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+    }
+
+    private void processStreamMessage(final StreamEntry message) {
+        final Map<String, String> body = message.getFields();
+        final String type = body.get(MSG_TYPE);
+        if (type == null) {
+            return;
+        }
+
+        final String value = body.get(MSG_VALUE);
+        switch (type) {
+            case MSG_TYPE_MAINTENANCE_UPDATE -> handleStatus(value, body.get("mode"));
+            case MSG_TYPE_SERVER_ADD -> handleServerStatus(value, body.get("mode"), true, "Server added to maintenance via Redis: ");
+            case MSG_TYPE_SERVER_REMOVE -> handleServerStatus(value, null, false, "Server removed from maintenance via Redis: ");
+            case MSG_TYPE_PLAYER_ADD -> handlePlayerAdd(value, body.get("name"));
+            case MSG_TYPE_PLAYER_REMOVE -> handlePlayerRemove(value);
+        }
+    }
+
+    private void handleStatus(final String value, @Nullable final String mode) {
+        final boolean maintenance = Boolean.parseBoolean(value);
+        if (settings.isMaintenance() != maintenance) {
+            plugin.getLogger().info("Maintenance status updated via Redis: " + maintenance);
+            settings.setMaintenanceDirect(maintenance, mode);
+            plugin.serverActions(maintenance);
+            return;
+        }
+
+        if (maintenance && !normalizeMode(mode).equals(normalizeMode(settings.activeMode()))) {
+            settings.setActiveModeDirect(mode);
+        }
+    }
+
+    private void handleServerStatus(final String value, @Nullable final String mode, final boolean maintenance, final String log) {
+        if (value == null) {
+            return;
+        }
+
+        final boolean success;
+        if (maintenance) {
+            success = settings.addMaintenanceServerDirect(value, mode);
+            settings.setMaintenanceServerModeDirect(value, mode);
+        } else {
+            success = settings.removeMaintenanceServerDirect(value);
+        }
+
+        if (success) {
+            plugin.getLogger().info(log + value);
+            final Server server = plugin.getServerOrDummy(value);
+            plugin.serverActions(server, maintenance);
+        }
+    }
+
+    private void handlePlayerAdd(final String uuid, final String name) {
+        settings.addWhitelistedPlayerDirect(UUID.fromString(uuid), name);
+    }
+
+    private void handlePlayerRemove(final String value) {
+        settings.removeWhitelistedPlayerDirect(UUID.fromString(value));
+    }
+
+    public void close() {
+        running.set(false);
+        if (client != null) {
+            client.close();
+            client = null;
+        }
+    }
+
+    private String normalizeMode(@Nullable final String mode) {
+        return mode == null || mode.isBlank() ? "default" : mode.toLowerCase(Locale.ROOT);
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/runnable/SingleMaintenanceRunnable.java

@@ -0,0 +1,67 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.runnable;
+
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.Settings;
+import eu.kennytv.maintenance.core.runnable.MaintenanceRunnableBase;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
+
+public class SingleMaintenanceRunnable extends MaintenanceRunnableBase {
+    protected final Server server;
+    protected final String mode;
+
+    public SingleMaintenanceRunnable(final MaintenancePlugin plugin, final Settings settings, final int seconds,
+                                     final boolean enable, final Server server, @Nullable final String mode) {
+        super(plugin, settings, seconds, enable);
+        this.server = server;
+        this.mode = mode;
+    }
+
+    @Override
+    protected void broadcast(final Component component) {
+        server.broadcast(component);
+    }
+
+    @Override
+    protected void finish() {
+        final MaintenanceProxyPlugin proxyPlugin = (MaintenanceProxyPlugin) plugin;
+        proxyPlugin.setMaintenanceToServer(server, enable, mode);
+        // Make sure no-ops have the platform task cancelled as well
+        if (proxyPlugin.getServerTasks().remove(server.getName(), this)) {
+            getTask().cancel();
+        }
+    }
+
+    @Override
+    protected Component getStartMessage() {
+        return settings.getMessage("singleStarttimerBroadcast",
+                "%TIME%", getTime(),
+                "%SERVER%", server.getName());
+    }
+
+    @Override
+    protected Component getEndMessage() {
+        return settings.getMessage("singleEndtimerBroadcast",
+                "%TIME%", getTime(),
+                "%SERVER%", server.getName());
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/runnable/SingleMaintenanceScheduleRunnable.java

@@ -0,0 +1,49 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.runnable;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.Settings;
+import eu.kennytv.maintenance.core.proxy.MaintenanceProxyPlugin;
+import java.time.Duration;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
+
+public final class SingleMaintenanceScheduleRunnable extends SingleMaintenanceRunnable {
+    private final int maintenanceDurationSeconds;
+
+    public SingleMaintenanceScheduleRunnable(final MaintenancePlugin plugin, final Settings settings, final int seconds,
+                                             final int maintenanceDuration, final Server server, @Nullable final String mode) {
+        super(plugin, settings, seconds, true, server, mode);
+        this.maintenanceDurationSeconds = maintenanceDuration;
+    }
+
+    @Override
+    protected void finish() {
+        super.finish();
+        ((MaintenanceProxyPlugin) plugin).startSingleMaintenanceRunnable(server, Duration.ofSeconds(maintenanceDurationSeconds), false);
+    }
+
+    @Override
+    protected Component getStartMessage() {
+        return settings.getMessage("singleScheduletimerBroadcast",
+                "%SERVER%", server.getName(),
+                "%TIME%", getTime(), "%DURATION%", plugin.getFormattedTime(maintenanceDurationSeconds));
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/util/ProfileLookup.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,21 +15,9 @@
  * 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.proxy.util;
 
-package eu.kennytv.maintenance.spigot.util;
+import java.util.UUID;
 
-import eu.kennytv.maintenance.core.util.Task;
-import org.bukkit.Bukkit;
-
-public final class BukkitTask implements Task {
-    private final int id;
-
-    public BukkitTask(final int id) {
-        this.id = id;
-    }
-
-    @Override
-    public void cancel() {
-        Bukkit.getScheduler().cancelTask(id);
-    }
+public record ProfileLookup(UUID uuid, String name) {
 }

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/util/ProxyOfflineSenderInfo.java

@@ -0,0 +1,49 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.proxy.util;
+
+import eu.kennytv.maintenance.api.proxy.Server;
+
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+
+public record ProxyOfflineSenderInfo(UUID uuid, String name) implements ProxySenderInfo {
+
+    @Override
+    public boolean canAccess(final Server server) {
+        return false;
+    }
+
+    @Override
+    public void disconnect(final Component component) {
+    }
+
+    @Override
+    public boolean hasPermission(final String permission) {
+        return false;
+    }
+
+    @Override
+    public void send(final Component component) {
+    }
+
+    @Override
+    public boolean isPlayer() {
+        return true;
+    }
+}

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/util/ProxySenderInfo.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,15 +15,15 @@
  * 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.proxy.util;
 
 import eu.kennytv.maintenance.api.proxy.Server;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import net.kyori.adventure.text.Component;
 
 public interface ProxySenderInfo extends SenderInfo {
 
     boolean canAccess(Server server);
 
-    void disconnect(String message);
+    void disconnect(Component component);
 }

core-proxy/src/main/java/eu/kennytv/maintenance/core/proxy/util/ServerConnectResult.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,10 +15,10 @@
  * 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.proxy.util;
 
 import eu.kennytv.maintenance.api.proxy.Server;
+import org.jetbrains.annotations.Nullable;
 
 public final class ServerConnectResult {
     private final boolean cancel;
@@ -38,7 +38,16 @@ public final class ServerConnectResult {
         return cancel;
     }
 
+    @Nullable
     public Server getTarget() {
         return target;
     }
+
+    @Override
+    public String toString() {
+        return "ServerConnectResult{" +
+                "cancel=" + cancel +
+                ", target=" + target +
+                '}';
+    }
 }

core/build.gradle.kts

@@ -0,0 +1,32 @@
+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()}")
+            }
+        }
+    }
+}
+
+dependencies {
+    api(projects.maintenanceApi)
+    compileOnlyApi(libs.adventureApi)
+    compileOnlyApi(libs.adventureTextMinimessage)
+    compileOnlyApi(libs.adventureTextSerializerPlain)
+    compileOnlyApi(libs.adventureTextSerializerLegacy)
+    compileOnly(libs.luckperms)
+    compileOnly(libs.serverlistplus)
+    compileOnly(libs.guava)
+    compileOnly(libs.gson)
+    compileOnly(libs.snakeyaml)
+}
+
+java {
+    withJavadocJar()
+}

core/src/main/java-templates/eu/kennytv/maintenance/core/util/MaintenanceVersion.java

@@ -0,0 +1,37 @@
+/*
+ * 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;
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/MaintenanceBase.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,19 +15,17 @@
  * 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;
 
-package eu.kennytv.maintenance.api;
+import eu.kennytv.maintenance.api.Maintenance;
 
-/**
- * @author KennyTV
- * @since 2.2.2
- */
-public interface IMaintenanceBase {
+@FunctionalInterface
+public interface MaintenanceBase {
 
     /**
      * This method is used internally when getting the api instance.
      *
-     * @return {@link IMaintenance} instance
+     * @return {@link Maintenance} instance
      */
-    IMaintenance getApi();
+    Maintenance getApi();
 }

core/src/main/java/eu/kennytv/maintenance/core/MaintenancePlugin.java

@@ -0,0 +1,519 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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;
+
+import com.google.common.collect.Lists;
+import com.google.common.io.CharStreams;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import eu.kennytv.maintenance.api.Maintenance;
+import eu.kennytv.maintenance.api.MaintenanceProvider;
+import eu.kennytv.maintenance.api.event.MaintenanceChangedEvent;
+import eu.kennytv.maintenance.api.event.manager.EventManager;
+import eu.kennytv.maintenance.core.command.MaintenanceCommand;
+import eu.kennytv.maintenance.core.dump.MaintenanceDump;
+import eu.kennytv.maintenance.core.dump.PluginDump;
+import eu.kennytv.maintenance.core.hook.ServerListPlusHook;
+import eu.kennytv.maintenance.core.runnable.MaintenanceRunnable;
+import eu.kennytv.maintenance.core.runnable.MaintenanceScheduleRunnable;
+import eu.kennytv.maintenance.core.util.DiscordWebhook;
+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.core.util.Version;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URI;
+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.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+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 Version version;
+    protected Settings settings;
+    protected ServerListPlusHook serverListPlusHook;
+    protected MaintenanceRunnable runnable;
+    protected MaintenanceCommand commandManager;
+    private final Component prefix;
+    private final ServerType serverType;
+    private Version newestVersion;
+    private boolean debug;
+
+    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.eventManager = new eu.kennytv.maintenance.core.event.EventManager();
+        MaintenanceProvider.setMaintenance(this);
+    }
+
+    public void disable() {
+    }
+
+    @Override
+    public void setMaintenance(final boolean maintenance, final String mode) {
+        settings.setMaintenance(maintenance, mode);
+        serverActions(maintenance);
+    }
+
+    public void serverActions(final boolean maintenance) {
+        if (isTaskRunning()) {
+            cancelTask();
+        }
+        if (serverListPlusHook != null && settings.isEnablePingMessages()) {
+            serverListPlusHook.setEnabled(!maintenance);
+        }
+
+        broadcast(maintenance ? settings.getMessage("maintenanceActivated") : settings.getMessage("maintenanceDeactivated"));
+        if (maintenance && settings.isKickOnlinePlayers()) {
+            kickPlayers();
+        }
+
+        eventManager.callEvent(new MaintenanceChangedEvent(maintenance));
+        if (maintenance) {
+            sendWebhookMessage("webhookMaintenanceActivated", DiscordWebhook.EventType.MAINTENANCE_ENABLED);
+        } else {
+            sendWebhookMessage("webhookMaintenanceDeactivated", DiscordWebhook.EventType.MAINTENANCE_DISABLED);
+        }
+
+        for (final String command : (maintenance ? settings.getCommandsOnMaintenanceEnable() : settings.getCommandsOnMaintenanceDisable())) {
+            try {
+                executeConsoleCommand(command);
+            } catch (final Exception e) {
+                getLogger().log(Level.SEVERE, "Error while executing extra maintenance " + (maintenance ? "enable" : "disable") + " command: " + command, e);
+            }
+        }
+    }
+
+    public void sendWebhookMessage(final String messageKey, final DiscordWebhook.EventType eventType, final String... replacements) {
+        if (!settings.isWebhookEnabled() || !settings.isWebhookEventEnabled(eventType.configKey())) {
+            return;
+        }
+
+        async(() -> {
+            try {
+                DiscordWebhook.sendMessage(settings.getWebhookMessage(messageKey, replacements), eventType, settings);
+            } catch (final Exception e) {
+                getLogger().log(Level.WARNING, "Could not send Discord webhook message", e);
+            }
+        });
+    }
+
+    public String getTargetTimestamp(final Duration duration) {
+        return Long.toString((System.currentTimeMillis() + duration.toMillis()) / TimeUnit.SECONDS.toMillis(1));
+    }
+
+    public String replacePingVariables(final String component) {
+        return replacePingVariables(component, settings.activeMode());
+    }
+
+    public String replacePingVariables(String component, @Nullable final String mode) {
+        if (component.contains("%TIMER%")) {
+            component = component.replace("%TIMER%", getTimerMessage());
+        }
+        final String reason = settings.activeReason() == null ? "" : settings.activeReason();
+        component = component.replace("%REASON%", reason);
+        component = component.replace("%MODE%", mode == null ? "default" : mode);
+        component = component.replace("%ONLINE%", String.valueOf(getOnlinePlayers()));
+        component = component.replace("%MAX%", String.valueOf(getMaxPlayers()));
+        return component;
+    }
+
+    public String getTimerMessage() {
+        if (!isTaskRunning()) {
+            return settings.getLanguageString("motdTimerNotRunning");
+        }
+
+        final int preHours = runnable.getSecondsLeft() / 60;
+        final int minutes = preHours % 60;
+        final int seconds = runnable.getSecondsLeft() % 60;
+        return settings.getLanguageString("motdTimer",
+                "%HOURS%", String.format("%02d", preHours / 60),
+                "%MINUTES%", String.format("%02d", minutes),
+                "%SECONDS%", String.format("%02d", seconds));
+    }
+
+    public String getFormattedTime(final int timeSeconds) {
+        final int preHours = timeSeconds / 60;
+        final int minutes = preHours % 60;
+        final int seconds = timeSeconds % 60;
+
+        final StringBuilder buider = new StringBuilder();
+        append(buider, "hour", preHours / 60);
+        append(buider, "minute", minutes);
+        append(buider, "second", seconds);
+        return buider.toString();
+    }
+
+    private void append(final StringBuilder builder, final String timeUnit, final int time) {
+        if (time == 0) return;
+        if (!builder.isEmpty()) {
+            builder.append(' ');
+        }
+        builder.append(time).append(' ').append(settings.language.getString(time == 1 ? timeUnit : timeUnit + "s"));
+    }
+
+    public void startMaintenanceRunnable(final Duration duration, final boolean enable) {
+        startMaintenanceRunnable(duration, enable, null);
+    }
+
+    public void startMaintenanceRunnable(final Duration duration, final boolean enable, @Nullable final String mode) {
+        runnable = new MaintenanceRunnable(this, settings, (int) duration.getSeconds(), enable, mode);
+        // 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) {
+        scheduleMaintenanceRunnable(enableIn, maintenanceDuration, null);
+    }
+
+    public void scheduleMaintenanceRunnable(final Duration enableIn, final Duration maintenanceDuration, @Nullable final String mode) {
+        runnable = new MaintenanceScheduleRunnable(this, settings, (int) enableIn.getSeconds(), (int) maintenanceDuration.getSeconds(), mode);
+    }
+
+    public boolean updateAvailable() {
+        try {
+            checkNewestVersion();
+            return version.compareTo(newestVersion) < 0;
+        } catch (final Exception e) {
+            return false;
+        }
+    }
+
+    protected void continueLastEndtimer() {
+        if (!settings.isSaveEndtimerOnStop()) return;
+        if (settings.getSavedEndtimer() == 0) return;
+
+        final long current = System.currentTimeMillis();
+        getLogger().info("Found interrupted endtimer from last uptime...");
+        if (!isMaintenance()) {
+            getLogger().info("Maintenance has already been disabled, thus the timer has been cancelled.");
+            settings.setSavedEndtimer(0);
+        } else if (settings.getSavedEndtimer() < current) {
+            getLogger().info("The endtimer has already expired, maintenance has been disabled.");
+            setMaintenance(false);
+            settings.setSavedEndtimer(0);
+        } else {
+            startMaintenanceRunnable(Duration.ofMillis(settings.getSavedEndtimer() - current), false);
+            getLogger().info("The timer has been continued - maintenance will be disabled in: " + getTimerMessage());
+        }
+    }
+
+    protected void sendEnableMessage() {
+        if (!settings.hasUpdateChecks()) return;
+        async(() -> {
+            try {
+                checkNewestVersion();
+            } catch (final Exception e) {
+                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 (version.getTag() != null && !version.getTag().isBlank()) {
+                    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)");
+                } else {
+                    getLogger().info("You're running a version, that doesn't exist!");
+                }
+            }
+        });
+    }
+
+    public boolean installUpdate() throws Exception {
+        final String fileName = "Maintenance-" + serverType.name() + "-" + newestVersion + ".jar";
+        final Path tempFilePath = Paths.get(getPluginFolder() + "Maintenance.tmp");
+        final URLConnection connection = URI.create("https://github.com/kennytv/Maintenance/releases/download/" + newestVersion + "/" + fileName).toURL().openConnection();
+        try (final BufferedInputStream is = new BufferedInputStream(connection.getInputStream());
+             final BufferedOutputStream os = new BufferedOutputStream(Files.newOutputStream(tempFilePath))) {
+            writeFile(is, os);
+        }
+
+        final File file = tempFilePath.toFile();
+        final long newlength = file.length();
+        if (newlength < 10_000) {
+            // Sanity check the file length
+            file.delete();
+            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 {
+        final byte[] chunk = new byte[1024];
+        int chunkSize;
+        while ((chunkSize = is.read(chunk)) != -1) {
+            os.write(chunk, 0, chunkSize);
+        }
+    }
+
+    private void checkNewestVersion() throws Exception {
+        final URLConnection connection = URI.create("https://hangar.papermc.io/api/v1/projects/Maintenance/latestrelease").toURL().openConnection();
+        connection.setRequestProperty("User-Agent", "Maintenance/" + getVersion());
+        connection.setConnectTimeout(5_000);
+        connection.setReadTimeout(10_000);
+        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+            final String newVersionString = reader.readLine();
+            final Version newVersion = new Version(newVersionString);
+            if (!newVersion.equals(version)) {
+                newestVersion = newVersion;
+            }
+        }
+    }
+
+    public String pasteDump() {
+        final MaintenanceDump dump = new MaintenanceDump(this, settings);
+        try {
+            final HttpURLConnection connection = (HttpURLConnection) URI.create("https://api.pastes.dev/post").toURL().openConnection();
+            connection.setDoOutput(true);
+            connection.setRequestMethod("POST");
+            connection.setRequestProperty("User-Agent", "Maintenance/" + getVersion());
+            connection.setRequestProperty("Content-Type", "text/plain");
+
+            try (final OutputStream out = connection.getOutputStream()) {
+                out.write(new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create().toJson(dump).getBytes(StandardCharsets.UTF_8));
+            }
+
+            if (connection.getResponseCode() == 503) {
+                getLogger().warning("Could not paste dump, pastes.dev down?");
+                return null;
+            }
+
+            try (final InputStream in = connection.getInputStream()) {
+                final String output = CharStreams.toString(new InputStreamReader(in));
+                final JsonObject jsonOutput = GSON.fromJson(output, JsonObject.class);
+                if (!jsonOutput.has("key")) {
+                    getLogger().log(Level.WARNING, "Could not paste dump, there was no key returned :(");
+                    return null;
+                }
+
+                return jsonOutput.get("key").getAsString();
+            }
+        } catch (final IOException e) {
+            getLogger().log(Level.WARNING, "Could not paste dump :(", e);
+            return null;
+        }
+    }
+
+    public void loadMaintenanceIcon() {
+        final File file = new File(getDataFolder(), "maintenance-icon.png");
+        if (!file.exists()) {
+            getLogger().warning("Could not find a 'maintenance-icon.png' file - did you create one in the plugin's folder?");
+            return;
+        }
+
+        try {
+            loadIcon(file);
+        } catch (final Exception e) {
+            getLogger().log(Level.WARNING, "Could not load the 'maintenance-icon.png' file!", e);
+        }
+    }
+
+    public void cancelTask() {
+        if (settings.isSaveEndtimerOnStop() && !runnable.shouldEnable()) {
+            settings.setSavedEndtimer(0);
+        }
+
+        runnable.getTask().cancel();
+        runnable = null;
+    }
+
+    @Nullable
+    public UUID checkUUID(final SenderInfo sender, final String s) {
+        final UUID uuid;
+        try {
+            uuid = UUID.fromString(s);
+        } catch (final Exception e) {
+            sender.send(settings.getMessage("invalidUuid"));
+            return null;
+        }
+        return uuid;
+    }
+
+    public String[] removeArrayIndex(final String[] args, final int index) {
+        final List<String> argsList = Lists.newArrayList(args);
+        argsList.remove(index);
+        return argsList.toArray(new String[0]);
+    }
+
+    public boolean isNumeric(final String string) {
+        return INT_PATTERN.matcher(string).matches();
+    }
+
+    @Override
+    public boolean isMaintenance() {
+        return settings.isMaintenance();
+    }
+
+    @Override
+    public boolean isTaskRunning() {
+        return runnable != null;
+    }
+
+    public @Nullable MaintenanceRunnable getCurrentTask() {
+        return runnable;
+    }
+
+    @Override
+    public Settings getSettings() {
+        return settings;
+    }
+
+    @Override
+    public EventManager getEventManager() {
+        return eventManager;
+    }
+
+    @Override
+    public String getVersion() {
+        return version.toString();
+    }
+
+    @Nullable
+    public List<String> getMaintenanceServersDump() {
+        return isMaintenance() ? Arrays.asList("global") : null;
+    }
+
+    @Override
+    public boolean isDebug() {
+        return debug;
+    }
+
+    @Override
+    public void setDebug(final boolean debug) {
+        this.debug = debug;
+    }
+
+    public int getSaltLevel() {
+        return Integer.MAX_VALUE;
+    }
+
+    public Version getNewestVersion() {
+        return newestVersion;
+    }
+
+    public Component prefix() {
+        return prefix;
+    }
+
+    /**
+     * @see #isTaskRunning()
+     */
+    @Nullable
+    public MaintenanceRunnable getRunnable() {
+        return runnable;
+    }
+
+    public MaintenanceCommand getCommandManager() {
+        return commandManager;
+    }
+
+    public ServerType getServerType() {
+        return serverType;
+    }
+
+    protected String getPluginFolder() {
+        return "plugins/";
+    }
+
+    public void sync(final Runnable runnable) {
+        async(runnable);
+    }
+
+    public abstract void async(Runnable runnable);
+
+    protected abstract void executeConsoleCommand(String command);
+
+    public abstract void broadcast(Component component);
+
+    public abstract Task startMaintenanceRunnable(Runnable runnable);
+
+    /**
+     * Gets the offline sender info of a player.
+     * This method may do a web lookup.
+     *
+     * @param name name of the player
+     */
+    public abstract CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(String name);
+
+    public abstract CompletableFuture<@Nullable SenderInfo> getOfflinePlayer(UUID uuid);
+
+    public abstract File getDataFolder();
+
+    @Nullable
+    public InputStream getResource(final String name) {
+        return this.getClass().getClassLoader().getResourceAsStream(name);
+    }
+
+    public abstract Logger getLogger();
+
+    public abstract String getServerVersion();
+
+    public abstract List<PluginDump> getPlugins();
+
+    protected abstract void loadIcon(File file) throws Exception;
+
+    protected abstract void kickPlayers();
+
+    protected abstract File getPluginFile();
+
+    protected abstract int getOnlinePlayers();
+
+    protected abstract int getMaxPlayers();
+}

core/src/main/java/eu/kennytv/maintenance/core/Settings.java

@@ -0,0 +1,812 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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;
+
+import eu.kennytv.maintenance.api.event.MaintenanceReloadedEvent;
+import eu.kennytv.maintenance.core.config.Config;
+import eu.kennytv.maintenance.core.config.ConfigSection;
+import eu.kennytv.maintenance.core.config.DisplayedMessages;
+import eu.kennytv.maintenance.core.util.ServerType;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import java.util.logging.Level;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+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 = 12;
+    private static final int LANGUAGE_VERSION = 5;
+    protected final MaintenancePlugin plugin;
+    private final Map<UUID, String> whitelistedPlayers = new HashMap<>();
+    private final String[] unsupportedFields;
+    protected boolean maintenance;
+    protected String activeMode;
+    protected String activeReason;
+    private Set<Integer> broadcastIntervals;
+    private DisplayedMessages pingMessages;
+    private DisplayedMessages timerSpecificPingMessages;
+    private List<String> commandsOnMaintenanceEnable;
+    private List<String> commandsOnMaintenanceDisable;
+    private DisplayedMessages legacyParsedPlayerCountMessages;
+    private DisplayedMessages legacyParsedTimerPlayerCountMessages;
+    private DisplayedMessages legacyParsedPlayerCountHoverLines;
+    private DisplayedMessages legacyParsedTimerPlayerCountHoverLines;
+    private String prefixString;
+    private String plainTextPrefix;
+    private String languageName;
+    private boolean enablePingMessages;
+    private boolean customPlayerCountMessage;
+    private boolean customPlayerCountHoverMessage;
+    private boolean customMaintenanceIcon;
+    private boolean joinNotifications;
+    private boolean updateChecks;
+    private boolean saveEndtimerOnStop;
+    private boolean kickOnlinePlayers;
+    private boolean debug;
+    private long savedEndtimer;
+
+    // Webhook settings
+    private boolean webhookEnabled;
+    private Set<String> webhookEnabledEvents;
+    private String webhookUrl;
+    private String webhookUsername;
+    private String webhookAvatarUrl;
+
+    protected Config config;
+    protected Config language;
+    protected Config whitelist;
+
+    public Settings(final MaintenancePlugin plugin, final String... unsupportedFields) {
+        this.plugin = plugin;
+        this.unsupportedFields = unsupportedFields;
+        if (!plugin.getDataFolder().exists()) {
+            updatePluginDirectory();
+            plugin.getDataFolder().mkdirs();
+        }
+
+        createFile("config.yml");
+        createFile("WhitelistedPlayers.yml");
+
+        reloadConfigs();
+    }
+
+    @Override
+    public void reloadConfigs() {
+        try {
+            config = new Config(new File(plugin.getDataFolder(), "config.yml"), unsupportedFields);
+            config.load();
+            config.resetAwesomeHeader();
+            whitelist = new Config(new File(plugin.getDataFolder(), "WhitelistedPlayers.yml"));
+            whitelist.load();
+        } catch (final Exception e) {
+            throw new RuntimeException("Unable to load Maintenance files - probably a malformed config file", e);
+        }
+
+        loadSettings();
+        createLanguageFile();
+
+        try {
+            language = new Config(new File(plugin.getDataFolder(), "language-" + languageName + ".yml"));
+            language.load();
+        } catch (final IOException e) {
+            throw new RuntimeException("Unable to load Maintenance language file - probably a malformed file", e);
+        }
+
+        try {
+            updateLanguageFile();
+        } catch (final IOException e) {
+            plugin.getLogger().log(Level.SEVERE, "Couldn't update language file", e);
+        }
+
+        prefixString = language.getString("prefix");
+        plainTextPrefix = PlainTextComponentSerializer.plainText().serialize(parse(prefixString));
+
+        plugin.getEventManager().callEvent(new MaintenanceReloadedEvent());
+    }
+
+    public void saveConfig() {
+        try {
+            config.save();
+        } catch (final IOException e) {
+            plugin.getLogger().log(Level.SEVERE, "Couldn't save the config file!", e);
+        }
+    }
+
+    // Public, as it is used in the MaintenanceAddon
+    public void createFile(final String name) {
+        createFile(name, name);
+    }
+
+    private void createFile(final String name, final String from) {
+        final File file = new File(plugin.getDataFolder(), name);
+        if (!file.exists()) {
+            try (final InputStream in = plugin.getResource(from)) {
+                Files.copy(in, file.toPath());
+            } catch (final IOException e) {
+                throw new RuntimeException("Unable to create " + name + " file for Maintenance!", e);
+            }
+        }
+    }
+
+    private void saveWhitelistedPlayers() {
+        try {
+            whitelist.save();
+        } catch (final IOException e) {
+            plugin.getLogger().log(Level.SEVERE, "Couldn't save the whitelisted players file!", e);
+        }
+    }
+
+    private void createLanguageFile() {
+        final String fileName = "language-" + languageName + ".yml";
+        final File file = new File(plugin.getDataFolder(), fileName);
+        if (file.exists()) return;
+
+        try (final InputStream in = plugin.getResource(fileName)) {
+            if (in == null) {
+                throw new IOException("No bundled language file " + fileName);
+            }
+            Files.copy(in, file.toPath());
+        } catch (final IOException e) {
+            plugin.getLogger().warning("Unable to provide language " + languageName);
+            // Fall back to English language (if not already selected)
+            if (!languageName.equals("en")) {
+                plugin.getLogger().warning("Falling back to default language: en");
+                languageName = "en";
+                createLanguageFile();
+            }
+        }
+    }
+
+    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.getSection("messages"));
+        if (pingMessageSection.getBoolean("enable-timer-specific-messages")) {
+            timerSpecificPingMessages = loadPingMessages(pingMessageSection.getSection("timer-messages"));
+        } else {
+            timerSpecificPingMessages = null;
+        }
+
+        maintenance = config.getBoolean("maintenance-enabled");
+        activeMode = normalizeMode(config.getString("active-mode"));
+        activeReason = normalizeReason(config.getString("active-reason"));
+        commandsOnMaintenanceEnable = config.getStringList("commands-on-maintenance-enable");
+        commandsOnMaintenanceDisable = config.getStringList("commands-on-maintenance-disable");
+        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");
+            legacyParsedPlayerCountMessages = loadPlayerCountMessages(playerCountMessageSection.getSection("messages"));
+            if (playerCountMessageSection.getBoolean("enable-timer-specific-message")) {
+                legacyParsedTimerPlayerCountMessages = loadPlayerCountMessages(playerCountMessageSection.getSection("timer-messages"));
+            } else {
+                legacyParsedTimerPlayerCountMessages = null;
+            }
+        }
+
+        final ConfigSection listHoverMessageSection = config.getSection("player-list-hover-message");
+        customPlayerCountHoverMessage = listHoverMessageSection.getBoolean("enabled");
+        legacyParsedPlayerCountHoverLines = loadPlayerCountHoverMessages(listHoverMessageSection.getSection("messages"));
+        if (listHoverMessageSection.getBoolean("enable-timer-specific-message")) {
+            legacyParsedTimerPlayerCountHoverLines = loadPlayerCountHoverMessages(listHoverMessageSection.getSection("timer-messages"));
+        } else {
+            legacyParsedTimerPlayerCountHoverLines = null;
+        }
+
+        languageName = config.getString("language").toLowerCase(Locale.ROOT);
+        kickOnlinePlayers = config.getBoolean("kick-online-players", true);
+        updateChecks = config.getBoolean("update-checks", true);
+        debug = config.getBoolean("debug");
+
+        final ConfigSection webhookSection = config.getSection("webhook");
+        webhookEnabled = webhookSection.getBoolean("enabled");
+        webhookEnabledEvents = new HashSet<>(webhookSection.getStringList("enabled-events"));
+        webhookUrl = webhookSection.getString("url", "");
+        webhookUsername = webhookSection.getString("username", "Maintenance");
+        webhookAvatarUrl = webhookSection.getString("avatar-url", "");
+
+        final ConfigSection section = config.getSection("continue-endtimer-after-restart");
+        saveEndtimerOnStop = section.getBoolean("enabled");
+        savedEndtimer = section.getLong("end");
+
+        if (customMaintenanceIcon) {
+            plugin.loadMaintenanceIcon();
+        }
+
+        loadWhitelistedPlayers();
+
+        loadExtraSettings();
+    }
+
+    protected void loadWhitelistedPlayers() {
+        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());
+            }
+        }
+    }
+
+    private void updatePluginDirectory() {
+        // 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.PAPER) {
+            oldDirName = "MaintenanceSpigot";
+        }
+
+        final File oldDir = new File(plugin.getDataFolder().getParentFile(), oldDirName);
+        if (!oldDir.exists()) {
+            return;
+        }
+
+        try {
+            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);
+        }
+    }
+
+    private void updateConfig() {
+        final int version = config.getInt("config-version");
+        if (version != CONFIG_VERSION) {
+            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);
+                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");
+            }
+            if (version < 11) {
+                config.move("player-count-message.message", "player-count-message.messages.default");
+                config.move("player-count-message.timer-message", "player-count-message.timer-messages.default");
+
+                config.move("player-list-hover-message.message", "player-list-hover-message.messages.default");
+                config.move("player-list-hover-message.timer-message", "player-list-hover-message.timer-messages.default");
+
+                migrateModeSection("ping-message.messages");
+                migrateModeSection("ping-message.timer-messages");
+                migrateModeSection("player-count-message.messages");
+                migrateModeSection("player-count-message.timer-messages");
+                migrateModeSection("player-list-hover-message.messages");
+                migrateModeSection("player-list-hover-message.timer-messages");
+
+                final Object proxiedMaintenanceServers = config.getObject("proxied-maintenance-servers");
+                if (proxiedMaintenanceServers instanceof List<?> list) {
+                    final Map<String, String> migratedServers = new LinkedHashMap<>();
+                    for (final Object entry : list) {
+                        if (entry != null) {
+                            migratedServers.put(String.valueOf(entry), "default");
+                        }
+                    }
+                    config.set("proxied-maintenance-servers", migratedServers);
+                }
+            }
+            if (version < 12) {
+                // Fix typo in the shipped config key :>
+                config.move("redis.enables", "redis.enabled");
+            }
+
+            createFile("config-new.yml", "config.yml");
+            final File file = new File(plugin.getDataFolder(), "config-new.yml");
+            final Config tempConfig = new Config(file, unsupportedFields);
+            try {
+                tempConfig.load();
+            } catch (final IOException e) {
+                e.printStackTrace();
+            }
+
+            config.addMissingFields(tempConfig);
+            config.replaceComments(tempConfig);
+            config.set("config-version", CONFIG_VERSION);
+
+            file.delete();
+            tempConfig.clear();
+
+            saveConfig();
+            plugin.getLogger().info("Done! Updated config!");
+        }
+    }
+
+    private void updateLanguageFile() throws IOException {
+        final int version = language.getInt("language-version");
+        if (version == LANGUAGE_VERSION) {
+            return;
+        }
+
+        plugin.getLogger().info("Updating language file to the latest version...");
+        if (version < 1) {
+            for (final Map.Entry<String, Object> entry : language.getValues().entrySet()) {
+                if (!(entry.getValue() instanceof String value)) {
+                    continue;
+                }
+
+                value = value.replace("&8[&eMaintenance&8] ", "<prefix>");
+                value = legacyToMinimessage(value);
+                value = value.replace("%NEWLINE%", NEW_LINE_REPLACEMENT);
+                language.set(entry.getKey(), value);
+            }
+        }
+
+        final String filePrefix = "language-" + languageName;
+        createFile(filePrefix + "-new.yml", filePrefix + ".yml");
+
+        final File file = new File(plugin.getDataFolder(), filePrefix + "-new.yml");
+        final Config tempConfig = new Config(file);
+        try {
+            tempConfig.load();
+        } finally {
+            file.delete();
+        }
+
+        language.addMissingFields(tempConfig);
+        language.replaceComments(tempConfig);
+        tempConfig.clear();
+
+        language.set("language-version", LANGUAGE_VERSION);
+
+        language.save();
+        plugin.getLogger().info("Updated language file!");
+    }
+
+    private String legacyToMinimessage(final String s) {
+        final TextComponent component = LegacyComponentSerializer.legacyAmpersand().deserialize(s);
+        final String serialized = MiniMessage.miniMessage().serialize(component);
+        //TODO hack to remove explicit closing until fixed in MM
+        return serialized.replaceAll("</[a-z_]+>", "");
+    }
+
+    private void migrateModeSection(final String path) {
+        final Object section = config.getObject(path);
+        if (section == null || section instanceof Map<?, ?>) {
+            return;
+        }
+
+        final Map<String, Object> map = new LinkedHashMap<>();
+        map.put("default", section);
+        config.set(path, map);
+    }
+
+    private String getConfigMessage(final ConfigSection section, final String path) {
+        final String s = section.getString(path);
+        if (s == null) {
+            plugin.getLogger().warning("The config file is missing the following string: " + path);
+            return path;
+        }
+        return replaceNewlineVar(s);
+    }
+
+    public String getConfigMessage(final String path) {
+        return getConfigMessage(config, path);
+    }
+
+    public String getLanguageString(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;
+        }
+        if (replacements.length != 0) {
+            if (replacements.length % 2 != 0) {
+                throw new IllegalArgumentException("Invalid replacement count: " + replacements.length);
+            }
+
+            for (int i = 0; i < replacements.length; i += 2) {
+                final String key = replacements[i];
+                s = s.replace(key, replacements[i + 1]);
+            }
+        }
+        return replaceNewlineVar(s).replace("<prefix>", prefixString);
+    }
+
+    public String getWebhookMessage(final String path, final String... replacements) {
+        String s = language.getString(path);
+        if (s == null) {
+            plugin.getLogger().warning("The language file is missing the following webhook message: " + path);
+            return path;
+        }
+        if (replacements.length != 0) {
+            if (replacements.length % 2 != 0) {
+                throw new IllegalArgumentException("Invalid replacement count: " + replacements.length);
+            }
+
+            for (int i = 0; i < replacements.length; i += 2) {
+                final String key = replacements[i];
+                s = s.replace(key, replacements[i + 1]);
+            }
+        }
+        return replaceNewlineVar(s);
+    }
+
+    public @Nullable String getLanguageStringOrNull(final String path, final String... replacements) {
+        return language.contains(path) ? getLanguageString(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() {
+        return getRandomPingMessage(activeMode);
+    }
+
+    public Component getRandomPingMessage(@Nullable final String mode) {
+        if (plugin.isTaskRunning() && !plugin.getRunnable().shouldEnable() && hasTimerSpecificPingMessages()) {
+            return getPingMessage(timerSpecificPingMessages, mode);
+        }
+        return pingMessages.isEmpty() ? Component.empty() : getPingMessage(pingMessages, mode);
+    }
+
+    private Component getPingMessage(final DisplayedMessages list, @Nullable final String mode) {
+        final String component = list.getRandomEntry(mode);
+        return parse(plugin.replacePingVariables(component, mode));
+    }
+
+    private DisplayedMessages loadPingMessages(final ConfigSection section) {
+        return loadDisplayedMessages(section, (list, s) -> list.add(replaceNewlineVar(s)));
+    }
+
+    private DisplayedMessages loadPlayerCountHoverMessages(final ConfigSection section) {
+        return loadDisplayedMessages(section, (list, s) -> {
+            // Split into separate messages (one per player entry)
+            for (final String line : s.split("<br>")) {
+                list.add(toLegacy(parse(line)));
+            }
+        });
+    }
+
+    private DisplayedMessages loadPlayerCountMessages(final ConfigSection section) {
+        return loadDisplayedMessages(section, (list, s) -> list.add(toLegacy(parse(s))));
+    }
+
+    private DisplayedMessages loadDisplayedMessages(final ConfigSection section, final BiConsumer<List<String>, String> messageFunction) {
+        final Map<String, List<String>> modes = new HashMap<>(section.getKeys().size());
+        for (final Map.Entry<String, Object> entry : section.getValues().entrySet()) {
+            final List<String> components = new ArrayList<>();
+            if (entry.getValue() instanceof String s) {
+                messageFunction.accept(components, s);
+            } else if (entry.getValue() instanceof List<?> list) {
+                //noinspection unchecked
+                for (final String s : ((Iterable<String>) list)) {
+                    messageFunction.accept(components, s);
+                }
+            }
+            modes.put(entry.getKey(), components);
+        }
+        return new DisplayedMessages(modes);
+    }
+
+    @Override
+    public boolean removeWhitelistedPlayer(final UUID uuid) {
+        if (whitelistedPlayers.remove(uuid) == null) {
+            return false;
+        }
+
+        whitelist.remove(uuid.toString());
+        saveWhitelistedPlayers();
+        return true;
+    }
+
+    @Override
+    public boolean removeWhitelistedPlayer(final String name) {
+        UUID uuid = null;
+        for (final Map.Entry<UUID, String> e : whitelistedPlayers.entrySet()) {
+            if (e.getValue().equalsIgnoreCase(name)) {
+                uuid = e.getKey();
+                break;
+            }
+        }
+
+        if (uuid == null) {
+            return false;
+        }
+
+        return removeWhitelistedPlayer(uuid);
+    }
+
+    @Override
+    public boolean addWhitelistedPlayer(final UUID uuid, final String name) {
+        final boolean added = !name.equals(whitelistedPlayers.put(uuid, name));
+        if (!added) {
+            return false;
+        }
+
+        whitelist.set(uuid.toString(), name);
+        saveWhitelistedPlayers();
+        return true;
+    }
+
+    @Override
+    public Map<UUID, String> getWhitelistedPlayers() {
+        return whitelistedPlayers;
+    }
+
+    @Override
+    public boolean isWhitelisted(final UUID uuid) {
+        return whitelistedPlayers.containsKey(uuid);
+    }
+
+    @Override
+    public boolean isMaintenance() {
+        return maintenance;
+    }
+
+    @Override
+    public @Nullable String activeMode() {
+        return activeMode;
+    }
+
+    public void setActiveMode(@Nullable final String activeMode) {
+        final String normalized = normalizeMode(activeMode);
+        if (Objects.equals(this.activeMode, normalized)) {
+            return;
+        }
+
+        this.activeMode = normalized;
+        config.set("active-mode", normalized != null ? normalized : "default");
+        saveConfig();
+    }
+
+    @Override
+    public String activeReason() {
+        return activeReason;
+    }
+
+    @Override
+    public void setActiveReason(@Nullable final String reason) {
+        final String normalized = normalizeReason(reason);
+        if (Objects.equals(this.activeReason, normalized)) {
+            return;
+        }
+
+        this.activeReason = normalized;
+        config.set("active-reason", normalized);
+        saveConfig();
+    }
+
+    public void setMaintenance(final boolean maintenance, @Nullable final String mode) {
+        if (this.maintenance != maintenance) {
+            this.maintenance = maintenance;
+            config.set("maintenance-enabled", maintenance);
+            this.activeMode = normalizeMode(mode);
+            config.set("active-mode", this.activeMode != null ? this.activeMode : "default");
+            saveConfig();
+        }
+    }
+
+    @Override
+    public boolean isEnablePingMessages() {
+        return enablePingMessages;
+    }
+
+    @Override
+    public boolean isJoinNotifications() {
+        return joinNotifications;
+    }
+
+    @Override
+    public boolean hasCustomIcon() {
+        return customMaintenanceIcon;
+    }
+
+    @Override
+    public boolean debugEnabled() {
+        return debug;
+    }
+
+    public boolean hasUpdateChecks() {
+        return updateChecks;
+    }
+
+    public boolean isSaveEndtimerOnStop() {
+        return saveEndtimerOnStop;
+    }
+
+    public boolean hasTimerSpecificPingMessages() {
+        return timerSpecificPingMessages != null;
+    }
+
+    public boolean isKickOnlinePlayers() {
+        return kickOnlinePlayers;
+    }
+
+    public long getSavedEndtimer() {
+        return savedEndtimer;
+    }
+
+    public void setSavedEndtimer(final long millis) {
+        if (savedEndtimer == millis) {
+            return;
+        }
+
+        this.savedEndtimer = millis;
+        config.getSection("continue-endtimer-after-restart").set("end", millis);
+        saveConfig();
+    }
+
+    public Config getConfig() {
+        return config;
+    }
+
+    public DisplayedMessages getPingMessages() {
+        return pingMessages;
+    }
+
+    public List<String> getCommandsOnMaintenanceEnable() {
+        return commandsOnMaintenanceEnable;
+    }
+
+    public List<String> getCommandsOnMaintenanceDisable() {
+        return commandsOnMaintenanceDisable;
+    }
+
+    public @Nullable DisplayedMessages getTimerSpecificPingMessages() {
+        return timerSpecificPingMessages;
+    }
+
+    public Set<Integer> getBroadcastIntervals() {
+        return broadcastIntervals;
+    }
+
+    public boolean isWebhookEnabled() {
+        return webhookEnabled;
+    }
+
+    public boolean isWebhookEventEnabled(final String event) {
+        return webhookEnabledEvents.contains(event);
+    }
+
+    public String getWebhookUrl() {
+        return webhookUrl;
+    }
+
+    public String getWebhookUsername() {
+        return webhookUsername;
+    }
+
+    public String getWebhookAvatarUrl() {
+        return webhookAvatarUrl;
+    }
+
+    public String getPlainTextPrefix() {
+        return plainTextPrefix;
+    }
+
+    public String getLegacyParsedPlayerCountMessage() {
+        return getLegacyParsedPlayerCountMessage(activeMode);
+    }
+
+    public String getLegacyParsedPlayerCountMessage(@Nullable final String mode) {
+        final DisplayedMessages messages = timerDependent(legacyParsedPlayerCountMessages, legacyParsedTimerPlayerCountMessages);
+        final String message = messages.getRandomEntry(mode);
+        return plugin.replacePingVariables(message, mode);
+    }
+
+    public String[] getLegacyParsedPlayerCountHoverLines() {
+        return getLegacyParsedPlayerCountHoverLines(activeMode);
+    }
+
+    public String[] getLegacyParsedPlayerCountHoverLines(@Nullable final String mode) {
+        final DisplayedMessages messages = timerDependent(legacyParsedPlayerCountHoverLines, legacyParsedTimerPlayerCountHoverLines);
+        final List<String> lines = messages.getMessages(mode);
+        final String[] parsedLines = new String[lines.size()];
+        for (int i = 0; i < lines.size(); i++) {
+            parsedLines[i] = plugin.replacePingVariables(lines.get(i), mode);
+        }
+        return parsedLines;
+    }
+
+    private <T> T timerDependent(final T normal, final @Nullable T timerSpecific) {
+        return timerSpecific != null && plugin.isTaskRunning() && !plugin.getRunnable().shouldEnable() ? timerSpecific : normal;
+    }
+
+    public Component getKickMessage() {
+        return parse(plugin.replacePingVariables(getLanguageString("kickmessage")));
+    }
+
+    public String getLanguage() {
+        return languageName;
+    }
+
+    public boolean hasCustomPlayerCountMessage() {
+        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: |-
+     *     First line text
+     *      Second line text.
+     *      ...
+     *
+     * This also happens to string lists, making those practically unreadable (in particular the motd list), as well as confusing for most users in general.
+     * Because of this, I replace <br> manually, to spare users from these ugly breaks (before I inevitably switch to a different configuration library).
+     */
+    protected String replaceNewlineVar(final String s) {
+        return s.replace(NEW_LINE_REPLACEMENT, "\n");
+    }
+
+    protected @Nullable String normalizeMode(@Nullable final String mode) {
+        if (mode == null || mode.isBlank() || mode.equalsIgnoreCase("default")) {
+            return null;
+        }
+        return mode.toLowerCase(Locale.ROOT);
+    }
+
+    private String normalizeReason(@Nullable final String reason) {
+        return reason == null || reason.isBlank() ? "" : reason;
+    }
+
+    protected void loadExtraSettings() {
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/CommandInfo.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,12 +15,13 @@
  * 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.command;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Collections;
 import java.util.List;
@@ -29,19 +30,29 @@ public abstract class CommandInfo {
     protected final MaintenancePlugin plugin;
     private final String helpMessageKey;
     private final String permission;
+    private final boolean visible;
 
-    protected CommandInfo(final MaintenancePlugin plugin, final String permission) {
+    protected CommandInfo(final MaintenancePlugin plugin, @Nullable final String permission) {
+        this(plugin, permission, true);
+    }
+
+    protected CommandInfo(final MaintenancePlugin plugin, @Nullable final String permission, final boolean visible) {
         this.plugin = plugin;
         this.permission = permission;
         // Just take the class name as the language key
         this.helpMessageKey = "help" + getClass().getSimpleName().replace("Command", "");
+        this.visible = visible;
     }
 
     public boolean hasPermission(final SenderInfo sender) {
         return sender.hasMaintenancePermission(permission);
     }
 
-    public String getHelpMessage() {
+    public boolean isVisible() {
+        return visible;
+    }
+
+    public Component getHelpMessage() {
         return getMessage(helpMessageKey);
     }
 
@@ -53,7 +64,7 @@ public abstract class CommandInfo {
 
     protected boolean checkPermission(final SenderInfo sender, final String permission) {
         if (!sender.hasMaintenancePermission(permission)) {
-            sender.sendMessage(getMessage("noPermission"));
+            sender.send(getMessage("noPermission"));
             return true;
         }
         return false;
@@ -61,14 +72,14 @@ public abstract class CommandInfo {
 
     protected boolean checkArgs(final SenderInfo sender, final String[] args, final int length) {
         if (args.length != length) {
-            sender.sendMessage(getHelpMessage());
+            sender.send(getHelpMessage());
             return true;
         }
         return false;
     }
 
-    protected String getMessage(final String s) {
-        return plugin.getSettings().getMessage(s);
+    protected Component getMessage(final String path, final String... replacements) {
+        return plugin.getSettings().getMessage(path, replacements);
     }
 
     protected Settings getSettings() {

core/src/main/java/eu/kennytv/maintenance/core/command/MaintenanceCommand.java

@@ -0,0 +1,214 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.Settings;
+import eu.kennytv.maintenance.core.command.subcommand.AbortTimerCommand;
+import eu.kennytv.maintenance.core.command.subcommand.DebugCommand;
+import eu.kennytv.maintenance.core.command.subcommand.DumpCommand;
+import eu.kennytv.maintenance.core.command.subcommand.EndtimerCommand;
+import eu.kennytv.maintenance.core.command.subcommand.HelpCommand;
+import eu.kennytv.maintenance.core.command.subcommand.MotdCommand;
+import eu.kennytv.maintenance.core.command.subcommand.ReloadCommand;
+import eu.kennytv.maintenance.core.command.subcommand.RemoveMotdCommand;
+import eu.kennytv.maintenance.core.command.subcommand.ScheduleTimerCommand;
+import eu.kennytv.maintenance.core.command.subcommand.SetReasonCommand;
+import eu.kennytv.maintenance.core.command.subcommand.SetMotdCommand;
+import eu.kennytv.maintenance.core.command.subcommand.StarttimerCommand;
+import eu.kennytv.maintenance.core.command.subcommand.StatusCommand;
+import eu.kennytv.maintenance.core.command.subcommand.ToggleCommand;
+import eu.kennytv.maintenance.core.command.subcommand.UpdateCommand;
+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 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<>();
+    private final List<CommandInfo> commands = new ArrayList<>();
+    private final HelpCommand help;
+
+    protected MaintenanceCommand(final MaintenancePlugin plugin, final Settings settings) {
+        this.plugin = plugin;
+        this.settings = settings;
+        help = new HelpCommand(plugin);
+    }
+
+    protected void registerCommands() {
+        add(help, "help");
+        add(new ReloadCommand(plugin), "reload");
+
+        addToggleAndTimerCommands();
+
+        add(new WhitelistCommand(plugin), "whitelist");
+        add(new WhitelistAddCommand(plugin), "add");
+        add(new WhitelistRemoveCommand(plugin), "remove");
+
+        add(new SetMotdCommand(plugin), "setmotd");
+        add(new RemoveMotdCommand(plugin), "removemotd");
+        add(new MotdCommand(plugin), "motd");
+        add(new SetReasonCommand(plugin), "setreason");
+
+        add(new UpdateCommand(plugin), "update", "forceupdate");
+        add(new DumpCommand(plugin), "dump");
+        add(new DebugCommand(plugin), "debug");
+    }
+
+    protected void add(final CommandInfo command, final String... aliases) {
+        commands.add(command);
+        for (final String alias : aliases) {
+            commandExecutors.put(alias, command);
+        }
+    }
+
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (!sender.hasMaintenancePermission("command")) {
+            sender.send(settings.getMessage("noPermission"));
+            return;
+        }
+        if (args.length == 0) {
+            help.sendUsage(sender);
+            return;
+        }
+
+        final CommandInfo command = commandExecutors.get(args[0].toLowerCase(Locale.ROOT));
+        if (command == null) {
+            help.sendUsage(sender);
+            return;
+        }
+        if (!command.hasPermission(sender)) {
+            sender.send(settings.getMessage("noPermission"));
+            return;
+        }
+
+        command.execute(sender, args);
+    }
+
+    public List<String> getSuggestions(final SenderInfo sender, final String[] args) {
+        if (!sender.hasMaintenancePermission("command") || args.length == 0) return Collections.emptyList();
+        final String s = args[0].toLowerCase(Locale.ROOT);
+        if (args.length == 1) {
+            final List<String> list = new ArrayList<>();
+            for (final Map.Entry<String, CommandInfo> entry : commandExecutors.entrySet()) {
+                final String command = entry.getKey();
+                final CommandInfo info = entry.getValue();
+                if (info.isVisible() && command.startsWith(s) && info.hasPermission(sender)) {
+                    list.add(command);
+                }
+            }
+            return list;
+        }
+
+        final CommandInfo info = commandExecutors.get(args[0]);
+        return info != null && info.hasPermission(sender) ? info.getTabCompletion(sender, args) : Collections.emptyList();
+    }
+
+    /**
+     * Converts a user given time like {@code 2d}, {@code 2d12h}, {@code 1h5m}, or {@code 30s} to an ISO-8601 duration string.
+     * Days are supported in addition to hours, minutes, and seconds.
+     *
+     * @return ISO duration string
+     */
+    private static String toIsoDuration(final String time) {
+        final String upper = time.toUpperCase(Locale.ROOT);
+        final int dayIndex = upper.indexOf('D');
+        if (dayIndex == -1) {
+            return "PT" + upper;
+        }
+
+        final String days = upper.substring(0, dayIndex + 1);
+        final String rest = upper.substring(dayIndex + 1);
+        return rest.isEmpty() ? "P" + days : "P" + days + "T" + rest;
+    }
+
+    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 {
+                duration = Duration.parse(toIsoDuration(time));
+            } catch (final DateTimeParseException e) {
+                return null;
+            }
+        }
+
+        if (taskCheck) {
+            if (plugin.isTaskRunning()) {
+                sender.send(settings.getMessage("timerAlreadyRunning"));
+                return null;
+            }
+        }
+
+        final long seconds = duration.getSeconds();
+        if (seconds > MAX_TASK_DURATION_SECONDS) {
+            sender.send(settings.getMessage("timerTooLong"));
+            return null;
+        }
+        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;
+        }
+        return duration;
+    }
+
+    public @Nullable Duration parseDurationAndCheckTask(final SenderInfo sender, final String time) {
+        return parseDurationAndCheckTask(sender, time, true);
+    }
+
+    protected void addToggleAndTimerCommands() {
+        add(new ToggleCommand(plugin), "on", "off");
+        add(new StatusCommand(plugin), "status");
+
+        add(new StarttimerCommand(plugin), "starttimer", "start");
+        add(new EndtimerCommand(plugin), "endtimer", "end");
+        add(new ScheduleTimerCommand(plugin), "scheduletimer", "schedule");
+        add(new AbortTimerCommand(plugin), "aborttimer", "abort");
+    }
+
+    public List<String> getServersCompletion(final String s) {
+        return null;
+    }
+
+    public List<String> getMaintenanceServersCompletion(final String s) {
+        return null;
+    }
+
+    public List<String> getPlayersCompletion() {
+        return null;
+    }
+
+    public List<CommandInfo> getCommands() {
+        return commands;
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/AbortTimerCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
@@ -31,16 +30,16 @@ public final class AbortTimerCommand extends CommandInfo {
     @Override
     public void execute(final SenderInfo sender, final String[] args) {
         if (args.length != 1) {
-            sender.sendMessage(getHelpMessage());
+            sender.send(getHelpMessage());
             return;
         }
 
         if (!plugin.isTaskRunning()) {
-            sender.sendMessage(getMessage("timerNotRunning"));
+            sender.send(getMessage("timerNotRunning"));
             return;
         }
 
         plugin.cancelTask();
-        sender.sendMessage(getMessage("timerCancelled"));
+        sender.send(getMessage("timerCancelled"));
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/DebugCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,29 +15,23 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
 
-public final class ToggleCommand extends CommandInfo {
+public final class DebugCommand extends CommandInfo {
 
-    public ToggleCommand(final MaintenancePlugin plugin) {
-        super(plugin, "toggle");
+    public DebugCommand(final MaintenancePlugin plugin) {
+        super(plugin, "debug", false);
     }
 
     @Override
     public void execute(final SenderInfo sender, final String[] args) {
         if (checkArgs(sender, args, 1)) return;
 
-        final boolean maintenance = args[0].equalsIgnoreCase("on");
-        if (maintenance == plugin.isMaintenance()) {
-            sender.sendMessage(getMessage(maintenance ? "alreadyEnabled" : "alreadyDisabled"));
-            return;
-        }
-
-        plugin.setMaintenance(maintenance);
+        plugin.setDebug(!plugin.isDebug());
+        sender.sendPrefixedRich("<gray>Debug mode is now " + (plugin.isDebug() ? "<green>enabled" : "<red>disabled"));
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/DumpCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,14 +15,19 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-
 import java.util.concurrent.TimeUnit;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.event.HoverEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import static eu.kennytv.maintenance.core.util.ComponentUtil.clickEvent;
 
 public final class DumpCommand extends CommandInfo {
     private long lastDump;
@@ -35,24 +40,30 @@ 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.sendMessage(plugin.getPrefix() + "§cYou can only create a dump every 5 minutes!");
+            sender.sendPrefixedRich("<red>You can only create a dump every 5 minutes!");
             return;
         }
 
         lastDump = System.currentTimeMillis();
-        sender.sendMessage(plugin.getPrefix() + "§7The dump is being created, this might take a moment.");
+        sender.sendPrefixedRich("<gray>The dump is being created, this might take a moment.");
         plugin.async(() -> {
             final String key = plugin.pasteDump();
             if (key == null) {
-                if (sender.isPlayer())
-                    sender.sendMessage(plugin.getPrefix() + "§cCould not paste dump (see the console for details)");
+                if (sender.isPlayer()) {
+                    sender.sendPrefixedRich("<red>Could not paste dump (see the console for details)");
+                }
                 return;
             }
 
-            final String url = "https://hasteb.in/" + key;
-            sender.sendMessage(plugin.getPrefix() + "§c" + url);
-            if (sender.isPlayer())
-                plugin.getCommandManager().sendDumpMessage(sender, url);
+            final String url = "https://pastes.dev/" + key;
+            sender.sendPrefixedRich("<red><click:open_url:'" + url + "'>" + url + "</click>");
+            if (sender.isPlayer()) {
+                final TextComponent text = Component.text().content("Click here to copy the link").color(NamedTextColor.GRAY)
+                        .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));
+            }
         });
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/EndtimerCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,12 +15,14 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.DiscordWebhook;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.time.Duration;
+import net.kyori.adventure.text.Component;
 
 public final class EndtimerCommand extends CommandInfo {
 
@@ -31,16 +33,23 @@ public final class EndtimerCommand extends CommandInfo {
     @Override
     public void execute(final SenderInfo sender, final String[] args) {
         if (checkArgs(sender, args, 2)) return;
-        if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
-            sender.sendMessage(getHelpMessage());
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
+        if (duration == null) {
+            sender.send(getHelpMessage());
             return;
         }
         if (!plugin.isMaintenance()) {
-            sender.sendMessage(getMessage("alreadyDisabled"));
+            sender.send(getMessage("alreadyDisabled"));
             return;
         }
 
-        plugin.startMaintenanceRunnableForMinutes(Integer.parseInt(args[1]), false);
-        sender.sendMessage(getMessage("endtimerStarted").replace("%TIME%", plugin.getRunnable().getTime()));
+        plugin.startMaintenanceRunnable(duration, false);
+
+        final Component message = getMessage("endtimerStarted", "%TIME%", plugin.getRunnable().getTime());
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookEndtimerStarted", DiscordWebhook.EventType.ENDTIMER_STARTED,
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/HelpCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,16 +15,15 @@
  * 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.command.subcommand;
 
 import com.google.common.base.Preconditions;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-
 import java.util.ArrayList;
 import java.util.List;
+import net.kyori.adventure.text.Component;
 
 public final class HelpCommand extends CommandInfo {
     private static final int COMMANDS_PER_PAGE = 8;
@@ -36,21 +35,22 @@ public final class HelpCommand extends CommandInfo {
     @Override
     public void execute(final SenderInfo sender, final String[] args) {
         if (args.length > 2) {
-            sender.sendMessage(getHelpMessage());
+            sender.send(getHelpMessage());
             return;
         }
 
         if (args.length == 1) {
             sendUsage(sender);
-        } else {
-            if (!plugin.isNumeric(args[1])) {
-                sender.sendMessage(getHelpMessage());
-                return;
-            }
-
-            final int page = Integer.parseInt(args[1]);
-            sendUsage(sender, page == 0 ? 1 : page);
+            return;
         }
+
+        if (!plugin.isNumeric(args[1])) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final int page = Integer.parseInt(args[1]);
+        sendUsage(sender, page == 0 ? 1 : page);
     }
 
     public void sendUsage(final SenderInfo sender) {
@@ -59,36 +59,37 @@ public final class HelpCommand extends CommandInfo {
 
     public void sendUsage(final SenderInfo sender, final int page) {
         Preconditions.checkArgument(page > 0);
-        final List<String> commands = new ArrayList<>();
+        final List<Component> commands = new ArrayList<>();
         for (final CommandInfo cmd : plugin.getCommandManager().getCommands()) {
-            if (cmd.hasPermission(sender)) {
+            if (cmd.isVisible() && cmd.hasPermission(sender)) {
                 commands.add(cmd.getHelpMessage());
             }
         }
         if ((page - 1) * COMMANDS_PER_PAGE >= commands.size()) {
-            sender.sendMessage(getMessage("helpPageNotFound"));
+            sender.send(getMessage("helpPageNotFound"));
             return;
         }
 
-        final List<String> filteredCommands;
-        if (page * COMMANDS_PER_PAGE >= commands.size())
-            filteredCommands = commands.subList((page - 1) * COMMANDS_PER_PAGE, commands.size());
-        else
-            filteredCommands = commands.subList((page - 1) * COMMANDS_PER_PAGE, page * COMMANDS_PER_PAGE);
+        final List<Component> filteredCommands = commands.subList((page - 1) * COMMANDS_PER_PAGE, Math.min(page * COMMANDS_PER_PAGE, commands.size()));
 
-        final String header = getMessage("helpHeader").replace("%NAME%", "Maintenance" + plugin.getServerType())
-                .replace("%PAGE%", Integer.toString(page)).replace("%MAX%", Integer.toString((commands.size() + getDivide(commands.size())) / COMMANDS_PER_PAGE));
-        sender.sendMessage("");
-        sender.sendMessage(header);
-        for (final String command : filteredCommands) {
-            sender.sendMessage(command);
+        final Component header = getMessage("helpHeader",
+                "%NAME%", "Maintenance" + plugin.getServerType(),
+                "%PAGE%", Integer.toString(page),
+                "%MAX%", Integer.toString((commands.size() + getDivide(commands.size())) / COMMANDS_PER_PAGE));
+        sender.send(Component.empty());
+        sender.send(header);
+        for (final Component command : filteredCommands) {
+            sender.send(command);
         }
-        if (page * COMMANDS_PER_PAGE < commands.size())
-            sender.sendMessage(getMessage("helpNextPage").replace("%PAGE%", Integer.toString(page + 1)));
-        else
-            sender.sendMessage("§8× §eVersion " + plugin.getVersion() + " §7by §bKennyTV");
-        sender.sendMessage(header);
-        sender.sendMessage("");
+
+        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.send(header);
+        sender.send(Component.empty());
     }
 
     private int getDivide(final int size) {

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/MotdCommand.java

@@ -0,0 +1,109 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.config.ConfigSection;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import org.jetbrains.annotations.Nullable;
+
+public final class MotdCommand extends CommandInfo {
+
+    public MotdCommand(final MaintenancePlugin plugin) {
+        super(plugin, "motd");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        int indexOffset = 1;
+        boolean timer = false;
+        if (args.length > indexOffset && args[indexOffset].equalsIgnoreCase("timer")) {
+            if (!getSettings().hasTimerSpecificPingMessages()) {
+                sender.send(getMessage("timerMotdDisabled"));
+                return;
+            }
+
+            timer = true;
+            indexOffset++;
+        }
+
+        if (args.length > indexOffset + 1) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final String mode = args.length == indexOffset + 1 ? args[indexOffset].toLowerCase(Locale.ROOT) : "default";
+        final ConfigSection section = getSettings().getConfig().getSection("ping-message").getSection(timer ? "timer-messages" : "messages");
+        sendList(sender, getModeMessages(section, mode));
+    }
+
+    private void sendList(final SenderInfo sender, @Nullable final List<String> list) {
+        if (list == null || list.isEmpty()) {
+            sender.send(getMessage("motdListEmpty"));
+            return;
+        }
+
+        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).replace("<br>", "\n"));
+        }
+        sender.sendRich("<dark_gray><st>----------");
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length < 2 || args.length > 3) {
+            return Collections.emptyList();
+        }
+
+        if (args.length == 2) {
+            final List<String> list = new ArrayList<>();
+            if (getSettings().hasTimerSpecificPingMessages()) {
+                list.add("timer");
+            }
+
+            final List<String> modes = new ArrayList<>(getSettings().getConfig().getSection("ping-message").getSection("messages").getKeys());
+            modes.remove("default");
+            list.addAll(modes);
+            return list;
+        }
+
+        if (!args[1].equalsIgnoreCase("timer") || !getSettings().hasTimerSpecificPingMessages()) {
+            return Collections.emptyList();
+        }
+
+        final List<String> modes = new ArrayList<>(getSettings().getConfig().getSection("ping-message").getSection("timer-messages").getKeys());
+        modes.remove("default");
+        return modes;
+    }
+
+    private @Nullable List<String> getModeMessages(final ConfigSection section, final String mode) {
+        final Object value = section.getObject(mode);
+        if (value instanceof String s) {
+            return Collections.singletonList(s);
+        }
+        return section.getStringList(mode);
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/ReloadCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
@@ -32,6 +31,6 @@ public final class ReloadCommand extends CommandInfo {
     public void execute(final SenderInfo sender, final String[] args) {
         if (checkArgs(sender, args, 1)) return;
         getSettings().reloadConfigs();
-        sender.sendMessage(getMessage("reload"));
+        sender.send(getMessage("reload"));
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/RemoveMotdCommand.java

@@ -0,0 +1,143 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.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 java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class RemoveMotdCommand extends CommandInfo {
+
+    public RemoveMotdCommand(final MaintenancePlugin plugin) {
+        super(plugin, "setmotd");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        int indexOffset = 1;
+        boolean timerPingMessages = false;
+        if (args.length > indexOffset && args[indexOffset].equalsIgnoreCase("timer")) {
+            if (!getSettings().hasTimerSpecificPingMessages()) {
+                sender.send(getMessage("timerMotdDisabled"));
+                return;
+            }
+
+            indexOffset++;
+            timerPingMessages = true;
+        }
+
+        if (args.length <= indexOffset) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        String mode = "default";
+        if (!plugin.isNumeric(args[indexOffset])) {
+            mode = args[indexOffset].toLowerCase(Locale.ROOT);
+            indexOffset++;
+        }
+
+        if (args.length != indexOffset + 1 || !plugin.isNumeric(args[indexOffset])) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final Settings settings = getSettings();
+        final ConfigSection section = settings.getConfig().getSection("ping-message");
+        final ConfigSection messageSection = section.getSection(timerPingMessages ? "timer-messages" : "messages");
+        final List<String> pingMessages = getModeMessages(messageSection, mode);
+        if (pingMessages.isEmpty()) {
+            sender.send(getMessage("motdListEmpty"));
+            return;
+        }
+        if (mode.equals("default") && pingMessages.size() < 2) {
+            sender.send(getMessage("removeMotdError"));
+            return;
+        }
+
+        final int index = Integer.parseInt(args[indexOffset]);
+        if (index == 0 || index > pingMessages.size()) {
+            sender.send(getMessage("setMotdIndexError",
+                    "%MOTDS%", Integer.toString(pingMessages.size()),
+                    "%NEWAMOUNT%", Integer.toString(pingMessages.size())));
+            return;
+        }
+
+        pingMessages.remove(index - 1);
+        if (pingMessages.isEmpty()) {
+            messageSection.remove(mode);
+        } else {
+            messageSection.set(mode, pingMessages);
+        }
+        settings.saveConfig();
+        settings.reloadConfigs();
+        sender.send(getMessage("removedMotd", "%INDEX%", Integer.toString(index)));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        final int indexOffset;
+        final boolean timer;
+        if (args.length > 1 && args[1].equalsIgnoreCase("timer")) {
+            timer = true;
+            indexOffset = 2;
+        } else {
+            timer = false;
+            indexOffset = 1;
+        }
+
+        if (args.length == indexOffset + 1 && !plugin.isNumeric(args[indexOffset])) {
+            return getModeCompletions(timer);
+        }
+
+        if (args.length == indexOffset + 1 || (args.length == indexOffset + 2 && !plugin.isNumeric(args[indexOffset]))) {
+            final String mode = plugin.isNumeric(args[indexOffset]) ? "default" : args[indexOffset].toLowerCase(Locale.ROOT);
+            final int size = getModeMessages(getSettings().getConfig().getSection("ping-message").getSection(timer ? "timer-messages" : "messages"), mode).size();
+            final List<String> list = new ArrayList<>(size);
+            for (int i = 1; i <= size; i++) {
+                list.add(Integer.toString(i));
+            }
+            return list;
+        }
+
+        return Collections.emptyList();
+    }
+
+    private List<String> getModeCompletions(final boolean timer) {
+        final List<String> modes = new ArrayList<>(getSettings().getConfig().getSection("ping-message").getSection(timer ? "timer-messages" : "messages").getKeys());
+        modes.remove("default");
+        return modes;
+    }
+
+    private List<String> getModeMessages(final ConfigSection section, final String mode) {
+        final Object value = section.getObject(mode);
+        if (value == null) {
+            return List.of();
+        }
+        if (value instanceof String s) {
+            return new ArrayList<>(Collections.singletonList(s));
+        }
+        return new ArrayList<>(section.getStringList(mode));
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/ScheduleTimerCommand.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.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;
+
+public final class ScheduleTimerCommand extends CommandInfo {
+
+    public ScheduleTimerCommand(final MaintenancePlugin plugin) {
+        super(plugin, "timer");
+    }
+
+    @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) {
+            sender.send(getHelpMessage());
+            return;
+        }
+        if (plugin.isMaintenance()) {
+            sender.send(getMessage("alreadyEnabled"));
+            return;
+        }
+
+        plugin.scheduleMaintenanceRunnable(enableIn, maintenanceDuration);
+        sender.send(getMessage(
+                "scheduletimerStarted",
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%DURATION%", plugin.getFormattedTime((int) maintenanceDuration.getSeconds())
+        ));
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/SetMotdCommand.java

@@ -0,0 +1,174 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.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 java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import static eu.kennytv.maintenance.core.Settings.NEW_LINE_REPLACEMENT;
+
+public final class SetMotdCommand extends CommandInfo {
+
+    public SetMotdCommand(final MaintenancePlugin plugin) {
+        super(plugin, "setmotd");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        int indexOffset = 1;
+        boolean timerPingMessages = false;
+        if (args.length > indexOffset && args[indexOffset].equalsIgnoreCase("timer")) {
+            if (!getSettings().hasTimerSpecificPingMessages()) {
+                sender.send(getMessage("timerMotdDisabled"));
+                return;
+            }
+
+            indexOffset++;
+            timerPingMessages = true;
+        }
+
+        if (args.length <= indexOffset + 2) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        String mode = "default";
+        if (!plugin.isNumeric(args[indexOffset])) {
+            mode = args[indexOffset].toLowerCase(Locale.ROOT);
+            indexOffset++;
+        }
+
+        if (args.length <= indexOffset + 2 || !plugin.isNumeric(args[indexOffset])) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final Settings settings = getSettings();
+        final ConfigSection section = settings.getConfig().getSection("ping-message");
+        final ConfigSection messageSection = section.getSection(timerPingMessages ? "timer-messages" : "messages");
+        final List<String> pingMessages = getOrCreateModeMessages(messageSection, mode);
+
+        final int index = Integer.parseInt(args[indexOffset]);
+        if (index == 0 || index > pingMessages.size() + 1) {
+            sender.send(getMessage("setMotdIndexError",
+                    "%MOTDS%", Integer.toString(pingMessages.size()),
+                    "%NEWAMOUNT%", Integer.toString(pingMessages.size() + 1)));
+            return;
+        }
+
+        if (!plugin.isNumeric(args[indexOffset + 1])) {
+            sender.send(getMessage("setMotdLineError"));
+            return;
+        }
+
+        final int line = Integer.parseInt(args[indexOffset + 1]);
+        if (line != 1 && line != 2) {
+            sender.send(getMessage("setMotdLineError"));
+            return;
+        }
+
+        final String message = String.join(" ", Arrays.copyOfRange(args, indexOffset + 2, args.length));
+        final String oldMessage = index > pingMessages.size() ? "" : pingMessages.get(index - 1);
+        final String newMessage;
+        if (line == 1) {
+            newMessage = oldMessage.contains(NEW_LINE_REPLACEMENT)
+                    ? message + NEW_LINE_REPLACEMENT + oldMessage.split(NEW_LINE_REPLACEMENT, 2)[1]
+                    : message;
+        } else {
+            newMessage = oldMessage.contains(NEW_LINE_REPLACEMENT)
+                    ? oldMessage.split(NEW_LINE_REPLACEMENT, 2)[0] + NEW_LINE_REPLACEMENT + message
+                    : oldMessage + NEW_LINE_REPLACEMENT + message;
+        }
+
+        if (index > pingMessages.size()) {
+            pingMessages.add(newMessage);
+        } else {
+            pingMessages.set(index - 1, newMessage);
+        }
+
+        messageSection.set(mode, pingMessages);
+        settings.saveConfig();
+        settings.reloadConfigs();
+
+        sender.send(settings.getMessage(
+                "setMotd",
+                "%LINE%", Integer.toString(line),
+                "%INDEX%", Integer.toString(index),
+                "%MOTD%", newMessage.replace(NEW_LINE_REPLACEMENT, "\n")
+        ));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        final int indexOffset;
+        final boolean timer;
+        if (args.length > 1 && args[1].equalsIgnoreCase("timer")) {
+            timer = true;
+            indexOffset = 2;
+        } else {
+            timer = false;
+            indexOffset = 1;
+        }
+
+        if (args.length == indexOffset + 2) {
+            return Arrays.asList("1", "2");
+        }
+
+        if (args.length == indexOffset + 1 && !plugin.isNumeric(args[indexOffset])) {
+            return getModeCompletions(timer);
+        }
+
+        if (args.length == indexOffset + 1) {
+            final String mode = plugin.isNumeric(args[indexOffset]) ? "default" : args[indexOffset].toLowerCase(Locale.ROOT);
+            final ConfigSection section = getSettings().getConfig().getSection("ping-message").getSection(timer ? "timer-messages" : "messages");
+            final int size = getOrCreateModeMessages(section, mode).size();
+            final List<String> list = new ArrayList<>();
+            for (int i = 1; i <= size + 1; i++) {
+                list.add(String.valueOf(i));
+            }
+            return list;
+        }
+        return Collections.emptyList();
+    }
+
+    private List<String> getModeCompletions(final boolean timer) {
+        final List<String> modes = new ArrayList<>(getSettings().getConfig().getSection("ping-message").getSection(timer ? "timer-messages" : "messages").getKeys());
+        modes.remove("default");
+        return modes;
+    }
+
+    private List<String> getOrCreateModeMessages(final ConfigSection section, final String mode) {
+        final Object value = section.getObject(mode);
+        if (value == null) {
+            return new ArrayList<>();
+        }
+
+        if (value instanceof String s) {
+            return new ArrayList<>(Collections.singletonList(s));
+        }
+        return new ArrayList<>(section.getStringList(mode));
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/SetReasonCommand.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+
+import java.util.Collections;
+import java.util.List;
+
+public final class SetReasonCommand extends CommandInfo {
+
+    public SetReasonCommand(final MaintenancePlugin plugin) {
+        super(plugin, "setreason");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length < 2) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final String value = String.join(" ", java.util.Arrays.copyOfRange(args, 1, args.length));
+        final String reason;
+        if (value.equalsIgnoreCase("none") || value.equalsIgnoreCase("clear") || value.equals("-")) {
+            reason = null;
+        } else {
+            reason = value;
+        }
+
+        getSettings().setActiveReason(reason);
+        sender.send(getMessage("setReason", "%REASON%", reason == null ? "-" : reason));
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length != 2) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList("none");
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/StarttimerCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,12 +15,14 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.DiscordWebhook;
 import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.time.Duration;
+import net.kyori.adventure.text.Component;
 
 public final class StarttimerCommand extends CommandInfo {
 
@@ -31,16 +33,23 @@ public final class StarttimerCommand extends CommandInfo {
     @Override
     public void execute(final SenderInfo sender, final String[] args) {
         if (checkArgs(sender, args, 2)) return;
-        if (plugin.getCommandManager().checkTimerArgs(sender, args[1])) {
-            sender.sendMessage(getHelpMessage());
+
+        final Duration duration = plugin.getCommandManager().parseDurationAndCheckTask(sender, args[1]);
+        if (duration == null) {
+            sender.send(getHelpMessage());
             return;
         }
         if (plugin.isMaintenance()) {
-            sender.sendMessage(getMessage("alreadyEnabled"));
+            sender.send(getMessage("alreadyEnabled"));
             return;
         }
 
-        plugin.startMaintenanceRunnableForMinutes(Integer.parseInt(args[1]), true);
-        sender.sendMessage(getMessage("starttimerStarted").replace("%TIME%", plugin.getRunnable().getTime()));
+        plugin.startMaintenanceRunnable(duration, true);
+
+        final Component message = getMessage("starttimerStarted", "%TIME%", plugin.getRunnable().getTime());
+        sender.send(message);
+        plugin.sendWebhookMessage("webhookStarttimerStarted", DiscordWebhook.EventType.STARTTIMER_STARTED,
+                "%TIME%", plugin.getRunnable().getTime(),
+                "%TIMESTAMP%", plugin.getTargetTimestamp(duration));
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/StatusCommand.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.runnable.MaintenanceRunnable;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import net.kyori.adventure.text.Component;
+
+public final class StatusCommand extends CommandInfo {
+
+    public StatusCommand(final MaintenancePlugin plugin) {
+        super(plugin, "status");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        final MaintenanceRunnable task = plugin.getCurrentTask();
+        if (task != null) {
+            final String key = task.shouldEnable() ? "maintenanceStatusOffWithStartTimer" : "maintenanceStatusOnWithEndTimer";
+            sender.send(getMessage(key, "%TIME%", task.getTime()));
+        } else {
+            sender.send(getMessage(plugin.isMaintenance() ? "maintenanceStatusOn" : "maintenanceStatusOff"));
+        }
+    }
+
+    @Override
+    public Component getHelpMessage() {
+        return getMessage("helpGlobalStatus");
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/ToggleCommand.java

@@ -0,0 +1,77 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class ToggleCommand extends CommandInfo {
+
+    public ToggleCommand(final MaintenancePlugin plugin) {
+        super(plugin, "toggle");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 0 || args.length > 2) {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        final boolean maintenance = args[0].equalsIgnoreCase("on");
+        final String mode;
+        if (maintenance && args.length == 2) {
+            mode = args[1].toLowerCase(Locale.ROOT);
+        } else if (!maintenance && args.length == 1) {
+            mode = null;
+        } else if (maintenance) {
+            mode = null;
+        } else {
+            sender.send(getHelpMessage());
+            return;
+        }
+
+        if (maintenance == plugin.isMaintenance()) {
+            if (mode != null) {
+                plugin.getSettings().setActiveMode(mode);
+                return;
+            }
+
+            sender.send(getMessage(maintenance ? "alreadyEnabled" : "alreadyDisabled"));
+            return;
+        }
+
+        plugin.setMaintenance(maintenance, mode);
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        if (args.length != 2 || !args[0].equalsIgnoreCase("on")) {
+            return Collections.emptyList();
+        }
+
+        final List<String> modes = new ArrayList<>(getSettings().getPingMessages().getKeys());
+        modes.remove("default");
+        return modes;
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/UpdateCommand.java

@@ -0,0 +1,76 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.SenderInfo;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.event.HoverEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public final class UpdateCommand extends CommandInfo {
+
+    public UpdateCommand(final MaintenancePlugin plugin) {
+        super(plugin, "update");
+    }
+
+    @Override
+    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;
+        }
+
+        if (!plugin.updateAvailable()) {
+            sender.sendPrefixedRich("<green>You already have the latest version of the plugin!");
+            return;
+        }
+
+        sender.send(getMessage("updateDownloading"));
+        try {
+            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());
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/WhitelistAddCommand.java

@@ -0,0 +1,108 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.command.subcommand;
+
+import eu.kennytv.maintenance.core.MaintenancePlugin;
+import eu.kennytv.maintenance.core.command.CommandInfo;
+import eu.kennytv.maintenance.core.util.DummySenderInfo;
+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 {
+
+    public WhitelistAddCommand(final MaintenancePlugin plugin) {
+        super(plugin, "whitelist.add");
+    }
+
+    @Override
+    public void execute(final SenderInfo sender, final String[] args) {
+        if (args.length == 2) {
+            if (args[1].length() == 36) {
+                final UUID uuid = plugin.checkUUID(sender, args[1]);
+                if (uuid != null) {
+                    addPlayerToWhitelist(sender, uuid);
+                }
+            } else {
+                addPlayerToWhitelist(sender, args[1]);
+            }
+        } else if (args.length == 3) {
+            if (args[1].length() != 36) {
+                sender.send(getHelpMessage());
+                return;
+            }
+
+            final UUID uuid = plugin.checkUUID(sender, args[1]);
+            if (uuid != null) {
+                addPlayerToWhitelist(sender, new DummySenderInfo(uuid, args[2]));
+            }
+        } else {
+            sender.send(getHelpMessage());
+        }
+    }
+
+    @Override
+    public List<String> getTabCompletion(final SenderInfo sender, final String[] args) {
+        return args.length == 2 ? plugin.getCommandManager().getPlayersCompletion() : Collections.emptyList();
+    }
+
+    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;
+            }
+
+            if (selected == null) {
+                sender.send(getMessage("playerNotOnline"));
+                return;
+            }
+
+            addPlayerToWhitelist(sender, selected);
+        });
+    }
+
+    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;
+            }
+
+            if (selected == null) {
+                sender.send(getMessage("playerNotFoundUuid"));
+                return;
+            }
+
+            addPlayerToWhitelist(sender, selected);
+        });
+    }
+
+    private void addPlayerToWhitelist(final SenderInfo sender, final SenderInfo selected) {
+        if (getSettings().addWhitelistedPlayer(selected.uuid(), selected.name())) {
+            sender.send(getMessage("whitelistAdded", "%PLAYER%", selected.name()));
+        } else {
+            sender.send(getMessage("whitelistAlreadyAdded", "%PLAYER%", selected.name()));
+        }
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/WhitelistCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
@@ -24,6 +23,7 @@ import eu.kennytv.maintenance.core.util.SenderInfo;
 
 import java.util.Map;
 import java.util.UUID;
+import net.kyori.adventure.text.Component;
 
 public final class WhitelistCommand extends CommandInfo {
 
@@ -37,14 +37,17 @@ public final class WhitelistCommand extends CommandInfo {
 
         final Map<UUID, String> players = getSettings().getWhitelistedPlayers();
         if (players.isEmpty()) {
-            sender.sendMessage(getMessage("whitelistEmpty"));
-        } else {
-            sender.sendMessage(getMessage("whitelistedPlayers"));
-            final String format = getMessage("whitelistedPlayersFormat");
-            for (final Map.Entry<UUID, String> entry : players.entrySet()) {
-                sender.sendMessage(format.replace("%NAME%", entry.getValue()).replace("%UUID%", entry.getKey().toString()));
-            }
-            sender.sendMessage("");
+            sender.send(getMessage("whitelistEmpty"));
+            return;
         }
+
+        sender.send(getMessage("whitelistedPlayers"));
+        final Component format = getMessage("whitelistedPlayersFormat");
+        for (final Map.Entry<UUID, String> entry : players.entrySet()) {
+            sender.send(format.replaceText(builder -> builder.matchLiteral("%NAME%").replacement(entry.getValue()))
+                    .replaceText(builder -> builder.matchLiteral("%UUID%").replacement(entry.getKey().toString())));
+        }
+
+        sender.send(Component.empty());
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/command/subcommand/WhitelistRemoveCommand.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.command.subcommand;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
@@ -25,6 +24,7 @@ import eu.kennytv.maintenance.core.util.SenderInfo;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.UUID;
 
 public final class WhitelistRemoveCommand extends CommandInfo {
@@ -38,10 +38,12 @@ public final class WhitelistRemoveCommand extends CommandInfo {
         if (checkArgs(sender, args, 2)) return;
         if (args[1].length() == 36) {
             final UUID uuid = plugin.checkUUID(sender, args[1]);
-            if (uuid != null)
+            if (uuid != null) {
                 removePlayerFromWhitelist(sender, uuid);
-        } else
+            }
+        } else {
             removePlayerFromWhitelist(sender, args[1]);
+        }
     }
 
     @Override
@@ -49,8 +51,9 @@ public final class WhitelistRemoveCommand extends CommandInfo {
         if (args.length != 2) return Collections.emptyList();
 
         final List<String> list = new ArrayList<>();
+        String matchNameLowerCase = args[1].toLowerCase(Locale.ROOT);
         for (final String name : getSettings().getWhitelistedPlayers().values()) {
-            if (name.toLowerCase().startsWith(args[1])) {
+            if (name.toLowerCase(Locale.ROOT).startsWith(matchNameLowerCase)) {
                 list.add(name);
             }
         }
@@ -58,30 +61,35 @@ public final class WhitelistRemoveCommand extends CommandInfo {
     }
 
     private void removePlayerFromWhitelist(final SenderInfo sender, final String name) {
-        final SenderInfo selected = plugin.getOfflinePlayer(name);
-        if (selected == null) {
-            if (getSettings().removeWhitelistedPlayer(name))
-                sender.sendMessage(getMessage("whitelistRemoved").replace("%PLAYER%", name));
-            else
-                sender.sendMessage(getMessage("whitelistNotFound"));
-            return;
-        }
+        plugin.getOfflinePlayer(name).whenComplete((selected, ex) -> {
+            if (selected == null) {
+                if (getSettings().removeWhitelistedPlayer(name)) {
+                    sender.send(getMessage("whitelistRemoved", "%PLAYER%", name));
+                } else {
+                    sender.send(getMessage("whitelistNotFound"));
+                }
+                return;
+            }
 
-        whitelistRemoveMessage(sender, selected.getUuid(), selected.getName());
+            removePlayerFromWhitelist(sender, selected.uuid(), selected.name());
+        });
     }
 
     private void removePlayerFromWhitelist(final SenderInfo sender, final UUID uuid) {
-        final SenderInfo selected = plugin.getOfflinePlayer(uuid);
-        if (selected == null)
-            whitelistRemoveMessage(sender, uuid, uuid.toString());
-        else
-            whitelistRemoveMessage(sender, selected.getUuid(), selected.getName());
+        plugin.getOfflinePlayer(uuid).whenComplete((selected, ex) -> {
+            if (selected == null) {
+                removePlayerFromWhitelist(sender, uuid, uuid.toString());
+            } else {
+                removePlayerFromWhitelist(sender, selected.uuid(), selected.name());
+            }
+        });
     }
 
-    private void whitelistRemoveMessage(final SenderInfo sender, final UUID uuid, final String toReplace) {
-        if (getSettings().removeWhitelistedPlayer(uuid))
-            sender.sendMessage(getMessage("whitelistRemoved").replace("%PLAYER%", toReplace));
-        else
-            sender.sendMessage(getMessage("whitelistNotFound"));
+    private void removePlayerFromWhitelist(final SenderInfo sender, final UUID uuid, final String toReplace) {
+        if (plugin.getSettings().removeWhitelistedPlayer(uuid)) {
+            sender.send(getMessage("whitelistRemoved", "%PLAYER%", toReplace));
+        } else {
+            sender.send(getMessage("whitelistNotFound"));
+        }
     }
 }

core/src/main/java/eu/kennytv/maintenance/core/config/Config.java

@@ -0,0 +1,156 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.config;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Collections;
+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.
+ *
+ * @author PSandro on 26.01.19
+ * @author kennytv
+ */
+public final class Config extends ConfigSection {
+
+    private static final String AWESOME_HEADER =
+            """
+                    ###################################################################################################################
+                    #   __  __       _       _                                    _             _                          _          #
+                    #  |  \\/  | __ _(_)_ __ | |_ ___ _ __   __ _ _ __   ___ ___  | |__  _   _  | | _____ _ __  _ __  _   _| |___   __ #
+                    #  | |\\/| |/ _` | | '_ \\| __/ _ \\ '_ \\ / _` | '_ \\ / __/ _ \\ | '_ \\| | | | | |/ / _ \\ '_ \\| '_ \\| | | | __\\ \\ / / #
+                    #  | |  | | (_| | | | | | ||  __/ | | | (_| | | | | (_|  __/ | |_) | |_| | |   <  __/ | | | | | | |_| | |_ \\ V /  #
+                    #  |_|  |_|\\__,_|_|_| |_|\\__\\___|_| |_|\\__,_|_| |_|\\___\\___| |_.__/ \\__, | |_|\\_\\___|_| |_|_| |_|\\__, |\\__| \\_/   #
+                    #                                                                  |___/                        |___/             #
+                    ###################################################################################################################
+                    # You can report bugs here: https://github.com/kennytv/Maintenance/issues
+                    # If you need any other help/support, you can also join my Discord server: https://discord.gg/vGCUzHq
+                    # The config and language files use MiniMessage, NOT legacy text for input. Use https://webui.advntr.dev/ to edit and preview the formatted text.
+                    # For a full list of formats and fancy examples of MiniMessage, see https://docs.papermc.io/adventure/minimessage/format/
+                    """;
+    private final Yaml yaml = createYaml();
+    private final File file;
+    private final Set<String> unsupportedFields;
+    private Map<String, String[]> comments = new HashMap<>();
+    private String header;
+
+    public Config(final File file, final String... unsupportedFields) {
+        super(null, "");
+        this.file = file;
+        this.unsupportedFields = unsupportedFields.length == 0 ? Collections.emptySet() : Set.of(unsupportedFields);
+    }
+
+    public void load() throws IOException {
+        final String data = Files.readString(this.file.toPath());
+        final Map<String, Object> map = yaml.load(data);
+        this.values = map != null ? map : new LinkedHashMap<>();
+        this.comments = ConfigSerializer.deserializeComments(data);
+
+        final String[] header = comments.remove(".header");
+        if (header != null) {
+            this.header = String.join("\n", header);
+        }
+
+        final boolean removedFields = values.keySet().removeIf(key -> {
+            final String[] split = key.split("\\.");
+            String splitKey = "";
+            for (final String s : split) {
+                splitKey += s;
+                if (!unsupportedFields.contains(splitKey)) {
+                    splitKey += ".";
+                    continue;
+                }
+
+                // Unsupported field
+                comments.remove(key);
+                return true;
+            }
+            return false;
+        });
+        if (removedFields) {
+            save();
+        }
+    }
+
+    public void save() throws IOException {
+        saveTo(file);
+    }
+
+    public void saveTo(final File file) throws IOException {
+        if (file.getParentFile() != null) {
+            file.getParentFile().mkdirs();
+        }
+        file.createNewFile();
+        Files.writeString(file.toPath(), toString());
+    }
+
+    public void replaceComments(final Config fromConfig) {
+        this.comments = new HashMap<>(fromConfig.comments);
+    }
+
+    private static Yaml createYaml() {
+        final DumperOptions options = new DumperOptions();
+        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        options.setPrettyFlow(false);
+        options.setIndent(2);
+        options.setWidth(10_000); // be sneaky because autobreak on saving looks disgusting
+        return new Yaml(options);
+    }
+
+    public void clear() {
+        this.values.clear();
+        this.comments.clear();
+        this.header = null;
+    }
+
+    public Map<String, String[]> getComments() {
+        return comments;
+    }
+
+    public Set<String> getUnsupportedFields() {
+        return unsupportedFields;
+    }
+
+    @Override
+    public Config getRoot() {
+        return this;
+    }
+
+    @Nullable
+    public String getHeader() {
+        return header;
+    }
+
+    public void resetAwesomeHeader() {
+        this.header = AWESOME_HEADER;
+    }
+
+    @Override
+    public String toString() {
+        return ConfigSerializer.serialize(this.header, this.values, this.comments, this.yaml);
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/config/ConfigSection.java

@@ -0,0 +1,255 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.config;
+
+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.
+ *
+ * @author kennytv
+ */
+public class ConfigSection {
+
+    protected final Config root;
+    protected final String currentPath;
+    protected Map<String, Object> values;
+
+    ConfigSection(final Config root, final String currentPath) {
+        this(root, currentPath, new LinkedHashMap<>());
+    }
+
+    ConfigSection(final Config root, final String currentPath, final Map<String, Object> values) {
+        this.root = root;
+        this.currentPath = currentPath;
+        this.values = values;
+    }
+
+    @Nullable
+    public <E> E get(final String key) {
+        return (E) getObject(key);
+    }
+
+    @Nullable
+    public <E> E get(final String key, @Nullable final E def) {
+        final Object o = getObject(key);
+        return o != null ? (E) o : def;
+    }
+
+    @Nullable
+    public Object getObject(final String key) {
+        return getObject(key, null);
+    }
+
+    @Nullable
+    public Object getObject(final String key, final Object def) {
+        final String[] parts = key.split("\\.");
+        ConfigSection section = this;
+        for (int i = 0; i < parts.length - 1; i++) {
+            section = section.getSection(parts[i]);
+            if (section == null) {
+                return def;
+            }
+        }
+
+        final String valueKey = parts[parts.length - 1];
+        final Object o = section.values.get(valueKey);
+        return o != null ? o : def;
+    }
+
+    @Nullable
+    public <E> E getOrSet(final String key, @Nullable final E def) {
+        final Object o = getObject(key);
+        if (o != null) {
+            return (E) o;
+        } else {
+            this.set(key, def);
+            return def;
+        }
+    }
+
+    @Nullable
+    public ConfigSection getSection(final String key) {
+        final Object o = getObject(key);
+        if (!(o instanceof Map)) return null;
+        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);
+        if (value == null) {
+            section.values.remove(sectionKey);
+            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);
+        }
+    }
+
+    public void remove(final String key) {
+        set(key, null);
+    }
+
+    public Set<String> getKeys() {
+        return this.values.keySet();
+    }
+
+    public Map<String, Object> getValues() {
+        return this.values;
+    }
+
+    public boolean getBoolean(final String key) {
+        return getBoolean(key, false);
+    }
+
+    public boolean getBoolean(final String key, final boolean def) {
+        final Object o = getObject(key);
+        return o instanceof Boolean ? (boolean) o : def;
+    }
+
+    @Nullable
+    public String getString(final String key) {
+        return get(key);
+    }
+
+    @Nullable
+    public String getString(final String key, @Nullable final String def) {
+        final Object o = getObject(key);
+        return o instanceof String s ? s : def;
+    }
+
+    public int getInt(final String key) {
+        return getInt(key, 0);
+    }
+
+    public int getInt(final String key, final int def) {
+        final Object o = getObject(key);
+        return o instanceof Number number ? number.intValue() : def;
+    }
+
+    public double getDouble(final String key) {
+        return getDouble(key, 0D);
+    }
+
+    public double getDouble(final String key, final double def) {
+        final Object o = getObject(key);
+        return o instanceof Number number ? number.doubleValue() : def;
+    }
+
+    public long getLong(final String key) {
+        return getLong(key, 0L);
+    }
+
+    public long getLong(final String key, final long def) {
+        final Object o = getObject(key);
+        return o instanceof Number number ? number.longValue() : def;
+    }
+
+    @Nullable
+    public List<String> getStringList(final String key) {
+        return get(key);
+    }
+
+    @Nullable
+    public List<String> getStringList(final String key, @Nullable final List<String> def) {
+        final List<String> list = get(key);
+        return list != null ? list : def;
+    }
+
+    @Nullable
+    public List<Integer> getIntList(final String key) {
+        return get(key);
+    }
+
+    @Nullable
+    public List<Integer> getIntList(final String key, @Nullable final List<Integer> def) {
+        final List<Integer> list = get(key);
+        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
+     */
+    public Config getRoot() {
+        return root;
+    }
+
+    /**
+     * @return current path, or empty string if root
+     */
+    public String getCurrentPath() {
+        return currentPath;
+    }
+
+    protected String getFullKeyInPath(final String key) {
+        return currentPath.isEmpty() ? key : currentPath + '.' + key;
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/config/ConfigSerializer.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.config;
 
 import org.yaml.snakeyaml.Yaml;
@@ -27,10 +26,10 @@ import java.util.Map;
 import java.util.regex.Pattern;
 
 /**
- * Further modified version of the SimpleConfig project of PSandro (https://github.com/PSandro/SimpleConfig).
+ * Further modified version of the <a href="https://github.com/PSandro/SimpleConfig">SimpleConfig</a>SimpleConfig project of PSandro.
  *
  * @author PSandro on 26.01.19
- * @author KennyTV
+ * @author kennytv
  */
 public final class ConfigSerializer {
 
@@ -40,7 +39,9 @@ public final class ConfigSerializer {
     private static final int INDENT_UNIT = 2;
 
     public static String serialize(final String header, final Map<String, Object> data, final Map<String, String[]> comments, final Yaml yaml) {
-        if (data.isEmpty()) return yaml.dump(null);
+        if (data.isEmpty()) {
+            return yaml.dump(null);
+        }
 
         final String rawYaml = yaml.dump(data);
         final StringBuilder fileData = new StringBuilder();
@@ -61,46 +62,60 @@ public final class ConfigSerializer {
                 key = join(array, array.length - backspace);
                 keyLine = true;
             } else {
-                keyLine = line.contains(":");
+                keyLine = line.indexOf(':') != -1;
             }
 
-            if (keyLine) {
-                final String newKey = substring.split(Pattern.quote(":"))[0]; // Not sure about the quote thing, so I'll just keep it :aaa:
-                if (!key.isEmpty())
-                    key += PATH_SEPARATOR_STRING;
-                key += newKey;
+            if (!keyLine) {
+                // Nothing to do, go to next line
+                fileData.append(line).append('\n');
+                continue;
+            }
 
+            final String newKey = substring.split(Pattern.quote(":"))[0]; // Not sure about the quote thing, so I'll just keep it :aaa:
+            if (!key.isEmpty()) {
+                key += PATH_SEPARATOR_STRING;
+            }
+            key += newKey;
+
+            // Add comments if present
+            if (comments != null) {
                 final String[] strings = comments.get(key);
                 if (strings != null) {
                     final String indentText = indent > 0 ? line.substring(0, indent) : "";
                     for (final String comment : strings) {
-                        if (comment.isEmpty())
+                        if (comment.isEmpty()) {
                             fileData.append('\n');
-                        else
+                        } else {
                             fileData.append(indentText).append(comment).append('\n');
+                        }
                     }
                 }
-
-                currentKeyIndents = indents;
             }
 
+            currentKeyIndents = indents;
             fileData.append(line).append('\n');
         }
         return header != null && !header.isEmpty() ? header + fileData : fileData.toString();
     }
 
     public static Map<String, String[]> deserializeComments(final String data) {
+        //TODO go through known yaml keys and figure out comments from there instead of from line to line?
+        // ... tho everything here would benefit from a cleanup
         final Map<String, String[]> comments = new HashMap<>();
         final List<String> currentComments = new ArrayList<>();
         boolean header = true;
+        boolean multiLineValue = false;
         int currentIndents = 0;
         String key = "";
         for (final String line : data.split("\n")) {
             final String s = line.trim();
+            // It's a comment!
             if (s.startsWith("#")) {
                 currentComments.add(s);
                 continue;
             }
+
+            // Header is over - save it!
             if (header) {
                 if (!currentComments.isEmpty()) {
                     currentComments.add("");
@@ -109,21 +124,39 @@ public final class ConfigSerializer {
                 }
                 header = false;
             }
+
+            // Save empty lines as well
             if (s.isEmpty()) {
                 currentComments.add(s);
                 continue;
             }
 
+            // Multi line values?
+            if (s.startsWith("- |")) {
+                multiLineValue = true;
+                continue;
+            }
+
             final int indent = getIndents(line);
             final int indents = indent / INDENT_UNIT;
+            // Check if the multi line value is over
+            if (multiLineValue) {
+                if (indents > currentIndents) continue;
+
+                multiLineValue = false;
+            }
+
+            // Check if this is a level lower
             if (indents <= currentIndents) {
                 final String[] array = key.split(PATH_SEPARATOR_QUOTED);
                 final int backspace = currentIndents - indents + 1;
-                key = join(array, array.length - backspace);
+                final int delta = array.length - backspace;
+                key = delta >= 0 ? join(array, delta) : key;
             }
 
+            // Finish current key
             final String separator = key.isEmpty() ? "" : PATH_SEPARATOR_STRING;
-            final String lineKey = line.contains(":") ? line.split(Pattern.quote(":"))[0] : line;
+            final String lineKey = line.indexOf(':') != -1 ? line.split(Pattern.quote(":"))[0] : line;
             key += separator + lineKey.substring(indent);
             currentIndents = indents;
 
@@ -138,8 +171,11 @@ public final class ConfigSerializer {
     private static int getIndents(final String line) {
         int count = 0;
         for (int i = 0; i < line.length(); i++) {
-            if (line.charAt(i) == ' ') count++;
-            else break;
+            if (line.charAt(i) != ' ') {
+                break;
+            }
+
+            count++;
         }
         return count;
     }

core/src/main/java/eu/kennytv/maintenance/core/config/DisplayedMessages.java

@@ -0,0 +1,62 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.config;
+
+import com.google.common.base.Preconditions;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public final class DisplayedMessages {
+
+    private static final Random RANDOM = new Random();
+    private final Map<String, List<String>> messages;
+    private final List<String> defaultMessages;
+
+    public DisplayedMessages(final Map<String, List<String>> messages) {
+        this.messages = messages;
+        this.defaultMessages = messages.get("default");
+    }
+
+    public List<String> getMessages(@Nullable final String key) {
+        Preconditions.checkNotNull(defaultMessages, "no default message configured in messages list");
+        if (key == null || messages.size() == 1) {
+            return defaultMessages;
+        }
+        return messages.getOrDefault(key, defaultMessages);
+    }
+
+    public String getRandomEntry(@Nullable final String key) {
+        final List<String> messages = getMessages(key);
+        return messages.get(RANDOM.nextInt(messages.size()));
+    }
+
+    public List<String> getDefaultMessages() {
+        return defaultMessages;
+    }
+
+    public boolean isEmpty() {
+        return messages.isEmpty();
+    }
+
+    public Set<String> getKeys() {
+        return messages.keySet();
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/dump/MaintenanceDump.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,10 +15,8 @@
  * 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.dump;
 
-import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
@@ -26,7 +24,9 @@ import eu.kennytv.maintenance.core.Settings;
 import java.io.File;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 
+@SuppressWarnings({"FieldCanBeLocal", "unused"})
 public final class MaintenanceDump {
     private final ServerDump general;
     private final Map<String, Object> configuration;
@@ -36,17 +36,37 @@ public final class MaintenanceDump {
         general = new ServerDump(plugin.getVersion(), plugin.getServerType().toString(), plugin.getServerVersion(), plugin.getMaintenanceServersDump());
 
         configuration = new LinkedHashMap<>(settings.getConfig().getValues());
-        final Object o = configuration.get("mysql");
-        if (o instanceof Map) {
-            final Map<String, Object> map = new LinkedHashMap<>(((Map<String, Object>) o));
-            map.keySet().removeIf(key -> !key.equals("use-mysql") && !key.equals("update-interval"));
-            configuration.put("mysql", map);
-        }
+        addDBSettings("redis", "enabled");
+        redact("webhook", "url");
         configuration.put("whitelisted-players", settings.getWhitelistedPlayers());
         configuration.put("icon-exists", new File(plugin.getDataFolder(), "maintenance-icon.png").exists());
 
         final JsonObject jsonObject = new JsonObject();
-        jsonObject.add("plugins", new GsonBuilder().create().toJsonTree(plugin.getPlugins()));
+        jsonObject.add("plugins", MaintenancePlugin.GSON.toJsonTree(plugin.getPlugins()));
         plugins = jsonObject;
     }
+
+    private void redact(final String key, final String... subKeys) {
+        final Object o = configuration.get(key);
+        if (o instanceof Map) {
+            final Map<String, Object> map = new LinkedHashMap<>(((Map<String, Object>) o));
+            for (final String subKey : subKeys) {
+                final Object value = map.get(subKey);
+                if (value != null) {
+                    map.put(subKey, value.toString().isEmpty() ? "" : "<redacted>");
+                }
+            }
+            configuration.put(key, map);
+        }
+    }
+
+    private void addDBSettings(final String key, final String... allowedSubKeys) {
+        final Set<String> allowedSubKeysSet = Set.of(allowedSubKeys);
+        final Object o = configuration.get(key);
+        if (o instanceof Map) {
+            final Map<String, Object> map = new LinkedHashMap<>(((Map<String, Object>) o));
+            map.keySet().removeIf(subKey -> !allowedSubKeysSet.contains(subKey));
+            configuration.put(key, map);
+        }
+    }
 }

core/src/main/java/eu/kennytv/maintenance/core/dump/PluginDump.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,16 +15,11 @@
  * 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.dump;
 
 import java.util.List;
 
-public final class PluginDump {
-    private final String name;
-    private final String version;
-    private final List<String> authors;
-
+public record PluginDump(String name, String version, List<String> authors) {
     public PluginDump(final String name, final String version, final List<String> authors) {
         this.name = name;
         this.version = version;

core/src/main/java/eu/kennytv/maintenance/core/dump/ServerDump.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,21 +15,9 @@
  * 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.dump;
 
 import java.util.List;
 
-public final class ServerDump {
-    private final String pluginVersion;
-    private final String platform;
-    private final String serverVersion;
-    private final List<String> maintenance;
-
-    public ServerDump(final String pluginVersion, final String platform, final String serverVersion, final List<String> maintenance) {
-        this.pluginVersion = pluginVersion;
-        this.platform = platform;
-        this.serverVersion = serverVersion;
-        this.maintenance = maintenance;
-    }
+public record ServerDump(String pluginVersion, String platform, String serverVersion, List<String> maintenance) {
 }

core/src/main/java/eu/kennytv/maintenance/core/event/EventManager.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,11 +15,9 @@
  * 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.event;
 
 import eu.kennytv.maintenance.api.event.manager.EventListener;
-import eu.kennytv.maintenance.api.event.manager.IEventManager;
 import eu.kennytv.maintenance.api.event.manager.MaintenanceEvent;
 
 import java.util.ArrayList;
@@ -27,7 +25,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-public final class EventManager implements IEventManager {
+public final class EventManager implements eu.kennytv.maintenance.api.event.manager.EventManager {
     private final Map<String, List<EventListener>> listeners = new HashMap<>();
 
     @Override
@@ -35,6 +33,7 @@ public final class EventManager implements IEventManager {
         listeners.computeIfAbsent(eventClass.getSimpleName(), s -> new ArrayList<>()).add(listener);
     }
 
+    @Override
     public void callEvent(final MaintenanceEvent event) {
         final List<EventListener> list = listeners.get(event.getClass().getSimpleName());
         if (list != null) {

core/src/main/java/eu/kennytv/maintenance/core/hook/LuckPermsHook.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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.hook;
+
+import eu.kennytv.maintenance.api.Maintenance;
+import net.luckperms.api.LuckPermsProvider;
+import net.luckperms.api.context.ContextCalculator;
+import net.luckperms.api.context.ContextConsumer;
+import net.luckperms.api.context.ContextSet;
+import net.luckperms.api.context.ImmutableContextSet;
+import org.jetbrains.annotations.NotNull;
+
+public final class LuckPermsHook {
+
+    public static <T> void register(final Maintenance maintenance) {
+        LuckPermsProvider.get().getContextManager().registerCalculator(new MaintenanceCalculator<T>(maintenance));
+    }
+
+    public static final class MaintenanceCalculator<T> implements ContextCalculator<T> {
+
+        public static final String MAINTENANCE_KEY = "is-maintenance";
+        private final Maintenance maintenance;
+
+        private MaintenanceCalculator(final Maintenance maintenance) {
+            this.maintenance = maintenance;
+        }
+
+        @Override
+        public void calculate(@NotNull final T target, @NotNull final ContextConsumer consumer) {
+            consumer.accept(MAINTENANCE_KEY, Boolean.toString(maintenance.isMaintenance()));
+        }
+
+        @Override
+        public ContextSet estimatePotentialContexts() {
+            return ImmutableContextSet.builder().add(MAINTENANCE_KEY, "true").add(MAINTENANCE_KEY, "false").build();
+        }
+    }
+}

core/src/main/java/eu/kennytv/maintenance/core/hook/ServerListPlusHook.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,7 +15,6 @@
  * 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.hook;
 
 import net.minecrell.serverlistplus.core.ServerListPlusCore;
@@ -25,9 +24,10 @@ public final class ServerListPlusHook {
     private final ServerListPlusCore serverListPlusCore;
 
     public ServerListPlusHook(final Object serverListPlus) {
-        if (!(serverListPlus instanceof ServerListPlusPlugin))
+        if (!(serverListPlus instanceof ServerListPlusPlugin serverListPlusPlugin)) {
             throw new IllegalArgumentException("Couldn't parse ServerListPlus instance!");
-        this.serverListPlusCore = ((ServerListPlusPlugin) serverListPlus).getCore();
+        }
+        this.serverListPlusCore = serverListPlusPlugin.getCore();
     }
 
     public void setEnabled(final boolean enable) {

core/src/main/java/eu/kennytv/maintenance/core/listener/JoinListenerBase.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,21 +15,27 @@
  * 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.listener;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
+import eu.kennytv.maintenance.core.util.DiscordWebhook;
 import eu.kennytv.maintenance.core.util.SenderInfo;
-
 import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.event.HoverEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+
+import static eu.kennytv.maintenance.core.util.ComponentUtil.clickEvent;
 
 public abstract class JoinListenerBase {
     protected final MaintenancePlugin plugin;
     protected final Settings settings;
-    protected final UUID notifyUuid = new UUID(-6334418481592579467L, -4779835342378829761L);
     private final Set<UUID> notifiedPlayers = new HashSet<>();
 
     protected JoinListenerBase(final MaintenancePlugin plugin, final Settings settings) {
@@ -44,13 +50,16 @@ public abstract class JoinListenerBase {
      * @return true if the sender should be kicked
      */
     protected boolean shouldKick(final SenderInfo sender, final boolean updateCheck) {
-        if (!settings.isMaintenance() || sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.getUuid())) {
+        if (!settings.isMaintenance() || sender.hasMaintenancePermission("bypass") || settings.isWhitelisted(sender.uuid())) {
             if (updateCheck) {
                 updateCheck(sender);
             }
             return false;
         }
 
+        if (settings.isWebhookEnabled()) {
+            plugin.sendWebhookMessage("webhookJoinNotification", DiscordWebhook.EventType.BLOCKED_JOIN, "%PLAYER%", sender.name());
+        }
         return true;
     }
 
@@ -59,17 +68,23 @@ public abstract class JoinListenerBase {
     }
 
     protected void updateCheck(final SenderInfo sender) {
-        if (sender.getUuid().equals(notifyUuid)) {
-            sender.sendMessage("§6Maintenance §aVersion " + plugin.getVersion());
-            return;
-        }
         if (!settings.hasUpdateChecks()) return;
-        if (!sender.hasPermission("maintenance.admin") || notifiedPlayers.contains(sender.getUuid())) return;
+        if (!sender.hasPermission("maintenance.admin") || notifiedPlayers.contains(sender.uuid())) return;
         plugin.async(() -> {
-            if (!plugin.updateAvailable()) return;
-            notifiedPlayers.add(sender.getUuid());
-            sender.sendMessage(plugin.getPrefix() + "§cThere is a newer version available: §aVersion " + plugin.getNewestVersion() + "§c, you're on §a" + plugin.getVersion());
-            plugin.sendUpdateNotification(sender);
+            if (!plugin.updateAvailable()) {
+                return;
+            }
+
+            notifiedPlayers.add(sender.uuid());
+            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.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));
         });
     }
 

core/src/main/java/eu/kennytv/maintenance/core/runnable/MaintenanceRunnable.java

@@ -1,6 +1,6 @@
 /*
- * Maintenance - https://git.io/maintenancemode
- * Copyright (C) 2018 KennyTV (https://github.com/KennyTV)
+ * This file is part of Maintenance - https://github.com/kennytv/Maintenance
+ * Copyright (C) 2018-2024 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
@@ -15,30 +15,37 @@
  * 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.runnable;
 
 import eu.kennytv.maintenance.core.MaintenancePlugin;
 import eu.kennytv.maintenance.core.Settings;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
 
-public final class MaintenanceRunnable extends MaintenanceRunnableBase {
+public class MaintenanceRunnable extends MaintenanceRunnableBase {
+    protected final String mode;
 
     public MaintenanceRunnable(final MaintenancePlugin plugin, final Settings settings, final int seconds, final boolean enable) {
+        this(plugin, settings, seconds, enable, null);
+    }
+
+    public MaintenanceRunnable(final MaintenancePlugin plugin, final Settings settings, final int seconds, final boolean enable, @Nullable final String mode) {
         super(plugin, settings, seconds, enable);
+        this.mode = mode;
     }
 
     @Override
     protected void finish() {
-        plugin.setMaintenance(enable);
+        plugin.setMaintenance(enable, mode);
     }
 
     @Override
-    protected String startMessageKey() {
-        return settings.getMessage("starttimerBroadcast").replace("%TIME%", getTime());
+    protected Component getStartMessage() {
+        return settings.getMessage("starttimerBroadcast", "%TIME%", getTime());
     }
 
     @Override
-    protected String endMessageKey() {
-        return settings.getMessage("endtimerBroadcast").replace("%TIME%", getTime());
+    protected Component getEndMessage() {
+        return settings.getMessage("endtimerBroadcast", "%TIME%", getTime());
     }
 }