using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Oxide.Core;
using Oxide.Core.Libraries;
using Oxide.Core.Plugins;
using Oxide.Core.Libraries.Covalence;
using Rust;

//  ____  _       _ _       
// / ___|(_) __ _(_) | ___  
// \___ \| |/ _` | | |/ _ \ 
//  ___) | | (_| | | | (_) |
// |____/|_|\__, |_|_|\___/ 
//          |___/             
// ☽✧✵✧✵✧✵✧✵✧✵✧✵✧☾
// ✦    RUST PLUGINS   ✦
// ✦     Sigilo.dev    ✦
// ☽✧✵✧✵✧✵✧✵✧✵✧✵✧☾

namespace Oxide.Plugins
{
    [Info("Pop", "Sigilo", "1.8.0")]
    [Description("Displays the number of connected, connecting, queued players and sleepers.")]

    public class Pop : CovalencePlugin
    {
        private string command;
        private string broadcastCommand;
        private string onlineColor;
        private string joiningColor;
        private string queuedColor;
        private string sleepersColor;
        private int broadcastDelay;
        private DateTime lastBroadcast;
        private bool enablePersonalCommand;
        private bool enableGlobalCommand;
        private ulong customIconSteamId;
        private bool showOnline;
        private bool showJoining;
        private bool showQueued;
        private bool showSleepers;

        private void Init()
        {
            permission.RegisterPermission("pop.use", this);
            LoadConfig();
            
            if (enablePersonalCommand && !string.IsNullOrEmpty(command))
            {
                AddCovalenceCommand(command, "PopCommand");
            }
            if (enableGlobalCommand && !string.IsNullOrEmpty(broadcastCommand))
            {
                AddCovalenceCommand(broadcastCommand, "BroadcastPopCommand");
            }
        }

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                command = Config.Get<string>("Command") ?? "pop";
                broadcastCommand = Config.Get<string>("BroadcastCommand") ?? "!pop";
                onlineColor = Config.Get<string>("OnlineColor") ?? "#ff686b";
                joiningColor = Config.Get<string>("JoiningColor") ?? "#ff686b";
                queuedColor = Config.Get<string>("QueuedColor") ?? "#ff686b";
                sleepersColor = Config.Get<string>("SleepersColor") ?? "#ff686b";
                
                broadcastDelay = Config["BroadcastDelay"] != null ? 
                    Convert.ToInt32(Config["BroadcastDelay"]) : 10;
                
                enablePersonalCommand = Config["EnablePersonalCommand"] != null ? 
                    Convert.ToBoolean(Config["EnablePersonalCommand"]) : true;
                
                enableGlobalCommand = Config["EnableGlobalCommand"] != null ? 
                    Convert.ToBoolean(Config["EnableGlobalCommand"]) : true;
                
                customIconSteamId = Config["CustomIconSteamId"] != null ? 
                    Convert.ToUInt64(Config["CustomIconSteamId"]) : 0UL;
                
                showOnline = true;
                showJoining = true;
                showQueued = true;
                showSleepers = true;
                
                object showOnlineObj = GetConfigValue("ShowOnline");
                if (showOnlineObj != null && bool.TryParse(showOnlineObj.ToString(), out bool showOnlineValue))
                    showOnline = showOnlineValue;
                
                object showJoiningObj = GetConfigValue("ShowJoining");
                if (showJoiningObj != null && bool.TryParse(showJoiningObj.ToString(), out bool showJoiningValue))
                    showJoining = showJoiningValue;
                
                object showQueuedObj = GetConfigValue("ShowQueued");
                if (showQueuedObj != null && bool.TryParse(showQueuedObj.ToString(), out bool showQueuedValue))
                    showQueued = showQueuedValue;
                
                object showSleepersObj = GetConfigValue("ShowSleepers");
                if (showSleepersObj != null && bool.TryParse(showSleepersObj.ToString(), out bool showSleepersValue))
                    showSleepers = showSleepersValue;
                
                SaveNewConfigOptions();
            }
            catch (Exception ex)
            {
                PrintError($"Error loading config: {ex.Message}");
                LoadDefaultConfig();
            }
        }
        
        private object GetConfigValue(string key)
        {
            try
            {
                if (Config[key] != null)
                    return Config[key];
            }
            catch (Exception ex)
            {
                PrintError($"Error getting config value '{key}': {ex.Message}");
            }
            return null;
        }
        
        private void SaveNewConfigOptions()
        {
            try
            {
                bool changed = false;
                
                if (GetConfigValue("SleepersColor") == null)
                {
                    Config["SleepersColor"] = "#ff686b";
                    changed = true;
                }
                
                if (GetConfigValue("ShowOnline") == null)
                {
                    Config["ShowOnline"] = true;
                    changed = true;
                }
                
                if (GetConfigValue("ShowJoining") == null)
                {
                    Config["ShowJoining"] = true;
                    changed = true;
                }
                
                if (GetConfigValue("ShowQueued") == null)
                {
                    Config["ShowQueued"] = true;
                    changed = true;
                }
                
                if (GetConfigValue("ShowSleepers") == null)
                {
                    Config["ShowSleepers"] = true;
                    changed = true;
                }
                
                if (GetConfigValue("CustomIconSteamId") == null)
                {
                    Config["CustomIconSteamId"] = 0UL;
                    changed = true;
                }
                
                if (changed)
                {
                    PrintWarning("Configuration file updated with new options.");
                    SaveConfig();
                }
            }
            catch (Exception ex)
            {
                PrintError($"Error saving new config options: {ex.Message}");
            }
        }

        protected override void LoadDefaultConfig()
        {
            PrintWarning("Creating new configuration file");
            Config.Clear();
            Config["Command"] = "pop";
            Config["BroadcastCommand"] = "!pop";
            Config["OnlineColor"] = "#ff686b";
            Config["JoiningColor"] = "#ff686b";
            Config["QueuedColor"] = "#ff686b";
            Config["SleepersColor"] = "#ff686b";
            Config["BroadcastDelay"] = 10;
            Config["EnablePersonalCommand"] = true;
            Config["EnableGlobalCommand"] = true;
            Config["CustomIconSteamId"] = 0UL;
            Config["ShowOnline"] = true;
            Config["ShowJoining"] = true;
            Config["ShowQueued"] = true;
            Config["ShowSleepers"] = true;
            SaveConfig();
        }

        private int GetQueuedPlayersCount()
        {
            return ServerMgr.Instance.connectionQueue.Queued;
        }

        private int GetSleepersCount()
        {
            return BasePlayer.sleepingPlayerList.Count;
        }

        private string FormatStatusMessage(int connectedPlayers, int joiningPlayers, int playersInQueue, int sleepersCount)
        {
            List<string> parts = new List<string>();
            
            if (showOnline)
                parts.Add($"Online: {string.Format("<color={0}>{1}</color>", onlineColor, connectedPlayers)}");
            
            if (showJoining)
                parts.Add($"Joining: {string.Format("<color={0}>{1}</color>", joiningColor, joiningPlayers)}");
            
            if (showQueued)
                parts.Add($"Queued: {string.Format("<color={0}>{1}</color>", queuedColor, playersInQueue)}");
            
            if (showSleepers)
                parts.Add($"Sleepers: {string.Format("<color={0}>{1}</color>", sleepersColor, sleepersCount)}");
            
            if (parts.Count == 0)
                parts.Add($"Online: {string.Format("<color={0}>{1}</color>", onlineColor, connectedPlayers)}");
            
            string message = string.Join(" | ", parts);
            
            return message;
        }

        private void PopCommand(IPlayer player, string cmd, string[] args)
        {
            if (!permission.UserHasPermission(player.Id, "pop.use"))
            {
                player.Reply(lang.GetMessage("NoPermission", this, player.Id));
                return;
            }

            int connectedPlayers = BasePlayer.activePlayerList.Count;
            int joiningPlayers = ServerMgr.Instance.connectionQueue.Joining;
            int playersInQueue = GetQueuedPlayersCount();
            int sleepersCount = GetSleepersCount();

            string message = FormatStatusMessage(connectedPlayers, joiningPlayers, playersInQueue, sleepersCount);
            
            if (customIconSteamId != 0)
            {
                BasePlayer basePlayer = player.Object as BasePlayer;
                if (basePlayer != null)
                {
                    basePlayer.SendConsoleCommand("chat.add", 0, customIconSteamId, message);
                    return;
                }
            }
            
            player.Reply(message);
        }

        private void BroadcastPopCommand(IPlayer player, string cmd, string[] args)
        {
            if (!permission.UserHasPermission(player.Id, "pop.use"))
            {
                player.Reply(lang.GetMessage("NoPermission", this, player.Id));
                return;
            }

            if (DateTime.Now < lastBroadcast.AddMinutes(broadcastDelay))
            {
                string tooSoonMessage = string.Format(lang.GetMessage("TooSoon", this, player.Id), broadcastDelay);
                player.Reply(tooSoonMessage);
                return;
            }

            lastBroadcast = DateTime.Now;

            int connectedPlayers = BasePlayer.activePlayerList.Count;
            int joiningPlayers = ServerMgr.Instance.connectionQueue.Joining;
            int playersInQueue = GetQueuedPlayersCount();
            int sleepersCount = GetSleepersCount();

            string message = FormatStatusMessage(connectedPlayers, joiningPlayers, playersInQueue, sleepersCount);
            
            if (customIconSteamId != 0)
            {
                foreach (BasePlayer basePlayer in BasePlayer.activePlayerList)
                {
                    basePlayer.SendConsoleCommand("chat.add", 0, customIconSteamId, message);
                }
                return;
            }
            
            server.Broadcast(message);
        }

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                {"NoPermission", "You don't have permission to use this command."},
                {"TooSoon", "You must wait {0} minutes between broadcasts (try /pop)."},
                {"PopMessage", "Players Online: {0}/{1} | Joining: {2} | Queued: {3} | Sleepers: {4}"}
            }, this);
        }

        void OnUserChat(IPlayer player, string message)
        {
            if (enableGlobalCommand && !string.IsNullOrEmpty(broadcastCommand) && message == broadcastCommand)
            {
                BroadcastPopCommand(player, message, null);
                return;
            }
        }
    }
}