How to make a Rust AFK kick plugin (idle timer with warning)

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

namespace Oxide.Plugins
{
    [Info("Afk Kick", "RustPluginGenerator", "1.0.0")]
    [Description("Kicks players who stay idle for too long, with a warning one minute before.")]
    public class AfkKick : RustPlugin
    {
        private const string PermUse = "afkkick.use";
        private const string PermExempt = "afkkick.exempt";

        private class PluginConfig
        {
            [JsonProperty("Idle Minutes")]
            public float IdleMinutes { get; set; } = 30f;

            [JsonProperty("Warning Grace Minutes")]
            public float WarningGraceMinutes { get; set; } = 1f;

            [JsonProperty("Minimum Players")]
            public int MinimumPlayers { get; set; } = 20;

            [JsonProperty("Check Interval Seconds")]
            public float CheckIntervalSeconds { get; set; } = 5f;

            [JsonProperty("Move Tolerance")]
            public float MoveTolerance { get; set; } = 0.5f;

            [JsonProperty("Angle Tolerance")]
            public float AngleTolerance { get; set; } = 2f;

            [JsonProperty("Kick Reason")]
            public string KickReason { get; set; } = "Kicked for being AFK";
        }

        private class PlayerState
        {
            public Vector3 Position;
            public Quaternion Rotation;
            public float LastActive;
            public bool Warned;
        }

        private PluginConfig config;
        private readonly Dictionary<ulong, PlayerState> states = new Dictionary<ulong, PlayerState>();
        private Timer checkTimer;

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

        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>
            {
                ["Warning"] = "You have been idle. Move within {0} minute(s) or you will be kicked.",
                ["Kicked"] = "Kicked for being AFK",
                ["Status"] = "You have been idle for {0} second(s). The kick threshold is {1} minute(s).",
                ["NoPermission"] = "You do not have permission to use that command."
            }, this);
        }

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

        private void OnServerInitialized()
        {
            checkTimer?.Destroy();
            checkTimer = timer.Every(Mathf.Max(1f, config.CheckIntervalSeconds), RunCheck);
        }

        private void Unload()
        {
            checkTimer?.Destroy();
            checkTimer = null;
            states.Clear();
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;
            states[player.userID] = new PlayerState
            {
                Position = player.transform.position,
                Rotation = player.eyes != null ? player.eyes.rotation : Quaternion.identity,
                LastActive = Time.realtimeSinceStartup,
                Warned = false
            };
        }

        private bool CanKick(BasePlayer player)
        {
            if (player == null || !player.IsConnected || player.IsAdmin) return false;
            if (permission.UserHasPermission(player.UserIDString, PermExempt)) return false;
            return true;
        }

        private void RunCheck()
        {
            if (BasePlayer.activePlayerList.Count <= config.MinimumPlayers) return;

            float now = Time.realtimeSinceStartup;
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (!CanKick(player)) continue;
                if (player.eyes == null) continue;

                PlayerState state;
                if (!states.TryGetValue(player.userID, out state))
                {
                    states[player.userID] = new PlayerState
                    {
                        Position = player.transform.position,
                        Rotation = player.eyes.rotation,
                        LastActive = now,
                        Warned = false
                    };
                    continue;
                }

                Vector3 pos = player.transform.position;
                Quaternion rot = player.eyes.rotation;

                bool moved = Vector3.Distance(pos, state.Position) > config.MoveTolerance;
                bool turned = Quaternion.Angle(rot, state.Rotation) > config.AngleTolerance;

                if (moved || turned)
                {
                    state.Position = pos;
                    state.Rotation = rot;
                    state.LastActive = now;
                    state.Warned = false;
                    continue;
                }

                float idleSeconds = now - state.LastActive;
                float warnAt = config.IdleMinutes * 60f;
                float kickAt = (config.IdleMinutes + config.WarningGraceMinutes) * 60f;

                if (idleSeconds >= kickAt)
                {
                    states.Remove(player.userID);
                    player.Kick(Msg("Kicked", player.UserIDString));
                }
                else if (idleSeconds >= warnAt && !state.Warned)
                {
                    state.Warned = true;
                    player.ChatMessage(Msg("Warning", player.UserIDString, config.WarningGraceMinutes));
                }
            }
        }

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

            PlayerState state;
            float idle = 0f;
            if (states.TryGetValue(player.userID, out state))
            {
                idle = Time.realtimeSinceStartup - state.LastActive;
            }

            player.ChatMessage(Msg("Status", player.UserIDString, Mathf.FloorToInt(idle), config.IdleMinutes));
        }
    }
}