How to make a Rust scheduled restarts plugin (daily countdown warnings)

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

namespace Oxide.Plugins
{
    [Info("Scheduled Restarts", "RustPluginGenerator", "1.0.0")]
    [Description("Restarts the server at configured daily times with chat countdown warnings and a final save.")]
    public class ScheduledRestarts : RustPlugin
    {
        private const string PermUse = "scheduledrestarts.use";
        private const string PermAdmin = "scheduledrestarts.admin";

        private class PluginConfig
        {
            [JsonProperty("Daily times (HH:mm)")]
            public List<string> DailyTimes = new List<string> { "04:00", "16:00" };

            [JsonProperty("Warning minutes")]
            public List<int> WarningMinutes = new List<int> { 15, 10, 5, 1 };

            [JsonProperty("Restart command")]
            public string RestartCommand = "quit";

            [JsonProperty("Save before restart")]
            public bool SaveBeforeRestart = true;

            [JsonProperty("Warn on join")]
            public bool WarnOnJoin = true;
        }

        private PluginConfig config;
        private Timer pollTimer;
        private Timer countdownTimer;
        private int remainingMinutes;
        private bool countingDown;
        private readonly List<TimeSpan> schedule = new List<TimeSpan>();

        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>
            {
                ["Warning"] = "Server restarting in {0} minute(s).",
                ["Restarting"] = "Server is restarting now. See you shortly!",
                ["Next"] = "Next scheduled restart: {0}. Daily times: {1}.",
                ["None"] = "No restart times are configured.",
                ["Manual"] = "A restart was triggered by an admin."
            }, this);
        }

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

        private void OnServerInitialized()
        {
            schedule.Clear();
            foreach (var raw in config.DailyTimes)
            {
                TimeSpan parsed;
                if (TimeSpan.TryParseExact(raw, @"hh\:mm", CultureInfo.InvariantCulture, out parsed))
                {
                    schedule.Add(parsed);
                }
                else
                {
                    PrintWarning("Invalid restart time '" + raw + "', expected HH:mm");
                }
            }

            config.WarningMinutes.Sort();
            config.WarningMinutes.Reverse();
            pollTimer = timer.Every(30f, Poll);
        }

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

        private void Poll()
        {
            if (countingDown || schedule.Count == 0) return;
            var now = DateTime.Now;
            var current = new TimeSpan(now.Hour, now.Minute, 0);
            if (schedule.Contains(current)) BeginCountdown();
        }

        private void BeginCountdown()
        {
            if (countingDown) return;
            countingDown = true;
            remainingMinutes = config.WarningMinutes.Count > 0 ? config.WarningMinutes[0] : 0;

            if (countdownTimer != null) countdownTimer.Destroy();
            countdownTimer = timer.Repeat(60f, remainingMinutes + 1, TickCountdown);
        }

        private void TickCountdown()
        {
            if (remainingMinutes <= 0)
            {
                FinishRestart();
                return;
            }

            if (config.WarningMinutes.Contains(remainingMinutes))
            {
                Server.Broadcast(Msg("Warning", null, remainingMinutes));
            }
            remainingMinutes--;
        }

        private void FinishRestart()
        {
            if (countdownTimer != null)
            {
                countdownTimer.Destroy();
                countdownTimer = null;
            }
            countingDown = false;

            Server.Broadcast(Msg("Restarting"));
            if (config.SaveBeforeRestart) ConsoleSystem.Run(ConsoleSystem.Option.Server.Quiet(), "server.save");

            NextTick(() => Server.Command(config.RestartCommand));
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null || !config.WarnOnJoin || !countingDown) return;
            if (remainingMinutes <= 0) return;
            player.ChatMessage(Msg("Warning", player.UserIDString, remainingMinutes));
        }

        [ChatCommand("restart")]
        private void CmdRestart(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage("You do not have permission to use this command.");
                return;
            }

            if (schedule.Count == 0)
            {
                player.ChatMessage(Msg("None", player.UserIDString));
                return;
            }

            var times = string.Join(", ", config.DailyTimes.ToArray());
            player.ChatMessage(Msg("Next", player.UserIDString, NextRestart().ToString(@"hh\:mm"), times));
        }

        [ConsoleCommand("scheduledrestarts.now")]
        private void CcmdNow(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }
            if (player == null && !arg.IsAdmin && arg.Connection != null)
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            if (countingDown)
            {
                arg.ReplyWith("A countdown is already running.");
                return;
            }

            Server.Broadcast(Msg("Manual"));
            BeginCountdown();
            arg.ReplyWith("Restart countdown started.");
        }

        private TimeSpan NextRestart()
        {
            var now = DateTime.Now.TimeOfDay;
            var ordered = new List<TimeSpan>(schedule);
            ordered.Sort();
            foreach (var slot in ordered)
            {
                if (slot > now) return slot;
            }
            return ordered[0];
        }

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