How to make a Rust vehicle owner lock plugin (team sharing)

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

namespace Oxide.Plugins
{
    [Info("VehicleOwnerLock", "RustPluginGenerator", "1.0.0")]
    [Description("Locks deployed or claimed vehicles to their owner and team.")]
    public class VehicleOwnerLock : RustPlugin
    {
        private const string PermClaim = "vehicleownerlock.claim";
        private const string DataFile = "VehicleOwnerLock";

        private class PluginConfig
        {
            [JsonProperty("Claim range in meters")]
            public float ClaimRange = 4f;

            [JsonProperty("Allow team members to mount")]
            public bool AllowTeam = true;

            [JsonProperty("Auto-claim on deploy")]
            public bool AutoClaimOnDeploy = true;
        }

        private class VehicleData
        {
            public string OwnerId;
            public string OwnerName;
        }

        private PluginConfig config;
        private Dictionary<ulong, VehicleData> data = new Dictionary<ulong, VehicleData>();

        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>
            {
                ["Locked"] = "This vehicle is locked to {0} and their team.",
                ["Claimed"] = "You claimed this vehicle. Only you and your team can mount it.",
                ["AlreadyOwned"] = "You already own this vehicle.",
                ["NotClaimable"] = "This vehicle belongs to {0}, it cannot be claimed.",
                ["NothingFound"] = "Look directly at a vehicle within {0} meters and try again.",
                ["Released"] = "You released this vehicle. Anyone can claim it now.",
                ["InfoOwned"] = "Owner: {0}. You {1} mount it.",
                ["InfoUnowned"] = "This vehicle is unowned.",
                ["AutoClaimed"] = "This vehicle is now locked to you and your team.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Allowed"] = "may",
                ["Denied"] = "may not"
            }, this);
        }

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

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, VehicleData>>(DataFile)
                   ?? new Dictionary<ulong, VehicleData>();
            SaveData();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, data);
        }

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

        private object CanMountEntity(BasePlayer player, BaseMountable mountable)
        {
            if (player == null || mountable == null) return null;
            if (player.IsAdmin) return null;

            VehicleData record;
            if (!data.TryGetValue(mountable.net.ID.Value, out record)) return null;

            if (record.OwnerId == player.UserIDString) return null;

            if (config.AllowTeam && player.currentTeam != 0)
            {
                var team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
                if (team != null && team.members.Contains(Convert.ToUInt64(record.OwnerId)))
                    return null;
            }

            player.ChatMessage(Msg("Locked", player.UserIDString, record.OwnerName));
            return "Vehicle locked";
        }

        private void OnItemDeployed(Deployer deployer, BaseEntity entity)
        {
            if (!config.AutoClaimOnDeploy || deployer == null || entity == null) return;

            var player = deployer.GetOwnerPlayer();
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermClaim)) return;

            var mountable = entity as BaseMountable;
            if (mountable == null) return;

            ulong id = mountable.net.ID.Value;
            if (data.ContainsKey(id)) return;

            data[id] = new VehicleData { OwnerId = player.UserIDString, OwnerName = player.displayName };
            SaveData();
            player.ChatMessage(Msg("AutoClaimed", player.UserIDString));
        }

        private void OnEntityKill(BaseNetworkable entity)
        {
            if (entity == null) return;
            if (data.Remove(entity.net.ID.Value)) SaveData();
        }

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

            var mountable = FindLookedAt(player);
            if (mountable == null)
            {
                SendReply(player, Msg("NothingFound", player.UserIDString, config.ClaimRange));
                return;
            }

            ulong id = mountable.net.ID.Value;
            VehicleData record;
            if (data.TryGetValue(id, out record))
            {
                if (record.OwnerId == player.UserIDString)
                    SendReply(player, Msg("AlreadyOwned", player.UserIDString));
                else
                    SendReply(player, Msg("NotClaimable", player.UserIDString, record.OwnerName));
                return;
            }

            data[id] = new VehicleData { OwnerId = player.UserIDString, OwnerName = player.displayName };
            SaveData();
            SendReply(player, Msg("Claimed", player.UserIDString));
        }

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

            var mountable = FindLookedAt(player);
            if (mountable == null)
            {
                SendReply(player, Msg("NothingFound", player.UserIDString, config.ClaimRange));
                return;
            }

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

            if (sub == "release")
            {
                if (!permission.UserHasPermission(player.UserIDString, PermClaim))
                {
                    SendReply(player, Msg("NoPermission", player.UserIDString));
                    return;
                }

                VehicleData record;
                if (!data.TryGetValue(mountable.net.ID.Value, out record) || record.OwnerId != player.UserIDString)
                {
                    SendReply(player, Msg("NotClaimable", player.UserIDString, record?.OwnerName ?? "someone else"));
                    return;
                }

                data.Remove(mountable.net.ID.Value);
                SaveData();
                SendReply(player, Msg("Released", player.UserIDString));
                return;
            }

            VehicleData owned;
            if (!data.TryGetValue(mountable.net.ID.Value, out owned))
            {
                SendReply(player, Msg("InfoUnowned", player.UserIDString));
                return;
            }

            bool allowed = owned.OwnerId == player.UserIDString || (config.AllowTeam && IsTeamMember(player, owned));
            SendReply(player, Msg("InfoOwned", player.UserIDString, owned.OwnerName, Msg(allowed ? "Allowed" : "Denied", player.UserIDString)));
        }

        private bool IsTeamMember(BasePlayer player, VehicleData record)
        {
            if (player.currentTeam == 0) return false;
            var team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
            return team != null && team.members.Contains(Convert.ToUInt64(record.OwnerId));
        }

        private BaseMountable FindLookedAt(BasePlayer player)
        {
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.position, player.eyes.HeadForward(), out hit, config.ClaimRange, 1237003025))
                return null;

            var entity = hit.GetEntity();
            while (entity != null)
            {
                var mountable = entity as BaseMountable;
                if (mountable != null) return mountable;
                entity = entity.GetParentEntity();
            }
            return null;
        }
    }
}