How to make a Rust vehicle recall plugin (despawn command)

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Vehicle Despawn", "RustPluginGenerator", "1.0.0")]
    [Description("Lets players despawn a vehicle they own and are looking at, refunding a configurable item.")]
    public class VehicleDespawn : RustPlugin
    {
        private const string PermUse = "vehicledespawn.use";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();
        private readonly Dictionary<ulong, float> pendingConfirm = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Range (metres)")]
            public float Range { get; set; } = 5f;

            [JsonProperty("Refund item shortname")]
            public string RefundShortname { get; set; } = "scrap";

            [JsonProperty("Refund amount")]
            public int RefundAmount { get; set; } = 100;

            [JsonProperty("Cooldown (seconds)")]
            public float CooldownSeconds { get; set; } = 300f;

            [JsonProperty("Require confirmation")]
            public bool RequireConfirmation { get; set; } = true;

            [JsonProperty("Confirmation window (seconds)")]
            public float ConfirmSeconds { get; set; } = 15f;
        }

        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 don't have permission to use that command.",
                ["NoVehicle"] = "Look at one of your vehicles within {0} metres.",
                ["NotOwner"] = "You can only despawn a vehicle you own.",
                ["Occupied"] = "That vehicle has a player mounted. Unmount first.",
                ["Cooldown"] = "You can despawn another vehicle in {0} seconds.",
                ["Confirm"] = "Type /despawn again within {0} seconds to confirm removal of your {1}.",
                ["Refunded"] = "Vehicle removed. You received {0} x {1}.",
                ["RefundFailed"] = "Vehicle removed, but the refund item could not be created. Check the config."
            }, this);
        }

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

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

        private void OnServerInitialized()
        {
            if (ItemManager.FindItemDefinition(config.RefundShortname) == null)
            {
                PrintWarning($"Refund shortname '{config.RefundShortname}' is not a valid item; despawns will not refund.");
            }
        }

        [ChatCommand("despawn")]
        private void CmdDespawn(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (!player.IsAdmin && !permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            float now = UnityEngine.Time.realtimeSinceStartup;

            float nextAllowed;
            if (cooldowns.TryGetValue(player.userID.Get(), out nextAllowed) && now < nextAllowed)
            {
                player.ChatMessage(Msg("Cooldown", player.UserIDString, Mathf.CeilToInt(nextAllowed - now)));
                return;
            }

            var vehicle = FindVehicle(player);
            if (vehicle == null)
            {
                player.ChatMessage(Msg("NoVehicle", player.UserIDString, config.Range));
                return;
            }

            if (!player.IsAdmin && vehicle.OwnerID != player.userID.Get())
            {
                player.ChatMessage(Msg("NotOwner", player.UserIDString));
                return;
            }

            if (IsOccupied(vehicle))
            {
                player.ChatMessage(Msg("Occupied", player.UserIDString));
                return;
            }

            if (config.RequireConfirmation)
            {
                float window;
                if (!pendingConfirm.TryGetValue(player.userID.Get(), out window) || now > window)
                {
                    pendingConfirm[player.userID.Get()] = now + config.ConfirmSeconds;
                    player.ChatMessage(Msg("Confirm", player.UserIDString, Mathf.RoundToInt(config.ConfirmSeconds), ShortName(vehicle)));
                    return;
                }
            }

            pendingConfirm.Remove(player.userID.Get());
            cooldowns[player.userID.Get()] = now + config.CooldownSeconds;

            vehicle.Kill();
            GiveRefund(player);
        }

        private BaseVehicle FindVehicle(BasePlayer player)
        {
            RaycastHit[] hits = Physics.RaycastAll(player.eyes.position, player.eyes.HeadForward(), config.Range);
            if (hits == null || hits.Length == 0) return null;

            BaseVehicle best = null;
            float bestDistance = float.MaxValue;

            foreach (var hit in hits)
            {
                var entity = hit.GetEntity();
                var vehicle = entity as BaseVehicle;
                if (vehicle == null || vehicle.IsDestroyed) continue;

                if (hit.distance < bestDistance)
                {
                    bestDistance = hit.distance;
                    best = vehicle;
                }
            }

            return best;
        }

        private bool IsOccupied(BaseVehicle vehicle)
        {
            // Any mounted player sits inside the vehicle hierarchy (seats are children).
            foreach (var child in vehicle.children)
            {
                var mounted = child as BasePlayer;
                if (mounted != null && mounted.isMounted) return true;

                var mountable = child as BaseMountable;
                if (mountable != null && mountable.GetMounted() != null) return true;
            }

            return false;
        }

        private void GiveRefund(BasePlayer player)
        {
            var item = ItemManager.CreateByName(config.RefundShortname, config.RefundAmount, 0);
            if (item == null)
            {
                player.ChatMessage(Msg("RefundFailed", player.UserIDString));
                return;
            }

            if (player.inventory.GiveItem(item))
            {
                player.ChatMessage(Msg("Refunded", player.UserIDString, item.amount, item.info.displayName.english));
                return;
            }

            item.Drop(player.transform.position + Vector3.up, Vector3.zero);
            player.ChatMessage(Msg("Refunded", player.UserIDString, item.amount, item.info.displayName.english));
        }

        private static string ShortName(BaseVehicle vehicle)
        {
            if (vehicle is BaseHelicopter) return "minicopter";
            if (vehicle is ModularCar) return "car";
            if (vehicle is BaseBoat) return "boat";
            return vehicle.ShortPrefabName ?? "vehicle";
        }

        private void Unload()
        {
            cooldowns.Clear();
            pendingConfirm.Clear();
        }
    }
}