How to make a Rust wipe day kit plugin (Oxide)

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

namespace Oxide.Plugins
{
    [Info("Wipe Day Kit", "RustPluginGenerator", "1.0.0")]
    [Description("Gives players a one-time kit that can only be claimed during the first N hours after a wipe.")]
    public class WipeDayKit : RustPlugin
    {
        private const string PermUse = "wipedaykit.use";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Window hours after wipe")]
            public int WindowHours = 48;

            [JsonProperty("Items")]
            public List<KitItem> Items = new List<KitItem>
            {
                new KitItem { Shortname = "scrap", Amount = 500 },
                new KitItem { Shortname = "stone.pickaxe", Amount = 1 },
                new KitItem { Shortname = "stone.hatchet", Amount = 1 },
                new KitItem { Shortname = "bandage", Amount = 3 }
            };
        }

        private class KitItem
        {
            [JsonProperty("Shortname")]
            public string Shortname = "scrap";

            [JsonProperty("Amount")]
            public int Amount = 1;

            [JsonProperty("Skin")]
            public ulong Skin = 0;
        }

        private class StoredData
        {
            [JsonProperty("Start unix")]
            public long StartUnix = 0;

            [JsonProperty("Claimed user ids")]
            public List<ulong> Claimed = new List<ulong>();
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to claim the wipe day kit.",
                ["AlreadyClaimed"] = "You already claimed your wipe day kit.",
                ["WindowClosed"] = "The wipe day kit window has closed.",
                ["WindowOpen"] = "Wipe day kit available. Time left: {0}h {1}m.",
                ["Claimed"] = "Wipe day kit claimed. Have fun!",
                ["ClaimFailed"] = "Your kit could not be granted right now. Try again later.",
                ["NoItems"] = "No items were given. Check your inventory space or contact an admin."
            }, 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);
            LoadData();
        }

        private void OnServerInitialized()
        {
            if (data == null) LoadData();
            if (data.StartUnix <= 0)
            {
                data.StartUnix = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            }
        }

        private void Unload()
        {
            SaveData();
        }

        private void LoadData()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name);
            }
            catch
            {
                data = null;
            }
            if (data == null) data = new StoredData();
            if (data.Claimed == null) data.Claimed = new List<ulong>();
        }

        private void SaveData()
        {
            if (data != null) Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        private void OnNewSave(string strFilename)
        {
            LoadData();
            data.StartUnix = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            data.Claimed.Clear();
            SaveData();
        }

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

            if (data == null) LoadData();

            if (data.Claimed.Contains(player.userID.Get()))
            {
                SendReply(player, Msg("AlreadyClaimed", player.UserIDString));
                return;
            }

            double elapsed = (DateTimeOffset.UtcNow.ToUnixTimeSeconds() - data.StartUnix) / 3600.0;
            if (data.StartUnix <= 0 || elapsed < 0 || elapsed > config.WindowHours)
            {
                SendReply(player, Msg("WindowClosed", player.UserIDString));
                return;
            }

            double remaining = config.WindowHours - elapsed;
            int hours = (int)remaining;
            int minutes = Mathf.Max(0, (int)((remaining - hours) * 60));
            SendReply(player, Msg("WindowOpen", player.UserIDString, hours, minutes));

            if (GiveKit(player))
            {
                data.Claimed.Add(player.userID.Get());
                SaveData();
                SendReply(player, Msg("Claimed", player.UserIDString));
            }
            else
            {
                SendReply(player, Msg("ClaimFailed", player.UserIDString));
            }
        }

        private bool GiveKit(BasePlayer player)
        {
            int given = 0;
            foreach (var entry in config.Items)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                int amount = Mathf.Max(1, entry.Amount);
                Item item = ItemManager.CreateByName(entry.Shortname, amount, entry.Skin);
                if (item == null)
                {
                    PrintWarning($"Unknown shortname in config: {entry.Shortname}");
                    continue;
                }
                player.GiveItem(item);
                given++;
            }

            if (given == 0)
            {
                SendReply(player, Msg("NoItems", player.UserIDString));
                return false;
            }
            return true;
        }
    }
}