Hints.cs

using HintServiceMeow.Core.Utilities;
using LabApi.Features.Console;
using LabApi.Features.Wrappers;
using LevelUp.PlayerData;
using MEC;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Hint = HintServiceMeow.Core.Models.Hints.Hint;

namespace LevelUp;

public static class Hints
{
    private static readonly Dictionary<string, Hint> levelHints = new();

    private static readonly Dictionary<string, Queue<string>> playerKillMessages = new();

    // 缓存上次显示的数据，避免不必要的更新
    private static readonly Dictionary<string, (int level, int exp, int reqExp)> lastDisplayedData = new();

    // 生成玩家名称的等级前缀（用于非击杀广播场景）
    public static string GetPlayerLevelPrefix(Player player)
    {
        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(player.UserId, out DataTemplates playerData))
        {
            playerData = new DataTemplates { UserId = player.UserId };
            LevelUp.Instance.PlayerDataCache[player.UserId] = playerData;
        }

        // 替换模板中的等级占位符
        return LevelUp.Instance.Translation.hintTrans.PlayerNamePrefix
            .Replace("{level}", playerData.Level.ToString());
    }

    public static Hint GetLevelHints(Player player)
    {
        if (player == null)
        {
            return null;
        }

        string userId = player.UserId;

        // 获取玩家数据
        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(userId, out DataTemplates playerData))
        {
            playerData = new DataTemplates { UserId = userId };
            LevelUp.Instance.PlayerDataCache[userId] = playerData;
            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"为玩家 {player.Nickname} ({userId}) 创建新的数据模板。");
        }

        // 计算所需经验（使用新的计算方法）
        int reqExp = LevelUp.Instance.CalculateRequiredExp(playerData.Level);

        // 检查数据是否变化
        bool needsUpdate = false;
        if (lastDisplayedData.TryGetValue(userId, out var lastData))
        {
            needsUpdate = lastData.level != playerData.Level ||
                          lastData.exp != playerData.Experience ||
                          lastData.reqExp != reqExp;
        }
        else
        {
            needsUpdate = true;
        }

        // 如果数据没变化且Hint已存在，直接返回缓存的Hint
        if (!needsUpdate && levelHints.TryGetValue(userId, out var cachedHint))
        {
            return cachedHint;
        }

        // 数据变化了，更新Hint
        string roleColor = player.RoleBase.RoleColor.ToHex();
        string text = LevelUp.Instance.Translation.hintTrans.lvTranslations
            .Replace("{roleColor}", roleColor)
            .Replace("{level}", playerData.Level.ToString())
            .Replace("{exp}", playerData.Experience.ToString())
            .Replace("{ReqExp}", reqExp.ToString());

        Hint hint;
        if (levelHints.TryGetValue(userId, out var existingHint))
        {
            // 重用现有Hint对象，只更新Text
            existingHint.Text = text;
            hint = existingHint;
        }
        else
        {
            // 创建新的Hint对象
            hint = new Hint
            {
                Text = text,
                FontSize = LevelUp.Instance.Config.statesettings.FontSize,
                YCoordinate = LevelUp.Instance.Config.statesettings.YCoordinate,
                XCoordinate = LevelUp.Instance.Config.statesettings.XCoordinate
            };
            levelHints[userId] = hint;
        }

        // 更新缓存的数据
        lastDisplayedData[userId] = (playerData.Level, playerData.Experience, reqExp);

        return hint;
    }

    public static void AddLevelHint(Player player)
    {
        PlayerDisplay pd = PlayerDisplay.Get(player);
        if (pd == null) return;

        if (LevelUp.Instance.Config.statesettings.IsEnabled)
            pd.AddHint(GetLevelHints(player));
    }

    public static void RemoveLevelHint(Player player)
    {
        PlayerDisplay pd = PlayerDisplay.Get(player);
        if (pd == null) return;

        if (levelHints.TryGetValue(player.UserId, out var hint))
        {
            pd.RemoveHint(hint);
            levelHints.Remove(player.UserId);
            lastDisplayedData.Remove(player.UserId); // 清理缓存数据
        }
    }

    public static void RemoveAllHints()
    {
        foreach (var player in Player.List.ToList())
            RemoveLevelHint(player);

        playerKillMessages.Clear();
        levelHints.Clear();
        lastDisplayedData.Clear(); // 清理缓存数据
    }

    public static Queue<string> GetKillMessage(Player player)
    {
        Queue<string> q = new Queue<string>();
        if (!playerKillMessages.ContainsKey(player.UserId)) 
        {
            playerKillMessages[player.UserId] = q;
        }

        q = playerKillMessages[player.UserId];
        return q;
    }

    public static void UpdateKillMessageHint(Player viewer, Queue<string> q)
    {
        if (!LevelUp.Instance.Config.killsettings.IsEnabled)
            return;

        // 启动协程处理击杀消息显示
        Timing.RunCoroutine(UpdateKillMessageHintCoroutine(viewer, q));
    }

    private static IEnumerator<float> UpdateKillMessageHintCoroutine(Player viewer, Queue<string> q)
    {
        PlayerDisplay pd = PlayerDisplay.Get(viewer);
        if (pd == null)
            yield break;

        string allmessages = string.Join("\n", q);

        var killHint = new Hint
        {
            Text = allmessages,
            FontSize = LevelUp.Instance.Config.killsettings.FontSize,
            YCoordinate = LevelUp.Instance.Config.killsettings.YCoordinate,
            XCoordinate = LevelUp.Instance.Config.killsettings.XCoordinate
        };

        pd.AddHint(killHint);

        // 逐条移除消息，每条显示指定时间
        while(q.Count > 0)
        {
            yield return Timing.WaitForSeconds(LevelUp.Instance.Config.showTime.killmessage);
            q.Dequeue();
            killHint.Text = string.Join("\n", q);
        }

        pd.RemoveHint(killHint);
    }

    // 击杀广播保持原样，不添加等级前缀
    public static void BroadcastKillMessage(Player killer, Player target)
    {
        if (!LevelUp.Instance.Config.killsettings.IsEnabled)
            return;

        // 直接使用原始昵称，不添加前缀
        string atkRoleColor = killer.RoleBase.RoleColor.ToHex();
        string tgtRoleColor = target.RoleBase.RoleColor.ToHex();
        string message = LevelUp.Instance.Translation.hintTrans.GlobalKillMessage
            .Replace("{atkroleColor}", atkRoleColor)
            .Replace("{tgtroleColor}", tgtRoleColor)
            .Replace("{killer}", killer.Nickname)
            .Replace("{target}", target.Nickname); // 不添加前缀

        int maxMessages = LevelUp.Instance.Config.killsettings.MaxDisplayMessages;

        foreach (var player in Player.List)
        {
            if(player == null || player.IsNpc) continue;

            var q = GetKillMessage(player);
            q.Enqueue(message);

            // 限制消息数量，超过限制时移除最旧的消息
            while (q.Count > maxMessages)
            {
                q.Dequeue();
            }

            UpdateKillMessageHint(player, q);
        }
    }

    // 添加玩家名称更新方法
    public static void UpdatePlayerNameWithLevelPrefix(Player player)
    {
        if (player == null || player.IsNpc) return;

        // 检查配置是否启用名称前缀
        if (!LevelUp.Instance.Config.EnableNamePrefix)
            return;

        string originalName = player.Nickname;
        string prefix = GetPlayerLevelPrefix(player);

        // 设置新名称（前缀+原始名称）
        string newName = $"{prefix}{originalName}";
        player.DisplayName = newName;
    }
}