OnServerRestart

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

namespace Oxide.Plugins
{
    [Info("Scheduled Restart Announcer", "RustPluginGenerator", "1.0.0")]
    [Description("Broadcasts and records the server restart countdown when a restart is scheduled.")]
    public class ScheduledRestartAnnouncer : RustPlugin
    {
        private const string PermAnnounce = "scheduledrestartannouncer.announce";

        private class PluginConfig
        {
            [JsonProperty("Announce restarts in chat")]
            public bool AnnounceInChat { get; set; } = true;

            [JsonProperty("Record restart schedule to data file")]
            public bool RecordSchedule { get; set; } = true;
        }

        private class RestartRecord
        {
            [JsonProperty("Notice")]
            public string Notice { get; set; }

            [JsonProperty("Seconds")]
            public int Seconds { get; set; }

            [JsonProperty("ScheduledUtc")]
            public string ScheduledUtc { get; set; }
        }

        private PluginConfig config;

        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>
            {
                ["RestartNotice"] = "Server restarting in {0}. {1}",
                ["RestartImmediate"] = "Server restart scheduled with no countdown.",
                ["NoNotice"] = "Please finish your business and log out safely."
            }, 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(PermAnnounce, this);
        }

        private object OnServerRestart(string notice, int seconds)
        {
            string text = string.IsNullOrEmpty(notice) ? Msg("NoNotice") : notice;

            if (seconds > 0)
            {
                if (config.AnnounceInChat)
                {
                    Server.Broadcast(Msg("RestartNotice", null, FormatSeconds(seconds), text));
                }
            }
            else
            {
                Puts("Immediate server restart requested (" + text + ")");
            }

            if (config.RecordSchedule)
            {
                var record = new RestartRecord
                {
                    Notice = notice,
                    Seconds = seconds,
                    ScheduledUtc = DateTime.UtcNow.ToString("o")
                };
                Interface.Oxide.DataFileSystem.WriteObject(Name, record);
            }

            return null;
        }

        private static string FormatSeconds(int seconds)
        {
            if (seconds >= 60)
            {
                int minutes = seconds / 60;
                int rest = seconds % 60;
                return rest == 0 ? minutes + " min" : minutes + " min " + rest + " sec";
            }
            return seconds + " sec";
        }

        [ChatCommand("restartinfo")]
        private void CmdRestartInfo(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            var record = Interface.Oxide.DataFileSystem.ReadObject<RestartRecord>(Name);
            if (record == null || string.IsNullOrEmpty(record.ScheduledUtc))
            {
                SendReply(player, "No restart has been scheduled on this server.");
                return;
            }
            SendReply(player, "Last scheduled restart: " + record.ScheduledUtc + " UTC, " + record.Seconds + " sec notice.");
        }

        private void Unload()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                // No CUI is used, but clear any future layers defensively.
            }
        }
    }
}