Advanced configuration for MOTDs with schedule weights priorities

common/src/main/java/xyz/jpenilla/minimotd/common/MiniMOTD.java

@@ -24,7 +24,6 @@
 package xyz.jpenilla.minimotd.common;
 
 import java.nio.file.Path;
-import java.util.concurrent.ThreadLocalRandom;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@@ -33,6 +32,10 @@
 import org.slf4j.Logger;
 import xyz.jpenilla.minimotd.common.config.ConfigManager;
 import xyz.jpenilla.minimotd.common.config.MOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDRepository;
+import xyz.jpenilla.minimotd.common.config.MOTDSettings;
+import xyz.jpenilla.minimotd.common.model.MOTD;
+import xyz.jpenilla.minimotd.common.util.MOTDSelector;
 import xyz.jpenilla.minimotd.common.util.MiniPlaceholdersUtil;
 
 import static net.kyori.adventure.text.Component.newline;
@@ -75,7 +78,10 @@ public ConfigManager configManager() {
     return this.configManager;
   }
 
-  public PingResponse<I> createMOTD(final MOTDConfig config, final int onlinePlayers, final int maxPlayers) {
+  public PingResponse<I> createMOTD(final MOTDSettings motdSettings, final int onlinePlayers, final int maxPlayers) {
+    final MOTDConfig config = motdSettings.getMotdConfig();
+    final MOTDRepository motdRepository = motdSettings.getMotdRepository();
+
     final PingResponse.PlayerCount count = config.modifyPlayerCount(onlinePlayers, maxPlayers);
     final PingResponse.Builder<I> response = PingResponse.<I>builder()
       .playerCount(count)
@@ -84,18 +90,18 @@ public PingResponse<I> createMOTD(final MOTDConfig config, final int onlinePlaye
 
     String iconString = null;
     if (config.motdEnabled()) {
-      if (config.motds().isEmpty()) {
+      if (motdRepository.motds().isEmpty()) {
         throw new IllegalStateException("MOTD is enabled, but there are no MOTDs in the config file?");
       }
-      final int index = config.motds().size() == 1 ? 0 : ThreadLocalRandom.current().nextInt(config.motds().size());
-      final MOTDConfig.MOTD motdConfig = config.motds().get(index);
-      final Component motd = Component.textOfChildren(
-        parse(motdConfig.line1(), count),
+
+      final MOTD motd = MOTDSelector.select(motdRepository.motds());
+      final Component motdComponent = Component.textOfChildren(
+        parse(motd.line1(), count),
         newline(),
-        parse(motdConfig.line2(), count)
+        parse(motd.line2(), count)
       );
-      response.motd(motd);
-      iconString = motdConfig.icon();
+      response.motd(motdComponent);
+      iconString = motd.icon();
     }
 
     if (config.iconEnabled()) {

common/src/main/java/xyz/jpenilla/minimotd/common/config/ConfigManager.java

@@ -27,11 +27,7 @@
 import java.net.InetSocketAddress;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.jspecify.annotations.NonNull;
@@ -47,12 +43,12 @@ public final class ConfigManager {
   private final MiniMOTD<?> miniMOTD;
 
   private final ConfigLoader<MOTDConfig> mainConfigLoader;
-  private MOTDConfig mainConfig;
+  private MOTDSettings motdSettings;
 
   private final ConfigLoader<PluginSettings> pluginSettingsLoader;
   private PluginSettings pluginSettings;
 
-  private final Map<String, MOTDConfig> extraConfigs = new HashMap<>();
+  private final Map<String, MOTDSettings> extraConfigs = new HashMap<>();
 
   public ConfigManager(final @NonNull MiniMOTD<?> miniMOTD) {
     this.miniMOTD = miniMOTD;
@@ -70,8 +66,8 @@ public ConfigManager(final @NonNull MiniMOTD<?> miniMOTD) {
 
   public void loadConfigs() {
     try {
-      this.mainConfig = this.mainConfigLoader.load();
-      this.mainConfigLoader.save(this.mainConfig);
+      this.motdSettings = new MOTDSettings(this.mainConfigLoader.load());
+      this.mainConfigLoader.save(motdSettings.getMotdConfig());
 
       this.pluginSettings = this.pluginSettingsLoader.load();
       this.pluginSettingsLoader.save(this.pluginSettings);
@@ -99,9 +95,9 @@ public void loadExtraConfigs() {
             path,
             options -> options.header(String.format("Extra MiniMOTD config '%s'", name))
           );
-          final MOTDConfig config = loader.load();
-          loader.save(config);
-          this.extraConfigs.put(name, config);
+          final MOTDSettings motdSettings = new MOTDSettings(loader.load());
+          loader.save(motdSettings.getMotdConfig());
+          this.extraConfigs.put(name, motdSettings);
         }
       }
     } catch (final IOException e) {
@@ -123,11 +119,11 @@ private void createDefaultExtraConfigs(final @NonNull Path extraConfigsDir) thro
     }
   }
 
-  public @NonNull MOTDConfig mainConfig() {
-    if (this.mainConfig == null) {
+  public @NonNull MOTDSettings motdSettings() {
+    if (this.motdSettings == null) {
       throw new IllegalStateException("Config has not yet been loaded");
     }
-    return this.mainConfig;
+    return this.motdSettings;
   }
 
   public @NonNull PluginSettings pluginSettings() {
@@ -137,9 +133,9 @@ private void createDefaultExtraConfigs(final @NonNull Path extraConfigsDir) thro
     return this.pluginSettings;
   }
 
-  public @NonNull MOTDConfig resolveConfig(final @Nullable InetSocketAddress address) {
+  public @NonNull MOTDSettings resolveConfig(final @Nullable InetSocketAddress address) {
     if (address == null) {
-      return this.mainConfig();
+      return this.motdSettings();
     }
     final String configString = this.pluginSettings().proxySettings().findConfigStringForHost(address.getHostString(), address.getPort());
 
@@ -148,21 +144,21 @@ private void createDefaultExtraConfigs(final @NonNull Path extraConfigsDir) thro
     }
 
     if (configString == null) {
-      return this.mainConfig();
+      return this.motdSettings();
     }
     return this.resolveConfig(configString);
   }
 
-  public @NonNull MOTDConfig resolveConfig(final @NonNull String name) {
+  public @NonNull MOTDSettings resolveConfig(final @NonNull String name) {
     if ("default".equals(name)) {
-      return this.mainConfig();
+      return this.motdSettings();
     }
-    final MOTDConfig cfg = this.extraConfigs.get(name);
+    final MOTDSettings cfg = this.extraConfigs.get(name);
     if (cfg != null) {
       return cfg;
     }
     this.miniMOTD.logger().warn("Invalid extra-config name: '{}', falling back to main.conf", name);
-    return this.mainConfig();
+    return this.motdSettings();
   }
 
 }

common/src/main/java/xyz/jpenilla/minimotd/common/config/MOTDConfig.java

@@ -29,6 +29,7 @@
 import org.jspecify.annotations.NonNull;
 import org.spongepowered.configurate.objectmapping.ConfigSerializable;
 import org.spongepowered.configurate.objectmapping.meta.Comment;
+import org.spongepowered.configurate.objectmapping.meta.Matches;
 import xyz.jpenilla.minimotd.common.PingResponse;
 
 import static xyz.jpenilla.minimotd.common.PingResponse.PlayerCount.playerCount;
@@ -62,7 +63,51 @@ public MOTDConfig(final @NonNull MOTD @NonNull ... defaults) {
   private PlayerCountSettings playerCountSettings = new PlayerCountSettings();
 
   @ConfigSerializable
-  public static final class MOTD {
+  public static final class MOTDScheduleSettings {
+    @Comment("Weight defines probability to be chosen on conflict.\n" +
+      " Higher value - Higher probability")
+    @Matches("[1-9][0-9]{0-5}")
+    private int weight = 1;
+
+    @Comment("MOTDs with lower priority will be ignored on conflict.\n" +
+      " Lower value - Higher priority.\n" +
+      " If few MOTDs have same priority then they will randomly compete based on `weight`")
+    @Matches("[1-9][0-9]{0-5}")
+    private int priority = 1;
+
+    @Comment("Time ranges when MOTD should be shown\n" +
+      " If none set - then could be shown at any time")
+    private List<TimeRangeConfig> timeSchedule = List.of();
+
+    public int getWeight() {
+      return weight;
+    }
+
+    public int getPriority() {
+      return priority;
+    }
+
+    public List<TimeRangeConfig> getTimeSchedule() {
+      return timeSchedule;
+    }
+  }
+
+  @ConfigSerializable
+  public static final class TimeRangeConfig {
+    private String from;
+    private String to;
+
+    public String getFrom() {
+      return from;
+    }
+
+    public String getTo() {
+      return to;
+    }
+  }
+
+  @ConfigSerializable
+  static final class MOTD {
 
     public MOTD() {
     }
@@ -82,6 +127,8 @@ public MOTD(final @NonNull String line1, final @NonNull String line2) {
       + "    ex: icon=\"myIconFile\"")
     private String icon = "random";
 
+    private MOTDScheduleSettings scheduleSettings = new MOTDScheduleSettings();
+
     public @NonNull String line1() {
       return this.line1;
     }
@@ -94,6 +141,9 @@ public MOTD(final @NonNull String line1, final @NonNull String line2) {
       return this.icon;
     }
 
+    public @NonNull MOTDScheduleSettings getScheduleSettings() {
+      return scheduleSettings;
+    }
   }
 
   @ConfigSerializable
@@ -170,7 +220,7 @@ public boolean iconEnabled() {
     return this.iconEnabled;
   }
 
-  public @NonNull List<MOTD> motds() {
+  @NonNull List<MOTD> motds() {
     return this.motds;
   }
 

common/src/main/java/xyz/jpenilla/minimotd/common/config/MOTDRepository.java

@@ -0,0 +1,81 @@
+package xyz.jpenilla.minimotd.common.config;
+
+import java.util.List;
+import org.jspecify.annotations.NonNull;
+import xyz.jpenilla.minimotd.common.model.MOTD;
+import xyz.jpenilla.minimotd.common.model.timerange.TimeRange;
+import xyz.jpenilla.minimotd.common.model.timerange.TimeRangeFactory;
+
+public final class MOTDRepository {
+  private final List<? extends MOTD> motds;
+
+  public MOTDRepository(final @NonNull List<? extends MOTD> motds) {
+    this.motds = motds;
+  }
+
+  @NonNull
+  public List<? extends MOTD> motds() {
+    return motds;
+  }
+
+
+  @NonNull
+  static MOTDRepository fromConfig(final MOTDConfig config) {
+    if (config.motds().isEmpty()) {
+      return new MOTDRepository(List.of());
+    }
+
+    final List<? extends MOTD> motds = config.motds().stream()
+      .map(MOTDAdapter::new)
+      .toList();
+
+    if (!motds.isEmpty() && motds.stream().noneMatch(motd -> motd.timeRanges().isEmpty())) {
+      // we have to request have at least one default MOTD until there is no algorithm which ensure that existing time ranges cover any time
+      throw new IllegalStateException("Required at least one MOTD without time range to have a fallback");
+    }
+
+    return new MOTDRepository(motds);
+  }
+
+  private static final class MOTDAdapter implements MOTD {
+    private final MOTDConfig.MOTD delegate;
+    private final List<TimeRange> timeRanges;
+
+    public MOTDAdapter(MOTDConfig.MOTD delegate) {
+      this.delegate = delegate;
+      this.timeRanges = delegate.getScheduleSettings().getTimeSchedule().stream()
+        .map(timeRangeConfig -> TimeRangeFactory.createTimeRange(timeRangeConfig.getFrom(), timeRangeConfig.getTo()))
+        .toList();
+    }
+
+    @Override
+    public @NonNull String line1() {
+      return delegate.line1();
+    }
+
+    @Override
+    public @NonNull String line2() {
+      return delegate.line2();
+    }
+
+    @Override
+    public @NonNull String icon() {
+      return delegate.icon();
+    }
+
+    @Override
+    public @NonNull List<TimeRange> timeRanges() {
+      return timeRanges;
+    }
+
+    @Override
+    public int weight() {
+      return delegate.getScheduleSettings().getWeight();
+    }
+
+    @Override
+    public int priority() {
+      return delegate.getScheduleSettings().getPriority();
+    }
+  }
+}

common/src/main/java/xyz/jpenilla/minimotd/common/config/MOTDSettings.java

@@ -0,0 +1,21 @@
+package xyz.jpenilla.minimotd.common.config;
+
+import org.jspecify.annotations.NonNull;
+
+public final class MOTDSettings {
+  private final MOTDConfig motdConfig;
+  private final MOTDRepository motdRepository;
+
+  public MOTDSettings(final @NonNull MOTDConfig motdConfig) {
+    this.motdConfig = motdConfig;
+    this.motdRepository = MOTDRepository.fromConfig(motdConfig);
+  }
+
+  public @NonNull MOTDConfig getMotdConfig() {
+    return motdConfig;
+  }
+
+  public @NonNull MOTDRepository getMotdRepository() {
+    return motdRepository;
+  }
+}

common/src/main/java/xyz/jpenilla/minimotd/common/model/MOTD.java

@@ -0,0 +1,23 @@
+package xyz.jpenilla.minimotd.common.model;
+
+import org.jspecify.annotations.NonNull;
+import xyz.jpenilla.minimotd.common.model.timerange.TimeRange;
+import java.util.List;
+
+public interface MOTD {
+  @NonNull
+  String line1();
+
+  @NonNull
+  String line2();
+
+  @NonNull
+  String icon();
+
+  @NonNull
+  List<TimeRange> timeRanges();
+
+  int weight();
+
+  int priority();
+}