How to make a Rust unlimited vehicle fuel plugin (permission based)

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

namespace Oxide.Plugins
{
    [Info("FuelFreeVehicles", "RustPluginGenerator", "1.0.0")]
    [Description("Permitted players do not consume fuel in configured vehicles.")]
    public class FuelFreeVehicles : RustPlugin
    {
        private const string PermUse = "fuelfreevehicles.use";
        private const string PermAdmin = "fuelfreevehicles.admin";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Enabled")]
            public bool Enabled = true;

            [JsonProperty("RefundFuel")]
            public bool RefundFuel = true;

            [JsonProperty("AffectedPrefabs")]
            public List<string> AffectedPrefabs = new List<string>
            {
                "minicopter.entity",
                "scraptransporthelicopter.entity",
                "modularcar",
                "rowboat",
                "rhib"
            };
        }

        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>
            {
                ["StatusOn"] = "Unlimited vehicle fuel is ENABLED. You have the driver permission: {0}.",
                ["StatusOff"] = "Unlimited vehicle fuel is DISABLED.",
                ["Toggled"] = "Unlimited vehicle fuel is now {0}.",
                ["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(PermUse, this);
            permission.RegisterPermission(PermAdmin, this);
        }

        private bool IsVehiclePrefab(string shortPrefabName)
        {
            if (string.IsNullOrEmpty(shortPrefabName) || config.AffectedPrefabs == null) return false;
            foreach (var prefab in config.AffectedPrefabs)
            {
                if (string.Equals(prefab, shortPrefabName, StringComparison.OrdinalIgnoreCase)) return true;
            }
            return false;
        }

        private object OnFuelConsume(BaseOven oven, Item fuel, ItemModBurnable burnable)
        {
            if (!config.Enabled || !config.RefundFuel) return null;
            if (oven == null || burnable == null || oven.inventory == null) return null;
            if (oven.IsDestroyed || !IsVehiclePrefab(oven.ShortPrefabName)) return null;

            var driver = FindDriver(oven);
            if (driver == null || driver.IsNpc) return null;
            if (!permission.UserHasPermission(driver.UserIDString, PermUse)) return null;

            var fuelDef = fuel?.info;
            if (fuelDef == null) return null;

            int amount = Mathf.RoundToInt(burnable.fuelAmount);
            if (amount <= 0) return null;

            foreach (var item in oven.inventory.itemList)
            {
                if (item == null || item.info == null) continue;
                if (item.info.itemid != fuelDef.itemid || item.amount >= item.MaxStackable()) continue;
                int room = item.MaxStackable() - item.amount;
                if (room <= 0) continue;
                item.amount += Mathf.Min(room, amount);
                item.MarkDirty();
                return null;
            }

            var created = ItemManager.CreateByItemID(fuelDef.itemid, amount);
            if (created != null && !oven.inventory.IsFull())
            {
                if (!created.MoveToContainer(oven.inventory)) created.Remove();
                oven.inventory.MarkDirty();
            }

            return null;
        }

        private BasePlayer FindDriver(BaseEntity entity)
        {
            var current = entity;
            for (int i = 0; i < 4 && current != null; i++)
            {
                if (current is BasePlayer player) return player;
                if (current is BaseVehicle vehicle)
                {
                    var mounted = vehicle.GetDriver();
                    if (mounted != null) return mounted;
                }
                current = current.GetParentEntity();
            }
            return null;
        }

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

            if (!config.Enabled)
            {
                player.ChatMessage(Msg("StatusOff", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("StatusOn", player.UserIDString, "yes"));
        }

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

            config.Enabled = !config.Enabled;
            SaveConfig();

            var state = config.Enabled ? "enabled" : "disabled";
            var message = Msg("Toggled", null, state);
            if (player != null) player.ChatMessage(message);
            else arg.ReplyWith(message);
            Server.Broadcast(message);
        }

        private void Unload()
        {
            SaveConfig();
        }
    }
}