How to make a Rust sleeping bag teleport plugin (bag list, warmup, cooldown)

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

namespace Oxide.Plugins
{
    [Info("BagTeleport", "RustPluginGenerator", "1.0.0")]
    [Description("Lists your sleeping bags with grid positions and teleports to them after a warmup.")]
    public class BagTeleport : RustPlugin
    {
        private const string PermUse = "bagteleport.use";
        private const string PermBypass = "bagteleport.bypass";

        private PluginConfig config;
        private readonly Dictionary<ulong, SleepingBag> bags = new Dictionary<ulong, SleepingBag>();
        private readonly Dictionary<ulong, float> warmup = new Dictionary<ulong, float>();
        private readonly Dictionary<string, DateTime> cooldowns = new Dictionary<string, DateTime>();

        private class PluginConfig
        {
            [JsonProperty("Warmup seconds")]
            public float WarmupSeconds = 10f;

            [JsonProperty("Cooldown seconds")]
            public float CooldownSeconds = 60f;

            [JsonProperty("Maximum bags listed")]
            public int MaxListedBags = 10;
        }

        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>
            {
                ["ListHeader"] = "Your sleeping bags:",
                ["ListItem"] = "{0}. {1} - {2}",
                ["ListEmpty"] = "You have no sleeping bags placed.",
                ["Usage"] = "Usage: /bag or /bag <number>",
                ["InvalidNumber"] = "That is not a bag number from the list.",
                ["Warmup"] = "Teleporting to {0} in {1} seconds. Taking damage cancels it.",
                ["Cancelled"] = "Teleport cancelled.",
                ["Cooldown"] = "You must wait {0} seconds before teleporting again.",
                ["Success"] = "You have been teleported to {0}."
            }, 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(PermBypass, this);
        }

        private void OnServerInitialized()
        {
            LoadData();
            foreach (var networkable in BaseNetworkable.serverEntities)
            {
                var bag = networkable as SleepingBag;
                if (bag != null && bag.OwnerID != 0)
                    bags[bag.net.ID.Value] = bag;
            }
        }

        private void OnEntitySpawned(BaseNetworkable entity)
        {
            var bag = entity as SleepingBag;
            if (bag != null && bag.OwnerID != 0)
                bags[bag.net.ID.Value] = bag;
        }

        private void OnEntityKill(BaseNetworkable entity)
        {
            if (entity != null)
                bags.Remove(entity.net.ID.Value);
        }

        [ChatCommand("bag")]
        private void CmdBag(BasePlayer player, string command, string[] args)
        {
            if (player == null || !permission.UserHasPermission(player.UserIDString, PermUse))
                return;

            if (args == null || args.Length == 0)
            {
                SendList(player);
                return;
            }

            int index;
            if (!int.TryParse(args[0], out index))
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            var owned = GetOwnedBags(player);
            if (index < 1 || index > owned.Count)
            {
                SendReply(player, Msg("InvalidNumber", player.UserIDString));
                return;
            }

            var target = owned[index - 1];
            if (target == null || target.IsDestroyed)
            {
                SendReply(player, Msg("InvalidNumber", player.UserIDString));
                return;
            }

            bool bypass = permission.UserHasPermission(player.UserIDString, PermBypass);
            if (!bypass && !CooldownReady(player))
            {
                DateTime last;
                if (cooldowns.TryGetValue(player.UserIDString, out last))
                {
                    double remaining = config.CooldownSeconds - (DateTime.UtcNow - last).TotalSeconds;
                    SendReply(player, Msg("Cooldown", player.UserIDString, Math.Max(1, (int)remaining)));
                }
                return;
            }

            if (bypass)
            {
                TeleportTo(player, target);
                SendReply(player, Msg("Success", player.UserIDString, target.ShortPrefabName));
                return;
            }

            var userId = player.userID.Get();
            warmup[userId] = UnityEngine.Time.realtimeSinceStartup;
            SendReply(player, Msg("Warmup", player.UserIDString, target.ShortPrefabName, (int)config.WarmupSeconds));

            timer.Once(config.WarmupSeconds, () =>
            {
                if (!warmup.ContainsKey(userId))
                    return;
                warmup.Remove(userId);
                if (player == null || !player.IsConnected || player.IsDead() || target == null || target.IsDestroyed)
                    return;
                TeleportTo(player, target);
                SendReply(player, Msg("Success", player.UserIDString, target.ShortPrefabName));
            });
        }

        private void SendList(BasePlayer player)
        {
            var owned = GetOwnedBags(player);
            if (owned.Count == 0)
            {
                SendReply(player, Msg("ListEmpty", player.UserIDString));
                return;
            }

            SendReply(player, Msg("ListHeader", player.UserIDString));
            for (int i = 0; i < owned.Count && i < config.MaxListedBags; i++)
            {
                var bag = owned[i];
                SendReply(player, Msg("ListItem", player.UserIDString, i + 1,
                    bag.ShortPrefabName, PositionToGrid(bag.transform.position)));
            }
        }

        private List<SleepingBag> GetOwnedBags(BasePlayer player)
        {
            var owner = player.userID.Get();
            var list = new List<SleepingBag>();
            foreach (var bag in bags.Values)
            {
                if (bag == null || bag.IsDestroyed) continue;
                if (bag.OwnerID != owner) continue;
                list.Add(bag);
            }
            return list
                .OrderBy(b => b.ShortPrefabName)
                .ThenBy(b => Vector3.Distance(player.transform.position, b.transform.position))
                .ToList();
        }

        private bool CooldownReady(BasePlayer player)
        {
            DateTime last;
            if (!cooldowns.TryGetValue(player.UserIDString, out last))
                return true;
            return (DateTime.UtcNow - last).TotalSeconds >= config.CooldownSeconds;
        }

        private void TeleportTo(BasePlayer player, SleepingBag target)
        {
            cooldowns[player.UserIDString] = DateTime.UtcNow;
            player.Teleport(target.transform.position + Vector3.up * 0.2f);
            SaveData();
        }

        private string PositionToGrid(Vector3 position)
        {
            float worldSize = ConVar.Server.worldsize;
            float half = worldSize / 2f;
            int x = (int)((position.x + half) / 150f) + 1;
            int z = (int)((position.z + half) / 150f) + 1;
            return string.Format("{0}{1}", GridLetter(x - 1), z);
        }

        private string GridLetter(int index)
        {
            index = Mathf.Clamp(index, 0, 25);
            return ((char)('A' + index)).ToString();
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
        {
            var player = entity as BasePlayer;
            if (player != null && warmup.ContainsKey(player.userID.Get()))
            {
                warmup.Remove(player.userID.Get());
                SendReply(player, Msg("Cancelled", player.UserIDString));
            }
            return null;
        }

        private void LoadData()
        {
            var stored = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, string>>(Name);
            if (stored == null) return;
            cooldowns.Clear();
            foreach (var entry in stored)
            {
                DateTime when;
                if (DateTime.TryParse(entry.Value, out when))
                    cooldowns[entry.Key] = when;
            }
        }

        private void SaveData()
        {
            var stored = new Dictionary<string, string>();
            foreach (var entry in cooldowns)
                stored[entry.Key] = entry.Value.ToString("o");
            Interface.Oxide.DataFileSystem.WriteObject(Name, stored);
        }

        private void Unload()
        {
            SaveData();
            warmup.Clear();
        }
    }
}