How to make a Rust /back to death plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Back To Death", "RustPluginGenerator", "1.0.0")]
    [Description("Allows players to teleport back to their last death position within a time window.")]
    public class BackToDeath : RustPlugin
    {
        private const string PermUse = "backtodeath.use";
        private const string DataFileName = "BackToDeath";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Require Permission")]
            public bool RequirePermission { get; set; } = true;

            [JsonProperty("Window Minutes")]
            public float WindowMinutes { get; set; } = 10f;

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

            [JsonProperty("Team Shared Cooldown")]
            public bool TeamSharedCooldown { get; set; } = false;

            [JsonProperty("Block In Building Privilege")]
            public bool BlockInBuildingPrivilege { get; set; } = true;

            [JsonProperty("Announce Teleport")]
            public bool AnnounceTeleport { get; set; } = false;

            [JsonProperty("Banned Item Shortnames")]
            public List<string> BannedItemShortnames { get; set; } = new List<string>();
        }

        private class DeathRecord
        {
            [JsonProperty("Position")]
            public Vector3 Position { get; set; }

            [JsonProperty("Time")]
            public double Time { get; set; }

            [JsonProperty("Map")]
            public string Map { get; set; }

            [JsonProperty("Team")]
            public ulong Team { get; set; }
        }

        private class StoredData
        {
            [JsonProperty("Deaths")]
            public Dictionary<ulong, DeathRecord> Deaths = new Dictionary<ulong, DeathRecord>();

            [JsonProperty("Last Use")]
            public Dictionary<ulong, double> LastUse = new Dictionary<ulong, double>();
        }

        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 use /back.",
                ["NoRecord"] = "You have no death to return to.",
                ["WindowClosed"] = "The time window to return has expired.",
                ["Cooldown"] = "You must wait {0} more second(s) before using /back.",
                ["TeamCooldown"] = "A team member is still on cooldown for /back.",
                ["Blocked"] = "You cannot teleport while inside another player's building privilege.",
                ["NotAlive"] = "You must be alive and awake to use /back.",
                ["MapChanged"] = "Your death was recorded on a different map.",
                ["Success"] = "You have been returned to your last death position.",
                ["Broadcast"] = "{0} returned to their death position."
            }, 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 Loaded()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(DataFileName) ?? new StoredData();
            if (data.Deaths == null) data.Deaths = new Dictionary<ulong, DeathRecord>();
            if (data.LastUse == null) data.LastUse = new Dictionary<ulong, double>();
        }

        private void Unload()
        {
            SaveData();
            data = null;
            config = null;
        }

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

        private object OnPlayerDeath(BasePlayer player, HitInfo info)
        {
            if (player == null || player.IsNpc) return null;

            data.Deaths[player.userID] = new DeathRecord
            {
                Position = player.transform.position,
                Time = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds,
                Map = ConVar.Server.level,
                Team = player.currentTeam
            };
            SaveData();
            return null;
        }

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

            if (config.RequirePermission && !permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (!player.IsAlive() || player.IsSleeping())
            {
                SendReply(player, Msg("NotAlive", player.UserIDString));
                return;
            }

            DeathRecord record;
            if (!data.Deaths.TryGetValue(player.userID, out record) || record == null)
            {
                SendReply(player, Msg("NoRecord", player.UserIDString));
                return;
            }

            if (!string.IsNullOrEmpty(record.Map) && record.Map != ConVar.Server.level)
            {
                SendReply(player, Msg("MapChanged", player.UserIDString));
                data.Deaths.Remove(player.userID);
                return;
            }

            double now = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;

            if (config.WindowMinutes > 0f && now - record.Time > config.WindowMinutes * 60f)
            {
                SendReply(player, Msg("WindowClosed", player.UserIDString));
                return;
            }

            if (config.BlockInBuildingPrivilege && player.IsBuildingBlocked())
            {
                SendReply(player, Msg("Blocked", player.UserIDString));
                return;
            }

            double remaining = GetRemainingCooldown(player, record.Team, now);
            if (remaining > 0d)
            {
                SendReply(player, Msg("Cooldown", player.UserIDString, Math.Ceiling(remaining)));
                return;
            }

            TeleportPlayer(player, record.Position);
            data.LastUse[player.userID] = now;
            data.Deaths.Remove(player.userID);
            SaveData();

            SendReply(player, Msg("Success", player.UserIDString));
            if (config.AnnounceTeleport) Server.Broadcast(Msg("Broadcast", null, player.displayName));
        }

        private double GetRemainingCooldown(BasePlayer player, ulong team, double now)
        {
            if (config.CooldownSeconds <= 0f) return 0d;

            double last;
            if (data.LastUse.TryGetValue(player.userID, out last) && now - last < config.CooldownSeconds)
                return config.CooldownSeconds - (now - last);

            if (!config.TeamSharedCooldown || team == 0UL) return 0d;

            var teamObj = RelationshipManager.ServerInstance.FindTeam(team);
            if (teamObj == null) return 0d;

            foreach (ulong member in teamObj.members)
            {
                if (member == player.userID) continue;
                double memberLast;
                if (data.LastUse.TryGetValue(member, out memberLast) && now - memberLast < config.CooldownSeconds)
                    return config.CooldownSeconds - (now - memberLast);
            }
            return 0d;
        }

        private void TeleportPlayer(BasePlayer player, Vector3 position)
        {
            Effect.server.Run("assets/bundled/prefabs/fx/teleport.prefab", player.transform.position);
            player.Teleport(position);

            if (config.BannedItemShortnames == null || config.BannedItemShortnames.Count == 0) return;

            var container = player.inventory?.containerMain;
            if (container == null) return;

            for (int i = container.itemList.Count - 1; i >= 0; i--)
            {
                var item = container.itemList[i];
                if (item?.info == null) continue;
                if (config.BannedItemShortnames.Contains(item.info.shortname)) item.Remove();
            }
            container.MarkDirty();
        }
    }
}