How to make a Rust wipe countdown plugin (UTC schedule)

using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Oxide.Core;

namespace Oxide.Plugins
{
    [Info("Wipe Countdown", "RustPluginGenerator", "1.0.0")]
    [Description("Shows the time left until the next wipe using a fixed or monthly UTC schedule.")]
    public class WipeCountdown : RustPlugin
    {
        private const string PermUse = "wipecountdown.use";

        private PluginConfig config;
        private DateTime nextWipe = DateTime.MaxValue;
        private Timer announceTimer;

        private class PluginConfig
        {
            [JsonProperty("Mode (Fixed or Monthly)")]
            public string Mode = "Monthly";

            [JsonProperty("Fixed wipe UTC (yyyy-MM-dd HH:mm)")]
            public string FixedWipeUtc = "2025-01-02 19:00";

            [JsonProperty("Monthly day of week")]
            public string MonthlyDay = "Thursday";

            [JsonProperty("Monthly hour UTC (0-23)")]
            public int MonthlyHourUtc = 19;

            [JsonProperty("Announce interval minutes (0 disables)")]
            public int AnnounceIntervalMinutes = 0;

            [JsonProperty("Remind within hours")]
            public int RemindWithinHours = 6;
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["TimeLeft"] = "Wipe in {0} days {1} hours {2} minutes.",
                ["TimeLeftNoDays"] = "Wipe in {0} hours {1} minutes.",
                ["WipeUnavailable"] = "No wipe date is currently scheduled.",
                ["WipeReminder"] = "Reminder: {0}",
                ["ScheduleFixed"] = "Wipe schedule: {0} UTC.",
                ["ScheduleMonthly"] = "Wipe schedule: first {0} of each month at {1}:00 UTC.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) =>
            string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            nextWipe = GetNextWipe();
        }

        private void Loaded()
        {
            nextWipe = GetNextWipe();
            if (config.AnnounceIntervalMinutes <= 0) return;

            announceTimer = timer.Every(config.AnnounceIntervalMinutes * 60f, () =>
            {
                var remaining = nextWipe - DateTime.UtcNow;
                if (remaining <= TimeSpan.Zero) return;
                if (remaining.TotalHours > config.RemindWithinHours) return;
                Server.Broadcast(Msg("WipeReminder", null, FormatRemaining(remaining)));
            });
        }

        private void Unload()
        {
            if (announceTimer != null)
            {
                announceTimer.Destroy();
                announceTimer = null;
            }
        }

        private DateTime GetNextWipe()
        {
            if (string.Equals(config.Mode, "Fixed", StringComparison.OrdinalIgnoreCase))
            {
                DateTime fixedDate;
                if (!DateTime.TryParseExact(config.FixedWipeUtc, "yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture,
                        DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out fixedDate))
                    return DateTime.MaxValue;
                return fixedDate > DateTime.UtcNow ? fixedDate : DateTime.MaxValue;
            }

            DayOfWeek targetDay;
            if (!Enum.TryParse(config.MonthlyDay, true, out targetDay))
                targetDay = DayOfWeek.Thursday;

            var now = DateTime.UtcNow;
            var candidate = FirstOfMonth(now.Year, now.Month, targetDay);
            if (candidate <= now)
            {
                var nextMonth = now.AddMonths(1);
                candidate = FirstOfMonth(nextMonth.Year, nextMonth.Month, targetDay);
            }
            return candidate;
        }

        private DateTime FirstOfMonth(int year, int month, DayOfWeek day)
        {
            var first = new DateTime(year, month, 1, config.MonthlyHourUtc, 0, 0, DateTimeKind.Utc);
            int offset = ((int)day - (int)first.DayOfWeek + 7) % 7;
            return first.AddDays(offset);
        }

        private string FormatRemaining(TimeSpan span)
        {
            if (span <= TimeSpan.Zero) return Msg("WipeUnavailable");
            int days = span.Days;
            int hours = span.Hours;
            int minutes = span.Minutes;
            return days > 0 ? Msg("TimeLeft", null, days, hours, minutes) : Msg("TimeLeftNoDays", null, hours, minutes);
        }

        [ChatCommand("wipe")]
        private void CmdWipe(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (nextWipe == DateTime.MaxValue)
            {
                SendReply(player, Msg("WipeUnavailable", player.UserIDString));
                return;
            }

            SendReply(player, FormatRemaining(nextWipe - DateTime.UtcNow));
        }

        [ChatCommand("wipeschedule")]
        private void CmdSchedule(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (string.Equals(config.Mode, "Fixed", StringComparison.OrdinalIgnoreCase))
            {
                SendReply(player, Msg("ScheduleFixed", player.UserIDString, config.FixedWipeUtc));
            }
            else
            {
                SendReply(player, Msg("ScheduleMonthly", player.UserIDString, config.MonthlyDay, config.MonthlyHourUtc));
            }
        }
    }
}