How to make a Rust double gather event plugin (scheduled multiplier)

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

namespace Oxide.Plugins
{
    [Info("Double Gather Event", "RustPluginGenerator", "1.0.0")]
    [Description("Runs scheduled or admin-triggered gather multiplier windows with announcements.")]
    public class DoubleGatherEvent : RustPlugin
    {
        private const string PermAdmin = "doublegatherevent.admin";

        private PluginConfig config;
        private DateTime eventEndsAt = DateTime.MinValue;
        private Timer endTimer;
        private Timer warnTimer;
        private Timer scheduledTimer;

        private class PluginConfig
        {
            [JsonProperty("Use schedule")]
            public bool UseSchedule { get; set; } = true;

            [JsonProperty("Schedule times (HH:mm, server local time)")]
            public List<string> ScheduleTimes { get; set; } = new List<string> { "19:00", "22:00" };

            [JsonProperty("Gather multiplier")]
            public float GatherMultiplier { get; set; } = 2.0f;

            [JsonProperty("Duration minutes")]
            public int DurationMinutes { get; set; } = 30;

            [JsonProperty("Warn seconds before end")]
            public int WarnSeconds { get; set; } = 120;
        }

        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>
            {
                ["Started"] = "<color=#ffd479>Gather event started!</color> All gathering is multiplied by {0} for {1} minutes.",
                ["Ended"] = "<color=#ffd479>Gather event ended.</color> Normal gather rates restored.",
                ["EndingSoon"] = "<color=#ffd479>Gather event ends in {0} seconds.</color>",
                ["AlreadyRunning"] = "The gather event is already running.",
                ["NotRunning"] = "No gather event is running.",
                ["StartedByAdmin"] = "{0} started a gather event: x{1} for {2} minutes.",
                ["CommandStart"] = "Gather event started for {0} minutes.",
                ["CommandStop"] = "Gather event stopped.",
                ["CommandStatus"] = "Gather event running with {0} seconds left.",
                ["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(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            if (config.UseSchedule) ScheduleNextRun();
        }

        private void Unload()
        {
            DestroyTimer(ref endTimer);
            DestroyTimer(ref warnTimer);
            DestroyTimer(ref scheduledTimer);
        }

        private static void DestroyTimer(ref Timer timer)
        {
            if (timer != null)
            {
                timer.Destroy();
                timer = null;
            }
        }

        private bool IsEventActive() => DateTime.UtcNow < eventEndsAt;

        private object OnDispenserGather(ResourceDispenser resourceDispenser, BasePlayer entity, Item item)
        {
            if (!IsEventActive() || item == null) return null;
            var original = item.amount;
            var scaled = Mathf.Max(original, Mathf.RoundToInt(original * config.GatherMultiplier));
            if (scaled != original)
            {
                item.amount = scaled;
                item.MarkDirty();
            }
            return null;
        }

        private object OnCollectiblePickup(CollectibleEntity collectibleEntity, BasePlayer reciever, bool eat)
        {
            if (!IsEventActive() || collectibleEntity?.itemList == null) return null;
            foreach (var entry in collectibleEntity.itemList)
            {
                if (entry == null || entry.itemDef == null) continue;
                var original = (int)entry.amount;
                var scaled = Mathf.Max(original, Mathf.RoundToInt(original * config.GatherMultiplier));
                entry.amount = scaled;
            }
            return null;
        }

        private void ScheduleNextRun()
        {
            DestroyTimer(ref scheduledTimer);
            DateTime now = DateTime.Now;
            DateTime? next = null;

            foreach (var raw in config.ScheduleTimes)
            {
                if (string.IsNullOrEmpty(raw)) continue;
                if (!TimeSpan.TryParse(raw.Trim(), out var span)) continue;

                var candidate = now.Date + span;
                if (candidate <= now) candidate = candidate.AddDays(1);

                if (next == null || candidate < next.Value) next = candidate;
            }

            if (next == null) return;

            double seconds = Math.Max(1.0, (next.Value - now).TotalSeconds);
            scheduledTimer = timer.Once((float)seconds, () =>
            {
                scheduledTimer = null;
                StartEvent(config.DurationMinutes);
            });
        }

        private bool StartEvent(int minutes)
        {
            if (IsEventActive()) return false;
            if (minutes <= 0) minutes = config.DurationMinutes;

            eventEndsAt = DateTime.UtcNow.AddMinutes(minutes);

            Server.Broadcast(Msg("Started", null, config.GatherMultiplier, minutes));

            DestroyTimer(ref endTimer);
            endTimer = timer.Once(minutes * 60f, () =>
            {
                endTimer = null;
                EndEvent();
            });

            DestroyTimer(ref warnTimer);
            if (config.WarnSeconds > 0 && config.WarnSeconds < minutes * 60)
            {
                warnTimer = timer.Once(minutes * 60f - config.WarnSeconds, () =>
                {
                    warnTimer = null;
                    Server.Broadcast(Msg("EndingSoon", null, config.WarnSeconds));
                });
            }

            return true;
        }

        private bool EndEvent()
        {
            if (eventEndsAt == DateTime.MinValue) return false;

            eventEndsAt = DateTime.MinValue;
            DestroyTimer(ref endTimer);
            DestroyTimer(ref warnTimer);

            Server.Broadcast(Msg("Ended"));

            if (config.UseSchedule) ScheduleNextRun();
            return true;
        }

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

            string sub = args != null && args.Length > 0 ? args[0].ToLowerInvariant() : "status";

            switch (sub)
            {
                case "start":
                {
                    if (IsEventActive())
                    {
                        SendReply(player, Msg("AlreadyRunning", player.UserIDString));
                        return;
                    }
                    int minutes = config.DurationMinutes;
                    if (args.Length > 1 && int.TryParse(args[1], out var parsed) && parsed > 0) minutes = parsed;
                    StartEvent(minutes);
                    Server.Broadcast(Msg("StartedByAdmin", null, player.displayName, config.GatherMultiplier, minutes));
                    SendReply(player, Msg("CommandStart", player.UserIDString, minutes));
                    break;
                }
                case "stop":
                {
                    if (!IsEventActive())
                    {
                        SendReply(player, Msg("NotRunning", player.UserIDString));
                        return;
                    }
                    EndEvent();
                    SendReply(player, Msg("CommandStop", player.UserIDString));
                    break;
                }
                default:
                {
                    if (!IsEventActive())
                    {
                        SendReply(player, Msg("NotRunning", player.UserIDString));
                        return;
                    }
                    var left = (int)Math.Max(0, (eventEndsAt - DateTime.UtcNow).TotalSeconds);
                    SendReply(player, Msg("CommandStatus", player.UserIDString, left));
                    break;
                }
            }
        }

        [ConsoleCommand("dge.start")]
        private void CcmdStart(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (!arg.IsAdmin && player == null)
            {
                arg.ReplyWith(Msg("NoPermission"));
                return;
            }

            if (IsEventActive())
            {
                arg.ReplyWith(Msg("AlreadyRunning"));
                return;
            }

            int minutes = config.DurationMinutes;
            int requested = arg.GetInt(0, 0);
            if (requested > 0) minutes = requested;

            StartEvent(minutes);
            arg.ReplyWith(Msg("CommandStart", null, minutes));
        }

        [ConsoleCommand("dge.stop")]
        private void CcmdStop(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (!arg.IsAdmin && player == null)
            {
                arg.ReplyWith(Msg("NoPermission"));
                return;
            }

            if (!EndEvent())
            {
                arg.ReplyWith(Msg("NotRunning"));
                return;
            }
            arg.ReplyWith(Msg("CommandStop"));
        }
    }
}