How to make a Rust auto close doors plugin (per-player delay)

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

namespace Oxide.Plugins
{
    [Info("Auto Doors", "RustPluginGenerator", "1.0.0")]
    [Description("Closes doors automatically after a per-player configurable delay.")]
    public class AutoDoors : RustPlugin
    {
        private const string PermUse = "autodoors.use";
        private const string DataName = "AutoDoors";

        private PluginConfig config;
        private StoredData data;
        private readonly Dictionary<ulong, Timer> timers = new Dictionary<ulong, Timer>();

        private class PluginConfig
        {
            [JsonProperty("Default enabled")]
            public bool DefaultEnabled = true;

            [JsonProperty("Default delay (seconds)")]
            public float DefaultDelay = 8f;

            [JsonProperty("Minimum delay (seconds)")]
            public float MinimumDelay = 3f;

            [JsonProperty("Maximum delay (seconds)")]
            public float MaximumDelay = 30f;
        }

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

            [JsonProperty("Delay (seconds)")]
            public float Delay = 8f;
        }

        private class StoredData
        {
            [JsonProperty("Players")]
            public Dictionary<string, PlayerSettings> Players = new Dictionary<string, PlayerSettings>();
        }

        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();
            }

            if (config.MinimumDelay < 0.5f) config.MinimumDelay = 0.5f;
            if (config.MaximumDelay < config.MinimumDelay) config.MaximumDelay = config.MinimumDelay;
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Enabled"] = "Auto doors enabled. Your door delay is {0} seconds.",
                ["Disabled"] = "Auto doors disabled.",
                ["DelaySet"] = "Your door auto close delay is now {0} seconds.",
                ["DelayRange"] = "Delay must be a number between {0} and {1} seconds.",
                ["NoPermission"] = "You do not have permission to use auto doors."
            }, this);
        }

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

        private void Unload()
        {
            foreach (var entry in timers)
            {
                entry.Value?.Destroy();
            }

            timers.Clear();
            SaveData();
        }

        private void LoadData()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(DataName);
            }
            catch
            {
                data = null;
            }

            if (data == null)
            {
                data = new StoredData();
            }

            if (data.Players == null)
            {
                data.Players = new Dictionary<string, PlayerSettings>();
            }
        }

        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(DataName, data);

        private PlayerSettings GetSettings(string userId, BasePlayer player = null)
        {
            PlayerSettings settings;
            if (!data.Players.TryGetValue(userId, out settings))
            {
                settings = new PlayerSettings
                {
                    Enabled = config.DefaultEnabled,
                    Delay = Clamp(config.DefaultDelay)
                };
                data.Players[userId] = settings;
            }

            settings.Delay = Clamp(settings.Delay);
            return settings;
        }

        private float Clamp(float value)
        {
            if (value < config.MinimumDelay) return config.MinimumDelay;
            if (value > config.MaximumDelay) return config.MaximumDelay;
            return value;
        }

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

        private void OnDoorOpened(Door door, BasePlayer player)
        {
            if (door == null || player == null || player.IsNpc) return;
            if (player.IsDead() || player.IsSleeping()) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return;

            ulong doorId = door.net.ID.Value;
            Timer oldTimer;
            if (timers.TryGetValue(doorId, out oldTimer))
            {
                oldTimer?.Destroy();
                timers.Remove(doorId);
            }

            PlayerSettings settings = GetSettings(player.UserIDString, player);
            if (!settings.Enabled) return;

            string userId = player.UserIDString;
            float delay = Clamp(settings.Delay);

            timers[doorId] = timer.Once(delay, () => CloseDoor(doorId, door, userId));
        }

        private void CloseDoor(ulong doorId, Door door, string userId)
        {
            timers.Remove(doorId);

            if (door == null || door.IsDestroyed) return;
            if (!permission.UserHasPermission(userId, PermUse)) return;

            PlayerSettings settings;
            if (!data.Players.TryGetValue(userId, out settings) || !settings.Enabled) return;

            door.SetOpen(false);
        }

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

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

            PlayerSettings settings = GetSettings(player.UserIDString, player);

            if (args == null || args.Length == 0)
            {
                settings.Enabled = !settings.Enabled;
                SaveData();

                if (settings.Enabled)
                {
                    player.ChatMessage(Msg("Enabled", player.UserIDString, settings.Delay.ToString("0.#")));
                }
                else
                {
                    player.ChatMessage(Msg("Disabled", player.UserIDString));
                }

                return;
            }

            float requested;
            if (!float.TryParse(args[0], out requested))
            {
                player.ChatMessage(Msg("DelayRange", player.UserIDString,
                    config.MinimumDelay.ToString("0.#"), config.MaximumDelay.ToString("0.#")));
                return;
            }

            settings.Delay = Clamp(requested);
            settings.Enabled = true;
            SaveData();

            player.ChatMessage(Msg("DelaySet", player.UserIDString, settings.Delay.ToString("0.#")));
        }
    }
}