How to make a Rust timed airdrop plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Timed Airdrop", "RustPluginGenerator", "1.0.0")]
    [Description("Spawns a vanilla cargo plane supply drop on a timer when enough players are online.")]
    public class TimedAirdrop : RustPlugin
    {
        private const string PermUse = "timedairdrop.use";

        private class PluginConfig
        {
            [JsonProperty("Interval Minutes")]
            public int IntervalMinutes { get; set; } = 45;

            [JsonProperty("Minimum Players")]
            public int MinimumPlayers { get; set; } = 5;

            [JsonProperty("Spawn Height")]
            public float SpawnHeight { get; set; } = 250f;
        }

        private PluginConfig config;
        private Timer dropTimer;
        private int lastWarnedPlayerCount = -1;

        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>
            {
                ["Incoming"] = "A cargo plane is dropping a supply crate — watch the sky!",
                ["NoPermission"] = "You don't have permission to call an airdrop.",
                ["Called"] = "A supply drop has been called.",
                ["Skipped"] = "Not enough players online ({0}/{1}) — airdrop skipped."
            }, 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()
        {
            StartTimer();

            // Warm-up tick so a live server doesn't wait a whole cycle after reload.
            timer.Once(10f, CheckScheduledDrop);
        }

        private void Unload()
        {
            dropTimer?.Destroy();
            dropTimer = null;
        }

        private void StartTimer()
        {
            dropTimer?.Destroy();
            var seconds = Mathf.Max(1, config.IntervalMinutes) * 60f;
            dropTimer = timer.Every(seconds, CheckScheduledDrop);
        }

        private void CheckScheduledDrop()
        {
            var online = CountOnlinePlayers();
            if (online < config.MinimumPlayers)
            {
                if (online != lastWarnedPlayerCount)
                {
                    lastWarnedPlayerCount = online;
                    Puts($"Skipping airdrop — {online}/{config.MinimumPlayers} players online.");
                }
                return;
            }

            lastWarnedPlayerCount = -1;
            SpawnAirdrop();
        }

        private int CountOnlinePlayers()
        {
            int count = 0;
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || player.IsNpc || !player.IsConnected || player.IsDead()) continue;
                count++;
            }
            return count;
        }

        private void SpawnAirdrop()
        {
            var position = new Vector3(
                TerrainMeta.Size.x * 0.5f,
                config.SpawnHeight,
                TerrainMeta.Size.z * 0.5f);

            var plane = GameManager.server.CreateEntity(
                "assets/prefabs/npc/cargo plane/cargo_plane.prefab",
                position,
                Quaternion.Euler(0f, UnityEngine.Random.Range(0f, 360f), 0f));

            if (plane == null)
            {
                PrintWarning("Failed to create the cargo plane prefab. Check the prefab path after a game update.");
                return;
            }

            plane.Spawn();
            Interface.Oxide.CallHook("OnAirdropCalled", plane);
            Server.Broadcast(Msg("Incoming"));
            Puts("Airdrop spawned.");
        }

        [ChatCommand("airdrop")]
        private void CmdAirdrop(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            SpawnAirdrop();
            player.ChatMessage(Msg("Called", player.UserIDString));
        }

        [ConsoleCommand("timedairdrop.status")]
        private void CcmdStatus(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var online = CountOnlinePlayers();
            arg.ReplyWith($"Interval: {config.IntervalMinutes} min, Minimum: {config.MinimumPlayers}, Online: {online}");
        }
    }
}