using UnityEngine;
using UnityEngine.UI;
using System;
using System.Collections;
using SmoothShakeFree;
using Random = UnityEngine.Random;

/// <summary>
/// 控制游戏过程中的打击特效及其他图形效果
/// </summary>
public class GfxController : MonoBehaviour
{
    public static GfxController Instance { get; private set; }

    // 复用的属性块：命中特效透明度覆写用，避免每次命中访问 r.materials 克隆材质。
    private MaterialPropertyBlock _fxPropertyBlock;

    [Header("Combatant Objects")]
    public GameObject enemyMoveObject;
    public GameObject ally01MoveObject;
    public GameObject ally02MoveObject;
    public GameObject ally03MoveObject;
    public GameObject ally04MoveObject;
    public GameObject ally05MoveObject;

    [Header("Hit Effects - Enemy")]
    public GameObject enemyObject;

    [Header("Hit Effects - Allies")]
    public GameObject ally01Object;
    public GameObject ally02Object;
    public GameObject ally03Object;
    public GameObject ally04Object;
    public GameObject ally05Object;

    [Header("Prefabs")]
    public GameObject hitFX;
    public GameObject projectileFX;
    public GameObject explosionFX;
    public GameObject k_o_fx;
    public GameObject koFatherObject;
    public float koFxScale = 1f;
    public int koFxSortingOrder = 31;

    [Header("Explosion Effect Settings")]
    [Tooltip("当单次伤害超过敌人最大生命值的百分比时触发爆炸 (0.2 = 20%)")]
    public float explosionDamageThresholdRatio = 0.2f;
    [Tooltip("爆炸特效是否使用独立的缩放设置 (否则跟随Hit特效缩放)")]
    public bool useExplosionSeparateScale = false;
    public float explosionFxScale = 1.5f;

    [Header("Hit Effect Settings - Enemy")]
    public float enemyOffsetX = 0f;
    public float enemyOffsetY = 0f;
    public float enemyFxScale = 1f;
    public bool useEnemyRandomScale = false;
    public float enemyMinFxScale = 0.8f;
    public float enemyMaxFxScale = 1.2f;
    [Range(0f, 1f)]
    public float enemyFxTransparency = 1f;
    public int enemyFxSortingOrder = 10;

    [Header("Hit Effect Settings - Ally")]
    public float allyOffsetX = 0f;
    public float allyOffsetY = 0f;
    public float allyFxScale = 1f;
    public bool useAllyRandomScale = false;
    public float allyMinFxScale = 0.8f;
    public float allyMaxFxScale = 1.2f;
    [Range(0f, 1f)]
    public float allyFxTransparency = 1f;
    public int allyFxSortingOrder = 10;

    [Header("Ally Attack Projectile")]
    public float projectileDuration = 0.5f;
    public AnimationCurve projectileSpeedCurve = AnimationCurve.Linear(0, 0, 1, 1);
    [Range(0f, 1f)]
    public float projectileTransparency = 1f;
    public float projectileScale = 1f;
    [Tooltip("弹道颜色控制 (影响 Trail 和 Particle)")]
    public Gradient projectileColor;
    [Tooltip("弹道到达终点时的随机偏移范围 - X轴")]
    public float projectileRandomOffsetX = 0f;
    [Tooltip("弹道到达终点时的随机偏移范围 - Y轴")]
    public float projectileRandomOffsetY = 0f;
    [Tooltip("弹道到达终点时的随机偏移范围 - Z轴")]
    public float projectileRandomOffsetZ = 0f;
    public int projectileSortingOrder = 10;

    [Header("敌人攻击控件")]
    [Tooltip("Miss时敌人攻击角色的弹道特效")]
    public GameObject enemyMissProjectilePrefab;
    [Tooltip("Miss弹道颜色控制")]
    public Gradient enemyAttackProjectileColor;
    [Tooltip("Miss弹道移动时间")]
    public float enemyAttackProjectileDuration = 0.4f;
    [Tooltip("Miss弹道缩放")]
    public float enemyAttackProjectileScale = 1.0f;
    [Tooltip("Miss弹道层级")]
    public int enemyAttackProjectileSortingOrder = 15;
    [Tooltip("Miss弹道到达时的Hit特效缩放")]
    public float enemyAttackHitFxScale = 1.0f;
    [Tooltip("Miss弹道速度曲线")]
    public AnimationCurve enemyAttackSpeedCurve = AnimationCurve.Linear(0, 0, 1, 1);

    [Header("Ally Skill Projectile")]
    [Tooltip("友军技能释放的弹道特效")]
    public GameObject allySkillProjectilePrefab;
    [Tooltip("友军技能弹道颜色控制")]
    public Gradient allySkillProjectileColor;
    [Tooltip("友军技能弹道移动时间")]
    public float allySkillProjectileDuration = 0.5f;
    [Tooltip("友军技能弹道缩放")]
    public float allySkillProjectileScale = 1.0f;
    [Tooltip("友军技能弹道层级")]
    public int allySkillProjectileSortingOrder = 15;
    [Tooltip("友军技能弹道速度曲线")]
    public AnimationCurve allySkillSpeedCurve = AnimationCurve.Linear(0, 0, 1, 1);
    [Tooltip("友军技能弹道到达时的随机偏移范围 - X轴")]
    public float allySkillRandomOffsetX = 0f;
    [Tooltip("友军技能弹道到达时的随机偏移范围 - Y轴")]
    public float allySkillRandomOffsetY = 0f;
    [Tooltip("友军技能弹道到达时的随机偏移范围 - Z轴")]
    public float allySkillRandomOffsetZ = 0f;
    
    [Header("Enemy Hurt Shake Settings")]
    public Vector3 hitShakeAmplitude = new Vector3(10f, 10f, 0f);
    public Vector3 hitShakeFrequency = new Vector3(20f, 20f, 0f);
    public float hitShakeDuration = 0.2f;

    [Header("Ally Hurt Shake Settings")]
    public Vector3 allyHitShakeAmplitude = new Vector3(8f, 8f, 0f);
    public Vector3 allyHitShakeFrequency = new Vector3(25f, 25f, 0f);
    public float allyHitShakeDuration = 0.15f;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    /// <summary>
    /// 在指定目标位置播放受击特效
    /// </summary>
    /// <param name="target">受击者物体</param>
    /// <param name="parent">父物体（特效将生成在该物体下）</param>
    /// <param name="isEnemy">是否为敌人受击</param>
    /// <param name="customWorldPos">可选：自定义世界坐标播放（如匹配弹道终点）</param>
    /// <param name="scaleOverride">可选：强制指定特效缩放倍率</param>
    /// <param name="damageInfo">可选：传入伤害信息以判断是否触发爆炸特效 (damage, maxHealth)</param>
    public void PlayHitFX(GameObject target, GameObject parent = null, bool isEnemy = false, Vector3? customWorldPos = null, float? scaleOverride = null, (float damage, float maxHealth)? damageInfo = null)
    {
        // --- Check if the target ally slot is active before playing VFX ---
        if (!isEnemy && teamUIController.Instance != null)
        {
            int slot = -1;
            var ally = target.GetComponent<AllyCombatant>();
            if (ally != null) slot = ally.slotIndex;
            else
            {
                string n = target.name.ToLower();
                if (n.Contains("ally_01")) slot = 0;
                else if (n.Contains("ally_02")) slot = 1;
                else if (n.Contains("ally_03")) slot = 2;
                else if (n.Contains("ally_04")) slot = 3;
                else if (n.Contains("ally_05")) slot = 4;
            }

            if (slot != -1)
            {
                bool isActive = false;
                switch (slot)
                {
                    case 0: isActive = teamUIController.Instance.isAlly01_active; break;
                    case 1: isActive = teamUIController.Instance.isAlly02_active; break;
                    case 2: isActive = teamUIController.Instance.isAlly03_active; break;
                    case 3: isActive = teamUIController.Instance.isAlly04_active; break;
                    case 4: isActive = teamUIController.Instance.isAlly05_active; break;
                }
                if (!isActive) return; // Skip VFX for inactive ally
            }
        }

        // Determine which FX prefab to use (Hit or Explosion)
        GameObject fxPrefab = hitFX;
        bool isExplosion = false;
        
        if (isEnemy && damageInfo.HasValue && explosionFX != null)
        {
            float ratio = damageInfo.Value.damage / damageInfo.Value.maxHealth;
            if (ratio >= explosionDamageThresholdRatio)
            {
                fxPrefab = explosionFX;
                isExplosion = true;
            }
        }

        if (target == null || fxPrefab == null)
        {
            if (fxPrefab == null) Debug.LogWarning($"[GfxController] {(isExplosion ? "ExplosionFX" : "HitFX")} Prefab 未在 Inspector 中分配！");
            return;
        }

        // 触发受击震动效果
        TriggerShake(target, isEnemy);

        GameObject visualParent = null;
        if (isEnemy && enemyObject != null)
        {
            visualParent = enemyObject;
        }
        else if (!isEnemy)
        {
            visualParent = ResolveGfxMountPoint(target);
        }
        if (visualParent == null)
        {
            visualParent = parent != null ? parent : ResolveGfxMountPoint(target);
        }

        // 如果是敌人，触发闪红效果 (使用 teamUIController 已有的逻辑)
        if (isEnemy && teamUIController.Instance != null)
        {
            teamUIController.Instance.TriggerEnemyHurtFlash();
        }
        else if (!isEnemy && teamUIController.Instance != null)
        {
            // 尝试从物体名称或组件中识别槽位并触发闪红
            int slot = -1;
            var ally = target.GetComponent<AllyCombatant>();
            if (ally != null) slot = ally.slotIndex;
            else
            {
                string n = target.name.ToLower();
                if (n.Contains("ally_01")) slot = 0;
                else if (n.Contains("ally_02")) slot = 1;
                else if (n.Contains("ally_03")) slot = 2;
                else if (n.Contains("ally_04")) slot = 3;
                else if (n.Contains("ally_05")) slot = 4;
            }

            if (slot != -1)
            {
                teamUIController.Instance.TriggerAllyHurtFlash(slot);
            }
        }

        // 根据身份选择参数
        float offsetX = isEnemy ? enemyOffsetX : allyOffsetX;
        float offsetY = isEnemy ? enemyOffsetY : allyOffsetY;
        
        // 计算缩放逻辑
        float fxScale;
        if (scaleOverride.HasValue)
        {
            fxScale = scaleOverride.Value;
        }
        else if (isEnemy)
        {
            if (isExplosion && useExplosionSeparateScale)
            {
                fxScale = explosionFxScale;
            }
            else
            {
                fxScale = useEnemyRandomScale ? Random.Range(enemyMinFxScale, enemyMaxFxScale) : enemyFxScale;
            }
        }
        else
        {
            fxScale = useAllyRandomScale ? Random.Range(allyMinFxScale, allyMaxFxScale) : allyFxScale;
        }

        float transparency = isEnemy ? enemyFxTransparency : allyFxTransparency;

        GameObject fx;
        Vector3 offsetVector = new Vector3(offsetX, offsetY, 0f);

        if (visualParent != null)
        {
            // 将缩放应用到挂载点物体（visualParent）本身
            visualParent.transform.localScale = Vector3.one * fxScale;

            // 作为子物体生成
            fx = Instantiate(fxPrefab, visualParent.transform);
            
            // 确保特效在 UI 层级中显示在最前方
            fx.transform.SetAsLastSibling();

            // 检查是否是 UI 元素 (RectTransform)
            RectTransform rt = fx.GetComponent<RectTransform>();
            if (rt != null)
            {
                if (customWorldPos.HasValue)
                {
                    // 如果有自定义世界坐标，将其转换为本地 UI 坐标
                    rt.position = customWorldPos.Value;
                }
                else
                {
                    rt.anchoredPosition = new Vector2(offsetX, offsetY);
                }
                
                rt.localRotation = Quaternion.identity;
                // 确保 UI 特效的原始大小正确，且 localScale 为 1（继承 parent 的缩放）
                rt.sizeDelta = fxPrefab.GetComponent<RectTransform>().sizeDelta;
                rt.localScale = Vector3.one;
            }
            else
            {
                if (customWorldPos.HasValue)
                {
                    fx.transform.position = customWorldPos.Value;
                }
                else
                {
                    fx.transform.localPosition = offsetVector;
                }
                fx.transform.localRotation = Quaternion.identity;
                fx.transform.localScale = Vector3.one;
            }
        }
        else
        {
            Vector3 spawnPos = customWorldPos.HasValue ? customWorldPos.Value : (target.transform.position + offsetVector);
            fx = Instantiate(fxPrefab, spawnPos, Quaternion.identity);
            fx.transform.localScale = Vector3.one * fxScale;
        }

        // 针对粒子系统的特殊处理
        ParticleSystem[] allParticles = fx.GetComponentsInChildren<ParticleSystem>();
        foreach (var ps in allParticles)
        {
            var main = ps.main;
            // 强制修复缩放：设置 Scaling Mode 为 Hierarchy，使粒子大小跟随 Transform 缩放
            main.scalingMode = ParticleSystemScalingMode.Hierarchy;
        }

        // 应用透明度并处理渲染
        ApplyTransparencyAndRender(fx, transparency, isEnemy ? enemyFxSortingOrder : allyFxSortingOrder);

        if (allParticles.Length > 0)
        {
            foreach (var ps in allParticles)
            {
                // 确保粒子在生成时立即播放
                ps.Play(true);

                // 设置停止动作，如果是根节点粒子，设置自动销毁
                if (ps.gameObject == fx)
                {
                    var m = ps.main;
                    m.stopAction = ParticleSystemStopAction.Destroy;
                }
            }
        }
        else
        {
            // 如果不是粒子系统（例如动画 Prefab），在固定时间后销毁（默认 2 秒）
            Destroy(fx, 2.0f);
        }
    }

    /// <summary>
    /// 从发射源向目标发射一个拖尾特效
    /// </summary>
    /// <param name="source">发射源逻辑物体</param>
    /// <param name="target">目标逻辑物体</param>
    /// <param name="onComplete">到达终点后的回调（可选，返回弹道终点的世界坐标）</param>
    public void PlayProjectile(GameObject source, GameObject target, Action<Vector3> onComplete = null)
    {
        if (source == null || target == null || projectileFX == null)
        {
            if (projectileFX == null) Debug.LogWarning("[GfxController] projectileFX Prefab 未分配！");
            onComplete?.Invoke(target != null ? target.transform.position : Vector3.zero);
            return;
        }

        // --- 核心修正：将逻辑物体映射到 UI 挂载点 ---
        GameObject visualSource = ResolveGfxMountPoint(source);
        GameObject visualTarget = ResolveGfxMountPoint(target);

        // 如果映射失败，则退而求其次使用原始物体的 Transform
        Transform startTransform = visualSource != null ? visualSource.transform : source.transform;
        Transform endTransform = visualTarget != null ? visualTarget.transform : target.transform;

        // 在源物体位置实例化
        GameObject projectile = Instantiate(projectileFX, startTransform.position, Quaternion.identity);
        
        // --- 核心修正：挂载到 GfxController (即当前脚本所在的 Canvas 层级物体) ---
        projectile.transform.SetParent(this.transform, true);
        projectile.transform.localScale = Vector3.one * projectileScale;

        // 应用透明度
        ApplyTransparencyAndRender(projectile, projectileTransparency, projectileSortingOrder);

        // 应用颜色
        ApplyColorToEffect(projectile, projectileColor);

        // 启动移动协程
        Vector3 targetRandomOffset = Vector3.zero;
        if (projectileRandomOffsetX > 0f || projectileRandomOffsetY > 0f || projectileRandomOffsetZ > 0f)
        {
            targetRandomOffset = new Vector3(
                Random.Range(-projectileRandomOffsetX, projectileRandomOffsetX),
                Random.Range(-projectileRandomOffsetY, projectileRandomOffsetY),
                Random.Range(-projectileRandomOffsetZ, projectileRandomOffsetZ)
            );
        }

        StartCoroutine(MoveProjectileCoroutine(projectile, startTransform, endTransform, targetRandomOffset, onComplete));
    }

    /// <summary>
    /// 触发友军技能弹道：从施法者飞向目标友军
    /// </summary>
    public void PlayAllySkillProjectile(GameObject source, GameObject target, Action<Vector3> onComplete = null)
    {
        if (source == null || target == null) return;

        // --- Check if the source or target ally slot is active before playing VFX ---
        if (teamUIController.Instance != null)
        {
            // Check source
            var sourceAlly = source.GetComponent<AllyCombatant>();
            if (sourceAlly != null)
            {
                bool isActive = false;
                switch (sourceAlly.slotIndex)
                {
                    case 0: isActive = teamUIController.Instance.isAlly01_active; break;
                    case 1: isActive = teamUIController.Instance.isAlly02_active; break;
                    case 2: isActive = teamUIController.Instance.isAlly03_active; break;
                    case 3: isActive = teamUIController.Instance.isAlly04_active; break;
                    case 4: isActive = teamUIController.Instance.isAlly05_active; break;
                }
                if (!isActive) { onComplete?.Invoke(target.transform.position); return; }
            }

            // Check target
            var targetAlly = target.GetComponent<AllyCombatant>();
            if (targetAlly != null)
            {
                bool isActive = false;
                switch (targetAlly.slotIndex)
                {
                    case 0: isActive = teamUIController.Instance.isAlly01_active; break;
                    case 1: isActive = teamUIController.Instance.isAlly02_active; break;
                    case 2: isActive = teamUIController.Instance.isAlly03_active; break;
                    case 3: isActive = teamUIController.Instance.isAlly04_active; break;
                    case 4: isActive = teamUIController.Instance.isAlly05_active; break;
                }
                if (!isActive) { onComplete?.Invoke(target.transform.position); return; }
            }
        }

        GameObject prefab = allySkillProjectilePrefab != null ? allySkillProjectilePrefab : projectileFX;
        if (prefab == null)
        {
            Debug.LogWarning("[GfxController] allySkillProjectilePrefab 未分配且无默认 projectileFX！");
            onComplete?.Invoke(target.transform.position);
            return;
        }

        // 核心修正：将逻辑物体映射到 UI 挂载点
        GameObject visualSource = ResolveGfxMountPoint(source);
        GameObject visualTarget = ResolveGfxMountPoint(target);

        Transform startTransform = visualSource != null ? visualSource.transform : source.transform;
        Transform endTransform = visualTarget != null ? visualTarget.transform : target.transform;

        GameObject projectile = Instantiate(prefab, startTransform.position, Quaternion.identity);
        projectile.transform.SetParent(this.transform, true);
        projectile.transform.localScale = Vector3.one * allySkillProjectileScale;

        // 应用层级（复用 projectileTransparency）
        ApplyTransparencyAndRender(projectile, projectileTransparency, allySkillProjectileSortingOrder);

        // 应用颜色
        ApplyColorToEffect(projectile, allySkillProjectileColor);

        // 计算随机偏移
        Vector3 targetRandomOffset = Vector3.zero;
        if (allySkillRandomOffsetX > 0f || allySkillRandomOffsetY > 0f || allySkillRandomOffsetZ > 0f)
        {
            targetRandomOffset = new Vector3(
                UnityEngine.Random.Range(-allySkillRandomOffsetX, allySkillRandomOffsetX),
                UnityEngine.Random.Range(-allySkillRandomOffsetY, allySkillRandomOffsetY),
                UnityEngine.Random.Range(-allySkillRandomOffsetZ, allySkillRandomOffsetZ)
            );
        }

        StartCoroutine(MoveAllySkillProjectileCoroutine(projectile, startTransform, endTransform, targetRandomOffset, onComplete));
    }

    /// <summary>
    /// 将逻辑战斗物体（Ally/Enemy）映射到 GfxController 中定义的 UI 挂载点
    /// </summary>
    private GameObject ResolveGfxMountPoint(GameObject logicObj)
    {
        if (logicObj == null) return null;

        // 检查是否是敌人
        if (logicObj.name == "thisEnemy" || logicObj.GetComponent<EnemyCombatant>() != null)
        {
            return enemyObject;
        }

        // 检查是否是盟友 (ally_01 到 ally_05)
        var ally = logicObj.GetComponent<AllyCombatant>();
        if (ally != null)
        {
            return GetAllyObject(ally.slotIndex);
        }

        // 如果名字符合模式也可以识别
        string name = logicObj.name.ToLower();
        if (name.Contains("ally_01")) return ally01Object;
        if (name.Contains("ally_02")) return ally02Object;
        if (name.Contains("ally_03")) return ally03Object;
        if (name.Contains("ally_04")) return ally04Object;
        if (name.Contains("ally_05")) return ally05Object;

        return null;
    }

    private IEnumerator MoveProjectileCoroutine(GameObject projectile, Transform start, Transform end, Vector3 targetOffset, Action<Vector3> onComplete)
    {
        float elapsed = 0f;
        Vector3 startPos = start.position;
        Vector3 lastEndPos = startPos;

        while (elapsed < projectileDuration)
        {
            if (projectile == null)
            {
                onComplete?.Invoke(lastEndPos);
                yield break;
            }
            
            elapsed += Time.deltaTime;
            float normalizedTime = Mathf.Clamp01(elapsed / projectileDuration);
            
            // 使用动画曲线计算插值比例
            float t = projectileSpeedCurve.Evaluate(normalizedTime);
            
            // 如果目标还在，更新目标位置（支持动态移动的目标）
            Vector3 currentEndPos = end != null ? end.position + targetOffset : projectile.transform.position;
            lastEndPos = currentEndPos;
            
            projectile.transform.position = Vector3.Lerp(startPos, currentEndPos, t);
            
            // 可选：让拖尾朝向移动方向
            if (t > 0)
            {
                Vector3 direction = currentEndPos - startPos;
                if (direction != Vector3.zero)
                {
                    projectile.transform.rotation = Quaternion.LookRotation(Vector3.forward, direction);
                }
            }

            yield return null;
        }

        // 到达终点，触发回调并传回终点坐标
        onComplete?.Invoke(lastEndPos);

        // 到达后销毁
        if (projectile != null)
        {
            // 如果有粒子系统，先停止发射让残余拖尾自然消失，或者直接销毁
            ParticleSystem[] ps = projectile.GetComponentsInChildren<ParticleSystem>();
            if (ps.Length > 0)
            {
                foreach (var p in ps) p.Stop(true, ParticleSystemStopBehavior.StopEmitting);
                Destroy(projectile, 1.0f); // 给一点时间让残余粒子消失
            }
            else
            {
                Destroy(projectile);
            }
        }
    }

    private IEnumerator MoveAllySkillProjectileCoroutine(GameObject projectile, Transform start, Transform end, Vector3 targetOffset, Action<Vector3> onComplete)
    {
        float elapsed = 0f;
        Vector3 startPos = start.position;
        Vector3 lastEndPos = startPos;

        while (elapsed < allySkillProjectileDuration)
        {
            if (projectile == null)
            {
                onComplete?.Invoke(lastEndPos);
                yield break;
            }
            
            elapsed += Time.deltaTime;
            float normalizedTime = Mathf.Clamp01(elapsed / allySkillProjectileDuration);
            
            // 使用动画曲线计算插值比例
            float t = allySkillSpeedCurve.Evaluate(normalizedTime);
            
            // 如果目标还在，更新目标位置（支持动态移动的目标）
            Vector3 currentEndPos = end != null ? end.position + targetOffset : projectile.transform.position;
            lastEndPos = currentEndPos;
            
            projectile.transform.position = Vector3.Lerp(startPos, currentEndPos, t);
            
            // 可选：让拖尾朝向移动方向
            if (t > 0)
            {
                Vector3 direction = currentEndPos - startPos;
                if (direction != Vector3.zero)
                {
                    projectile.transform.rotation = Quaternion.LookRotation(Vector3.forward, direction);
                }
            }

            yield return null;
        }

        // 到达终点，触发回调并传回终点坐标
        onComplete?.Invoke(lastEndPos);

        // 到达后销毁
        if (projectile != null)
        {
            ParticleSystem[] ps = projectile.GetComponentsInChildren<ParticleSystem>();
            if (ps.Length > 0)
            {
                foreach (var p in ps) p.Stop(true, ParticleSystemStopBehavior.StopEmitting);
                Destroy(projectile, 1.0f); // 给一点时间让残余粒子消失
            }
            else
            {
                Destroy(projectile);
            }
        }
    }

    /// <summary>
    /// 为特效物体及其子物体中的 TrailRenderer 和 ParticleSystem 应用颜色渐变
    /// </summary>
    private void ApplyColorToEffect(GameObject effectObj, Gradient gradient)
    {
        if (effectObj == null || gradient == null) return;

        // 检查 Gradient 是否有效（至少有一个 alpha key 或 color key 且不全是透明）
        // 如果用户没有设置颜色，则保持原样
        if (gradient.colorKeys.Length <= 1 && gradient.alphaKeys.Length <= 1 && 
            gradient.colorKeys[0].color == Color.white && gradient.alphaKeys[0].alpha == 0)
        {
             // 简单的空检查，如果 Gradient 看起来是默认未设置状态则跳过
             // 注意：Unity 默认 Gradient 通常是全白不透明，这里可以根据需要调整判断
        }

        // 应用于 TrailRenderer
        var trails = effectObj.GetComponentsInChildren<TrailRenderer>(true);
        foreach (var trail in trails)
        {
            trail.colorGradient = gradient;
        }

        // 应用于 ParticleSystem (主要影响起始颜色)
        var particles = effectObj.GetComponentsInChildren<ParticleSystem>(true);
        foreach (var ps in particles)
        {
            var main = ps.main;
            main.startColor = new ParticleSystem.MinMaxGradient(gradient);
        }
    }

    /// <summary>
    /// 为特效物体及其子物体中的渲染器应用透明度和层级
    /// </summary>
    private void ApplyTransparencyAndRender(GameObject fx, float transparency, int sortingOrder)
    {
        // 1. 处理所有普通渲染器 (MeshRenderer, SpriteRenderer 等)
        Renderer[] renderers = fx.GetComponentsInChildren<Renderer>();
        foreach (var r in renderers)
        {
            // 设置排序层级
            r.sortingOrder = sortingOrder;

            // 处理材质透明度：用 MaterialPropertyBlock 覆写 alpha，避免访问 r.materials
            // 触发材质实例化（每次命中都会克隆并泄漏材质，产生 GC）。视觉结果等价。
            if (transparency < 1f)
            {
                var sharedMat = r.sharedMaterial;
                if (sharedMat != null)
                {
                    if (_fxPropertyBlock == null) _fxPropertyBlock = new MaterialPropertyBlock();
                    r.GetPropertyBlock(_fxPropertyBlock);
                    if (sharedMat.HasProperty("_Color"))
                    {
                        Color c = sharedMat.color;
                        c.a *= transparency;
                        _fxPropertyBlock.SetColor("_Color", c);
                    }
                    else if (sharedMat.HasProperty("_BaseColor")) // URP 命名
                    {
                        Color c = sharedMat.GetColor("_BaseColor");
                        c.a *= transparency;
                        _fxPropertyBlock.SetColor("_BaseColor", c);
                    }
                    r.SetPropertyBlock(_fxPropertyBlock);
                }
            }
        }

        // 2. 处理粒子系统颜色 (考虑不同模式)
        ParticleSystem[] particles = fx.GetComponentsInChildren<ParticleSystem>();
        foreach (var ps in particles)
        {
            var main = ps.main;
            
            // 处理 Start Color
            var startColor = main.startColor;
            if (startColor.mode == ParticleSystemGradientMode.Color)
            {
                Color c = startColor.color;
                c.a *= transparency;
                main.startColor = c;
            }
            else if (startColor.mode == ParticleSystemGradientMode.TwoColors)
            {
                Color c1 = startColor.colorMin;
                Color c2 = startColor.colorMax;
                c1.a *= transparency;
                c2.a *= transparency;
                main.startColor = new ParticleSystem.MinMaxGradient(c1, c2);
            }
        }

        // 3. 处理 TrailRenderer (拖尾特效的核心组件)
        TrailRenderer[] trails = fx.GetComponentsInChildren<TrailRenderer>();
        foreach (var trail in trails)
        {
            if (transparency < 1f)
            {
                Gradient gradient = trail.colorGradient;
                GradientAlphaKey[] alphaKeys = gradient.alphaKeys;
                for (int i = 0; i < alphaKeys.Length; i++)
                {
                    alphaKeys[i].alpha *= transparency;
                }
                gradient.SetKeys(gradient.colorKeys, alphaKeys);
                trail.colorGradient = gradient;
            }
        }
    }

    public void PlayKOFX(GameObject target)
    {
        if (target == null || k_o_fx == null)
        {
            if (k_o_fx == null) Debug.LogWarning("[GfxController] k_o_fx Prefab 未分配！");
            return;
        }

        GameObject fx;
        
        // 优先使用指定的 KO 父物体
        if (koFatherObject != null)
        {
            // 控制父物体的缩放
            koFatherObject.transform.localScale = Vector3.one * koFxScale;
            
            fx = Instantiate(k_o_fx, koFatherObject.transform);
            
            RectTransform rt = fx.GetComponent<RectTransform>();
            if (rt != null)
            {
                rt.anchoredPosition = Vector2.zero;
                rt.localRotation = Quaternion.identity;
                rt.localScale = Vector3.one; // 预设物体缩放回归 1，由父物体控制
            }
            else
            {
                fx.transform.localPosition = Vector3.zero;
                fx.transform.localRotation = Quaternion.identity;
                fx.transform.localScale = Vector3.one;
            }
        }
        else
        {
            // 备份逻辑：映射到 UI 挂载点
            GameObject visualParent = ResolveGfxMountPoint(target);
            
            if (visualParent != null)
            {
                fx = Instantiate(k_o_fx, visualParent.transform);
                fx.transform.SetAsLastSibling();
                
                RectTransform rt = fx.GetComponent<RectTransform>();
                if (rt != null)
                {
                    rt.anchoredPosition = Vector2.zero;
                    rt.localRotation = Quaternion.identity;
                    rt.localScale = Vector3.one * koFxScale;
                }
                else
                {
                    fx.transform.localPosition = Vector3.zero;
                    fx.transform.localRotation = Quaternion.identity;
                    fx.transform.localScale = Vector3.one * koFxScale;
                }
            }
            else
            {
                fx = Instantiate(k_o_fx, target.transform.position, Quaternion.identity);
                fx.transform.localScale = Vector3.one * koFxScale;
            }
        }

        // 应用层级 Order In Layer
        Renderer[] renderers = fx.GetComponentsInChildren<Renderer>(true);
        foreach (var r in renderers)
        {
            r.sortingOrder = koFxSortingOrder;
        }
        Canvas[] canvases = fx.GetComponentsInChildren<Canvas>(true);
        foreach (var c in canvases)
        {
            c.sortingOrder = koFxSortingOrder;
        }

        // 动画播放完后销毁
        Destroy(fx, 3.0f);
    }

    /// <summary>
    /// 当 Miss 发生时，从敌人向指定角色发射弹道，并在到达时触发受击效果及实际扣血
    /// </summary>
    /// <returns>是否成功启动弹道逻辑。如果返回 false，调用方应执行保底扣血。</returns>
    public bool PlayEnemyAttackOnMiss(int allySlotIndex, float damageAmount, AllyCombatant allyInstance)
    { 
        if (enemyObject == null || !enemyObject.activeInHierarchy) 
        {
            Debug.LogWarning("[GfxController] enemyObject 为空或未激活，无法播放 Miss 攻击特效。");
            return false;
        }

        // --- Check if the target ally slot is active before playing VFX ---
        if (teamUIController.Instance != null)
        {
            bool isActive = false;
            switch (allySlotIndex)
            {
                case 0: isActive = teamUIController.Instance.isAlly01_active; break;
                case 1: isActive = teamUIController.Instance.isAlly02_active; break;
                case 2: isActive = teamUIController.Instance.isAlly03_active; break;
                case 3: isActive = teamUIController.Instance.isAlly04_active; break;
                case 4: isActive = teamUIController.Instance.isAlly05_active; break;
            }
            if (!isActive)
            {
                // If inactive, skip VFX and return false so SkillBuilder applies immediate (but blocked) damage
                return false; 
            }
        }

        GameObject targetAllyObj = GetAllyObject(allySlotIndex);
        if (targetAllyObj == null) 
        {
            Debug.LogWarning($"[GfxController] 找不到槽位 {allySlotIndex} 的盟友物体。");
            return false;
        }

        GameObject projectilePrefab = enemyMissProjectilePrefab != null ? enemyMissProjectilePrefab : projectileFX;
        if (projectilePrefab == null) 
        {
            Debug.LogWarning("[GfxController] 未分配任何弹道 Prefab。");
            return false;
        }

        // 生成弹道
        GameObject projectile = Instantiate(projectilePrefab, enemyObject.transform.position, Quaternion.identity);
        projectile.transform.SetParent(enemyObject.transform, true);
        projectile.transform.localScale = Vector3.one * enemyAttackProjectileScale;

        // 应用层级
        ApplyTransparencyAndRender(projectile, projectileTransparency, enemyAttackProjectileSortingOrder);

        // 应用颜色
        ApplyColorToEffect(projectile, enemyAttackProjectileColor);

        // 启动移动协程
        StartCoroutine(MoveEnemyAttackProjectileCoroutine(projectile, enemyObject.transform, targetAllyObj.transform, allySlotIndex, damageAmount, allyInstance));
        return true;
    }

    private IEnumerator MoveEnemyAttackProjectileCoroutine(GameObject projectile, Transform start, Transform end, int allySlotIndex, float damageAmount, AllyCombatant allyInstance)
    { 
        float elapsed = 0f;
        Vector3 startPos = start.position;
        Vector3 lastEndPos = startPos;

        while (elapsed < enemyAttackProjectileDuration)
        { 
            if (projectile == null) yield break;
            
            elapsed += Time.deltaTime;
            float normalizedTime = Mathf.Clamp01(elapsed / enemyAttackProjectileDuration);
            float t = enemyAttackSpeedCurve.Evaluate(normalizedTime);
            
            Vector3 currentEndPos = end != null ? end.position : lastEndPos;
            lastEndPos = currentEndPos;
            
            projectile.transform.position = Vector3.Lerp(startPos, currentEndPos, t);

            // 朝向目标
            Vector3 direction = currentEndPos - projectile.transform.position;
            if (direction != Vector3.zero)
            { 
                projectile.transform.rotation = Quaternion.LookRotation(Vector3.forward, direction);
            }

            yield return null;
        }

        // 到达终点
        if (projectile != null)
        { 
            // 停止粒子系统
            ParticleSystem[] ps = projectile.GetComponentsInChildren<ParticleSystem>();
            foreach (var p in ps) { var m = p.main; m.loop = false; }
            Destroy(projectile, 0.5f);
        }

        // 播放 Hit 特效、闪红，并执行实际扣血
        GameObject targetAllyObj = GetAllyObject(allySlotIndex);
        if (targetAllyObj != null)
        { 
            // 1. 播放 Hit FX 并触发闪红（PlayHitFX 内部已处理闪红）
            PlayHitFX(targetAllyObj, null, false, lastEndPos, enemyAttackHitFxScale);
            
            // 2. 执行实际扣血逻辑 (使用传入的实例，更准确)
            if (allyInstance != null)
            {
                allyInstance.ReceiveDamage(damageAmount, null);
            }
            else
            {
                // 备选方案：尝试从物体获取
                var ally = targetAllyObj.GetComponent<AllyCombatant>();
                if (ally != null) ally.ReceiveDamage(damageAmount, null);
            }
        }
    }

    /// <summary>
    /// 根据槽位索引获取盟友特效挂载点
    /// </summary>
    public GameObject GetAllyObject(int slotIndex)
    {
        switch (slotIndex)
        {
            case 0: return ally01Object;
            case 1: return ally02Object;
            case 2: return ally03Object;
            case 3: return ally04Object;
            case 4: return ally05Object;
            default: return null;
        }
    }

    /// <summary>
    /// 获取盟友/敌人的移动父物体（用于震动）
    /// </summary>
    public GameObject GetMoveObject(GameObject targetObj)
    {
        if (targetObj == null) return null;

        // 1. 检查是否是敌人（逻辑物体或受击挂载点）
        if (targetObj.name == "thisEnemy" || 
            targetObj == enemyObject || 
            targetObj.GetComponent<EnemyCombatant>() != null)
        {
            return enemyMoveObject;
        }

        // 2. 检查是否是盟友逻辑物体
        var ally = targetObj.GetComponent<AllyCombatant>();
        if (ally != null)
        {
            return GetAllyMoveObject(ally.slotIndex);
        }

        // 3. 检查是否是盟友受击挂载点 (ally01Object - ally05Object)
        if (targetObj == ally01Object) return ally01MoveObject;
        if (targetObj == ally02Object) return ally02MoveObject;
        if (targetObj == ally03Object) return ally03MoveObject;
        if (targetObj == ally04Object) return ally04MoveObject;
        if (targetObj == ally05Object) return ally05MoveObject;

        // 4. 通过名称模式兜底识别
        string n = targetObj.name.ToLower();
        if (n.Contains("ally_01") || n.Contains("ally01")) return ally01MoveObject;
        if (n.Contains("ally_02") || n.Contains("ally02")) return ally02MoveObject;
        if (n.Contains("ally_03") || n.Contains("ally03")) return ally03MoveObject;
        if (n.Contains("ally_04") || n.Contains("ally04")) return ally04MoveObject;
        if (n.Contains("ally_05") || n.Contains("ally05")) return ally05MoveObject;

        return null;
    }

    private GameObject GetAllyMoveObject(int slotIndex)
    {
        switch (slotIndex)
        {
            case 0: return ally01MoveObject;
            case 1: return ally02MoveObject;
            case 2: return ally03MoveObject;
            case 3: return ally04MoveObject;
            case 4: return ally05MoveObject;
            default: return null;
        }
    }

    /// <summary>
    /// 触发指定目标的震动效果
    /// </summary>
    private void TriggerShake(GameObject target, bool isEnemy)
    {
        GameObject moveObj = GetMoveObject(target);
        if (moveObj == null) return;

        SmoothShake ss = moveObj.GetComponent<SmoothShake>();
        if (ss == null) ss = moveObj.AddComponent<SmoothShake>();

        // 修复：确保 Shaker 实例已初始化，避免 NullReferenceException
        if (ss.positionShake == null) ss.positionShake = new Shaker();
        if (ss.rotationShake == null) ss.rotationShake = new Shaker();

        // 选择震动参数
        Vector3 amplitude = isEnemy ? hitShakeAmplitude : allyHitShakeAmplitude;
        Vector3 frequency = isEnemy ? hitShakeFrequency : allyHitShakeFrequency;
        float duration = isEnemy ? hitShakeDuration : allyHitShakeDuration;
        if (isEnemy && teamUIController.Instance != null)
        {
            teamUIController.Instance.TriggerEnemySpineShake(amplitude, frequency, duration);
        }
        if (isEnemy) amplitude *= 0.5f;

        // 配置震动参数
        ss.positionShake.noiseType = Shaker.NoiseType.SineWave;
        ss.positionShake.amplitude = amplitude;
        ss.positionShake.frequency = frequency;
        
        // 旋转震动重置为0，防止干扰
        ss.rotationShake.amplitude = Vector3.zero;
        
        // 配置时间参数
        ss.timeSettings.constantShake = false;
        ss.timeSettings.fadeInDuration = 0.05f;
        ss.timeSettings.holdDuration = duration * 0.4f;
        ss.timeSettings.fadeOutDuration = duration * 0.55f;
        
        // 确保动画曲线有值（否则震动无法淡出）
        if (ss.timeSettings.fadeInCurve == null || ss.timeSettings.fadeInCurve.length == 0)
            ss.timeSettings.fadeInCurve = AnimationCurve.Linear(0, 0, 1, 1);
        if (ss.timeSettings.fadeOutCurve == null || ss.timeSettings.fadeOutCurve.length == 0)
            ss.timeSettings.fadeOutCurve = AnimationCurve.Linear(0, 1, 1, 0);

        // 初始化内部数组（插件在 AddComponent 时 Awake 已经运行，由于当时字段为空，需要重新同步数组）
        ss.shakers = new Shaker[] { ss.positionShake, ss.rotationShake };
        ss.sum = new Vector3[2];
        
        // 启动震动
        ss.StartShake();
    }
}