using System;
using System.Threading.Tasks;
using asap.core;
using Game;
using TMPro;
using UI.PartnerGather.Mining;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.UI;
using Quaternion = UnityEngine.Quaternion;
using Vector3 = UnityEngine.Vector3;


namespace EventPartnerGather.Mining
{
    /// <summary>
    /// 事件合作伙伴挖矿角色控制器
    /// 控制角色的移动、动画播放、挖矿行为等
    /// 
    /// 建议挂载在：角色模型的根对象上
    /// 需要组件：CharacterController（必须）
    /// 
    /// 场景结构建议：
    /// Character (挂载此脚本 + CharacterController)
    /// ├── Model (角色模型)
    /// │   └── Animator (动画控制器)
    /// └── Body (可选的身体Transform，用于旋转控制)
    /// </summary>
    [RequireComponent(typeof(CharacterController))]
    public class EventPartnerMiningCharacterController : MonoBehaviour
    {
    private const bool EnableTraceLogs = false;
        private static readonly int BasicMove = Animator.StringToHash("_basicMove");
        private static readonly int BackToIdle = Animator.StringToHash("_backToIdle");
        private static readonly int ToBasic = Animator.StringToHash("_toBasic");
        private static readonly int BasicGathering = Animator.StringToHash("_basicGathering");
        private static readonly int ToAdvance = Animator.StringToHash("_toAdvance");
        private static readonly int ToMaster = Animator.StringToHash("_toMaster");
        private static readonly int ShowType = Animator.StringToHash("_showType");
        private static readonly int Celebrate = Animator.StringToHash("_celebrate");
        // private static readonly int Advancedmove = Animator.StringToHash("_advancedmove");
        private static readonly int MasterMove = Animator.StringToHash("_masterMove");
        private static readonly int AdvancedGathering = Animator.StringToHash("_advancedGathering");
        private static readonly int MasterGathering = Animator.StringToHash("_masterGathering");
        private static readonly int AdvancedMove = Animator.StringToHash("_advancedMove");
        private static readonly int EndIdle = Animator.StringToHash("_endIdle");
        private static readonly int IsGathering = Animator.StringToHash("_isGathering");
        // 0 Idle 1 Move 2 Gathering 3 Celebrate
        
        private static readonly int CurrentStatus = Animator.StringToHash("_currentStatus");
        public Vector3 LastTargetPosition { get;set ;}
        

        [Header("组件引用")] public Animator animator;
        public Transform body;
        public CharacterController characterController;
        
        // [Tooltip("用户落点偏移")]
        // [Range(-10f, 10f)] public List<float> userPointDelta = new();
        
        // // 设置一下，以后修改
        // [SerializeField]
        // private float columnDistance = 1.0f;
        
        [Header("移动配置")]
        public float moveSpeed = 2f;
        public float idleThreshold = 0.05f;
        public float rotationSpeed = 5f;

        [Tooltip("跟随速度")]
        public float followSpeed = 3f;

        [Header("模型配置")] [Tooltip("是否平滑旋转")] 
        public bool smoothRotation = true;

        
        [Tooltip("旋转动画持续时间")]
        [Range(0.1f, 1f)]
        public float rotationDuration = 0.2f;

        [Header("调试配置")] public bool showDebugInfo = true;
        public bool showMovementPath = true;
        public Color targetPointColor = Color.red;
        public Color pathColor = Color.yellow;
        public Color directionColor = Color.green;

        [Header("动画参数")] 
        public string runAnimParam = "run";
        public string mineAnimParam = "mine";
        public string idleAnimParam = "idle";


        [Header("头像")] 
        public Transform headUI;
        
        // 头像跟随
        [Header("Bone")] 
        public Transform targetBone;
        public bool useSmoothing = true;
        public float smoothingSpeed = 10f;
    
        [Header("呼吸效果")]
        public bool enableBreathing = true;
        public float breathingAmplitude = 0.02f;
        public float breathingFrequency = 1.2f;
        public AnimationCurve breathingCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);

        [Header("变身特效")] 
        
        public Transform _fx_advancedToBasic;
        public Transform _fx_basicToAdvanced;
        public Transform _fx_advancedGather;
        public Transform _fx_basicGather;
        public Transform _fx_masterGather;
        public Transform _fx_basicToMaster;
        public Transform _fx_masterToBasic;
        
        
        
        // 计算标准的变量
        // 标准位置
        [HideInInspector]
        public  int step = -1;
        //
        [HideInInspector]
        public  int col = -1 ;
        
        
        //
        // public Vector3 localOffset = new Vector3(0, 2f, 0);

        private Vector3 localOffset;

        private float localOffsetY;
        
        private Vector3 velocity;
        private Vector3 previousBonePosition;
        private Vector3 currentOffset;
        private float breathingTime;
        
        
        
        private string basicAniParam = "basic";
        private string advanceAniAnim = "advance";
        private string masterAniAnim = "master";
        
        // 用户积分
        private TMP_Text _textNum;
        private TMP_Text _textName;
        
        
        // 调试信息
        private Vector3 _debugTargetPosition;
        private Vector3 _debugStartPosition;
        private bool _isMoving = false;
        private Vector3 _debugMoveDirection;
        
        // 采集次数
        private int _gatherNum; 
        public int GatherNumPerDuration { get; set; } = 3;
        
        
        public bool IsMainCharacter { get; set; } = false;
        //Task
        private TaskCompletionSource<bool> _playMiningTcs;
        private TaskCompletionSource<bool> _changeShowTypeTask;
        private TaskCompletionSource<bool> _idleSpecialTask;
        private TaskCompletionSource<bool> _playCelebrateTcs;
        
        
        private int idleStateHash;
        private int basicMoveHash;
        // private int advancedMoveHash;
        private int MasterMoveHash;
        private int BasicGatheringHash;
        private int BasicRunningHash;
        private int BasicToAdvancedHash;
        private int AdvancedRunningHash;
        private int AdvancedToBasicHash;
        private int AdvancedGatheringHash;
        private int AdvancedIdleHash;
        private int BasicToMasterHash;
        private int MasterRunningHash;
        private int MasterToBasicHash;
        private int MasterGatheringHash;
        private int MasterIdleHash;
        
        
        private AudioClip audioBasic;
        private AudioClip audioAdvanced;
        private AudioClip audioMaster;
        private Sound soundMove;
        
        
        private void Awake()
        {
            if (!characterController)
                characterController = GetComponent<CharacterController>();
            if (!body) 
                body = transform.Find("body");
            _textNum = transform.Find("ui/myself/myself/head/text_num").GetComponent<TMP_Text>();
            //
            _textName = transform.Find("ui/myself/myself/head/btn_head/text_name").GetComponent<TMP_Text>();
            
            idleStateHash = Animator.StringToHash("Base Layer.Idle");
            basicMoveHash = Animator.StringToHash("Base Layer.BasicMove");
            MasterMoveHash = Animator.StringToHash("Base Layer.MasterMove");
            BasicGatheringHash =  Animator.StringToHash("Base Layer.BasicMove.BasicGathering");
            BasicRunningHash = Animator.StringToHash("Base Layer.BasicMove.BasicRunning");
            BasicToAdvancedHash = Animator.StringToHash("Base Layer.AdvancedMove.BasicToAdvanced");
            AdvancedRunningHash = Animator.StringToHash("Base Layer.AdvancedMove.AdvancedRunning");
            AdvancedToBasicHash = Animator.StringToHash("Base Layer.AdvancedMove.AdvancedToBasic");
            AdvancedGatheringHash = Animator.StringToHash("Base Layer.AdvancedMove.AdvancedGathering");
            AdvancedIdleHash = Animator.StringToHash("Base Layer.AdvancedMove.AdvancedIdle");
            BasicToMasterHash = Animator.StringToHash("Base Layer.MasterMove.BasicToMaster");
            MasterRunningHash = Animator.StringToHash("Base Layer.MasterMove.MasterRunning");
            MasterToBasicHash = Animator.StringToHash("Base Layer.MasterMove.MasterToBasic");
            MasterGatheringHash = Animator.StringToHash("Base Layer.MasterMove.MasterGathering");
            MasterIdleHash = Animator.StringToHash("Base Layer.MasterMove.MasterIdle");
            
            LoadAudio();

        }

        private async void LoadAudio()
        {
            audioBasic = await Addressables.LoadAssetAsync<AudioClip>("audio_ui_partnermining_npc_basicrun").Task;
            audioAdvanced = await Addressables.LoadAssetAsync<AudioClip>("audio_ui_partnermining_npc_advancedrun").Task;
            audioMaster = await Addressables.LoadAssetAsync<AudioClip>("audio_ui_partnermining_npc_masterrun").Task;
        }
        void AudioRelease()
        {
            Addressables.Release(audioBasic);
            Addressables.Release(audioAdvanced);
            Addressables.Release(audioMaster);
        }
        
        
        private void Start()
        {
            if (animator)
            {
                animator.GetComponent<CharacterAnimationReceiver>()?.SetCharacterController(this);
            }
            SetSpinPointText(0);
            
            localOffset = new Vector3(headUI.position.x - targetBone.position.x , headUI.position.y - targetBone.position.y, 0);

            localOffsetY = headUI.position.y - targetBone.position.y;
        }

        private void Update()
        {
            
        }

        private void OnDestroy()
        {
            StopMoveAudio();
            AudioRelease();
        }
        
        void StopMoveAudio()
        {
            if (soundMove)
            {
                soundMove.audioSource.Stop();
                soundMove.ReturnPool();
                soundMove = null;
            }
        }

        private void LateUpdate()
        {
            // throw new NotImplementedException();
            if (!targetBone) return;
            UpdateBreathingEffect();
            UpdateFollowPosition();
        }

        private void UpdateBreathingEffect()
        {
            if (!enableBreathing) return;
        
            breathingTime += Time.deltaTime * breathingFrequency;
        
            // 使用动画曲线获得更自然的呼吸
            var breathingValue = breathingCurve.Evaluate((Mathf.Sin(breathingTime) + 1) * 0.5f);
        
            // 应用呼吸偏移
            var breathingOffset = Vector3.up * (breathingValue * breathingAmplitude);
            currentOffset = localOffset + breathingOffset;
            
            // localOffsetY
        }

        private void UpdateFollowPosition()
        {

            // var targetPosition = targetBone.position + currentOffset;// targetBone.TransformDirection(currentOffset);
            
            var newPosition = new Vector3(headUI.position.x, targetBone.position.y + localOffsetY, headUI.position.z);
        
            // // 预测性跟随
            // if (predictiveFollowing)
            // {
            //     var boneVelocity = (targetBone.position - previousBonePosition) / Time.deltaTime;
            //     targetPosition += boneVelocity * predictionStrength;
            // }
        
            // 平滑跟随
            if (useSmoothing)
            {
                headUI.position = Vector3.SmoothDamp( headUI.position, newPosition, ref velocity, 1f / smoothingSpeed );
            }
            else
            {
                headUI.position = newPosition;
            }
        
            previousBonePosition = targetBone.position;
            
        }

        private string GetStateName()
        {
            var stateInfo = animator.GetCurrentAnimatorStateInfo(0);
            var stateName = "NULL";
            // 检查当前状态
            if (stateInfo.fullPathHash  == idleStateHash)
            {
                // Log("当前状态: Idle");
                stateName = "Idle";
            }
            else if (stateInfo.fullPathHash  == BasicRunningHash)
            {
                // Log("当前状态: BasicRunning");
                stateName = "BasicRunning";
            }
            else if (stateInfo.fullPathHash  == BasicGatheringHash)
            {
                // Log("当前状态: BasicGathering");
                stateName = "BasicGathering";
            }
            else if (stateInfo.fullPathHash  == BasicToAdvancedHash)
            {
                // Log("当前状态: BasicToAdvanced");
                stateName = "BasicToAdvanced";
            }
            else if (stateInfo.fullPathHash  == AdvancedRunningHash)
            {
                // Log("当前状态: AdvancedRunning");
                stateName = "AdvancedRunning";
            }
            else if (stateInfo.fullPathHash  == AdvancedToBasicHash)
            {
                // Log("当前状态: AdvancedToBasicHash");
                stateName = "AdvancedToBasic";
            }
            else if (stateInfo.fullPathHash  == AdvancedGatheringHash)
            {
                // Log("当前状态: AdvancedGathering");
                stateName = "AdvancedGathering";
            }
            else if (stateInfo.fullPathHash == AdvancedIdleHash)
            {
                // Log("当前状态: AdvancedToBasicHash");
                stateName = "AdvancedIdleHash";
            }
            else if (stateInfo.fullPathHash  == BasicToMasterHash)
            {
                // Log("当前状态: BasicToMaster");
                stateName = "BasicToMaster";
            }
            else if (stateInfo.fullPathHash  == MasterRunningHash)
            {
                // Log("当前状态: MasterRunning");
                stateName = "MasterRunning";
            }
            else if (stateInfo.fullPathHash  == MasterGatheringHash)
            {
                // Log("当前状态: MasterGathering");
                stateName = "MasterGathering";
            }
            else if (stateInfo.fullPathHash == MasterIdleHash)
            {
                stateName = "MasterIdleHash";
            }
            return stateName;
        }
        private void OnDrawGizmos()
        {
            if (body != null && showDebugInfo)
            {
                // 绘制角色位置和朝向
                Gizmos.color = Color.green;
                Gizmos.DrawWireSphere(body.position, 0.5f);

                // 绘制前方向量（蓝色）
                Gizmos.color = Color.blue;
                Gizmos.DrawRay(body.position, body.forward * 2f);

                // 绘制右方向量（红色）
                Gizmos.color = Color.red;
                Gizmos.DrawRay(body.position, body.right * 1.5f);

                // 绘制上方向量（黄色，较短）
                Gizmos.color = Color.yellow;
                Gizmos.DrawRay(body.position, body.up * 1f);

                // === 新增：移动调试可视化 ===
                if (_isMoving)
                {
                    // 绘制目标点
                    Gizmos.color = targetPointColor;
                    Gizmos.DrawWireSphere(_debugTargetPosition, 0.8f);
                    Gizmos.DrawCube(_debugTargetPosition + Vector3.up * 0.5f, Vector3.one * 0.3f);

                    // 绘制起始点
                    Gizmos.color = Color.cyan;
                    Gizmos.DrawWireCube(_debugStartPosition, Vector3.one * 0.4f);

                    if (showMovementPath)
                    {
                        // 绘制移动路径线
                        Gizmos.color = pathColor;
                        Gizmos.DrawLine(_debugStartPosition, _debugTargetPosition);

                        // 绘制当前位置到目标的连线
                        Gizmos.color = Color.white;
                        Gizmos.DrawLine(body.position, _debugTargetPosition);

                        // 绘制移动方向箭头
                        Vector3 directionArrow = _debugMoveDirection * 3f;
                        Gizmos.color = directionColor;
                        Gizmos.DrawRay(body.position + Vector3.up * 0.2f, directionArrow);

                        // 绘制箭头头部
                        Vector3 arrowEnd = body.position + Vector3.up * 0.2f + directionArrow;
                        Vector3 arrowSide1 = Quaternion.Euler(0, 30, 0) * (-directionArrow.normalized * 0.5f);
                        Vector3 arrowSide2 = Quaternion.Euler(0, -30, 0) * (-directionArrow.normalized * 0.5f);
                        Gizmos.DrawLine(arrowEnd, arrowEnd + arrowSide1);
                        Gizmos.DrawLine(arrowEnd, arrowEnd + arrowSide2);
                    }
                }

                // 显示四个主要方向（运行时）
                if (Application.isPlaying)
                {
                    Gizmos.color = Color.cyan;
                    // 显示四个主要方向
                    Gizmos.DrawRay(body.position + Vector3.up * 0.1f, Vector3.forward * 0.8f); // 前
                    Gizmos.DrawRay(body.position + Vector3.up * 0.1f, Vector3.back * 0.8f); // 后
                    Gizmos.DrawRay(body.position + Vector3.up * 0.1f, Vector3.left * 0.8f); // 左
                    Gizmos.DrawRay(body.position + Vector3.up * 0.1f, Vector3.right * 0.8f); // 右
                }

                // 显示默认朝向（编辑器中）
                if (!Application.isPlaying)
                {
                    Gizmos.color = Color.magenta;
                    // Unity默认前方向量
                    Gizmos.DrawRay(body.position, Vector3.forward * 1.5f);
                }
            }

#if UNITY_EDITOR
            // 在编辑器中显示文字信息
            if (body != null && showDebugInfo)
            {
                UnityEditor.Handles.color = Color.white;
                string info = $"Current Rotation: {body.rotation.eulerAngles}\n";
                info += $"Forward: {body.forward.ToString("F2")}\n";
                info += $"Right: {body.right.ToString("F2")}";

                if (_isMoving)
                {
                    info += $"\n--- 移动调试 ---";
                    info += $"\n起点: {_debugStartPosition.ToString("F1")}";
                    info += $"\n目标: {_debugTargetPosition.ToString("F1")}";
                    info += $"\n当前: {body.position.ToString("F1")}";
                    info += $"\n方向: {_debugMoveDirection.ToString("F2")}";
                    float distance = Vector3.Distance(body.position, _debugTargetPosition);
                    info += $"\n剩余距离: {distance:F2}";
                }

                UnityEditor.Handles.Label(body.position + Vector3.up * 2f, info);
            }
#endif
        }
        
        public void SetPlayerName(string buildPartnerDisplayName)
        {
            _textName.text = buildPartnerDisplayName;
        }
        
        public void SetHeadImage(string headImageUrl)
        {
            var iconHead = headUI?.Find("myself/myself/head/btn_head/mask/icon_head");
            var image = iconHead?.GetComponent<Image>();
            GContext.container.Resolve<IUIService>().SetHeadImage(image, headImageUrl);
        }
        
        // 看逻辑没有清理，直接设置为0
        public void SetSpinPointText(int point)
        {
            _textNum.text = point.ToString();
        }
        
        /// <summary>
        /// 移动到指定的3D位置
        /// </summary>
        /// <param name="targetPosition">目标位置</param>
        /// <param name="speed">移动速度，0表示使用默认速度</param>
        public async Task MoveToPosition_Old(Vector3 targetPosition, float speed = 0f)
        {
            if (speed <= 0f) 
                speed = moveSpeed;
            var st  = animator.GetInteger(ShowType);
            Trace($"MoveToPositionStart target={targetPosition} showType={st}");
            if (false)
            {
                LastTargetPosition = targetPosition;
                // 设置调试信息
                _debugStartPosition = body.position;
                _debugTargetPosition = targetPosition;
            }

            _isMoving = true;
            
            var startPos = body.position;
            var direction = (targetPosition - startPos);

            // 忽略Y轴方向，只考虑水平面移动
            direction.y = 0f;
            _debugMoveDirection = direction.normalized;

            // float bodyForward = Mathf.Atan2(body.forward.x, body.forward.z) * Mathf.Rad2Deg;
            // 检查水平移动距离是否足够大
            if (direction.magnitude > 0.01f)
            {
                // Log($"开始移动: 从 {startPos} 到 {targetPosition}, 方向: {_debugMoveDirection}");
                // 设置角色朝向目标方向
                await SetCharacterDirectionVector(direction);
            }
            else
            {
                Trace($"MoveSkippedTooClose distance={direction.magnitude:F3}");
                _isMoving = false;
                return;
            }
            // return;
            // 开始移动动画
            SetAnimationState("moving");
            // 移动到目标位置            
            var bodyStandPosition = body.position;
            bodyStandPosition.y = targetPosition.y;
            while (Vector3.Distance(bodyStandPosition, targetPosition) > idleThreshold)
            {
                var moveDirection = (targetPosition - bodyStandPosition).normalized;
                moveDirection.y = 0f;
                _debugMoveDirection = moveDirection; // 更新当前移动方向
                Vector3 moveVector = moveDirection * speed * Time.deltaTime;
                if (characterController && characterController.enabled)
                {
                    moveVector.y = -9.81f * Time.deltaTime;
                    try
                    {
                        characterController.Move(moveVector);
                    }
                    catch (Exception e)
                    {
                    LogError($"CharacterMoveFailed error={e.Message}");
                        break;
                    }
                
                }
                else
                {
                    Vector3 newPos = transform.position + moveVector;
                    newPos.y = transform.position.y;
                    transform.position = newPos;
                }
                bodyStandPosition = body.position;
                bodyStandPosition.y = targetPosition.y;
                await Awaiters.NextFrame;
            }
            
            Vector3 finalPos = targetPosition;
            finalPos.y = transform.position.y;
            transform.position = finalPos;
            
            _ = SetCharacterDirectionVector(Vector3.right);
            Trace($"MoveToPositionComplete bodyPos={body.position} transformPos={transform.position}");
            _isMoving = false;
        }
        // 前进几列
        public async Task MoveCol(int column,Vector3 theUserPoint,float columnDistance, float speed = 0f)
        {
            Trace($"MoveColStart column={column} userPoint={theUserPoint} lastTarget={LastTargetPosition}");
            if (speed <= 0f) 
                speed = moveSpeed;
            if (column <= 0) return;
            var distance = theUserPoint.x  - LastTargetPosition.x ;
            if (distance < 0)
            {
                distance = 0;
            }
            // 这个是什么玩意儿。。
            LastTargetPosition = theUserPoint;
            // distance = 0;
            
            Trace($"MoveColResolved column={column} userPoint={theUserPoint} distance={distance} finalDistance={column * columnDistance + distance}");
            var targetPosition = new Vector3(body.position.x + column * columnDistance + distance, body.position.y, body.position.z);
            SetAnimationState("moving");
            var bodyStandPosition = body.position;
            while (Vector3.Distance(bodyStandPosition, targetPosition) > idleThreshold)
            {
                var moveDirection = (targetPosition - bodyStandPosition).normalized;
                moveDirection.y = 0f;
                // _debugMoveDirection = moveDirection; // 更新当前移动方向
                var moveVector = moveDirection * speed * Time.deltaTime;
                if (characterController && characterController.enabled)
                {
                    moveVector.y = -9.81f * Time.deltaTime;
                    characterController.Move(moveVector);
                }
                else
                {
                    var newPos = body.position + moveVector;
                    newPos.y = body.position.y;
                    body.position = newPos;
                }
                bodyStandPosition = body.position;
                bodyStandPosition.y = targetPosition.y;
                await Awaiters.NextFrame;
            }
        }
        
        public async Task MoveToPosition(Vector3 targetPosition, float speed = 0f, float maxDuration = 10f)
        {
            speed = speed > 0f ? speed : moveSpeed;

            var st = animator.GetInteger(ShowType);
            Trace($"MoveToPositionStart target={targetPosition} showType={st}");

            _isMoving = true;

            var startPos = body.position;
            
            
            var initialDir = Horizontal(targetPosition - startPos);
            if (initialDir.sqrMagnitude <= 0.0001f)
            {
                Trace($"MoveSkippedTooClose distance={initialDir.sqrMagnitude:F3}");
                _isMoving = false;
                return;
            }

            await SetCharacterDirectionVector(initialDir);
            SetAnimationState("moving");

            var startPosition = body.position;
            var bodyPos = body.position;
            float elapsed = 0f;

            while (!IsCloseHorizontally(bodyPos, targetPosition, idleThreshold))
            {
                elapsed += Time.deltaTime;
                if (elapsed > maxDuration)
                {
                    LogWarning($"MoveTimeout maxDurationSec={maxDuration}");
                    break;
                }

                // 計算當前水平移動方向
                var moveDir = Horizontal(targetPosition - bodyPos).normalized;
                _debugMoveDirection = moveDir;

                // 執行一步移動，並獲得實際水平位移量(用於檢測卡住/進度)
                var actualMove = DoMoveStep(moveDir, speed);
                bodyPos = body.position;

                if (IsStuck(actualMove, bodyPos, targetPosition, idleThreshold))
                {
                    Trace($"MovementBlocked distance={Horizontal(targetPosition - bodyPos).magnitude}");
                    if (!TryUnstuck())
                        break;
                    await Awaiters.NextFrame;
                }

                if (IsMinimalProgress(elapsed, maxDuration, startPosition, bodyPos, targetPosition))
                {
                    LogWarning($"MoveMinimalProgress elapsedSec={elapsed:F2} maxDurationSec={maxDuration}");
                    break;
                }

                await Awaiters.NextFrame;
            }

            // 最終貼位：只調整XZ，保持當前Y
            SnapToTargetXZKeepY(targetPosition);

            // 維持和原行為一致：最後朝向設為 Vector3.right
            _ = SetCharacterDirectionVector(Vector3.right);

            Trace($"MoveToPositionComplete bodyPos={body.position} transformPos={transform.position}");
            _isMoving = false;
        }
        
        /* ====================== Helpers ====================== */
// 只保留水平方向
        private static Vector3 Horizontal(in Vector3 v) => new Vector3(v.x, 0f, v.z);
// 水平方向是否在閾值內
        private static bool IsCloseHorizontally(in Vector3 a, in Vector3 b, float threshold)
        {
            var diff = Horizontal(b - a);
            return diff.sqrMagnitude <= threshold * threshold;
        }
        
        // 執行一步位移，返回實際的水平位移(用於卡住判斷)
        private Vector3 DoMoveStep(in Vector3 moveDir, float speed)
        {
            var before = body.position;

            Vector3 moveVector = moveDir * speed * Time.deltaTime;

            if (characterController && characterController.enabled)
            {
                // 添加重力，與原代碼一致
                moveVector.y = -9.81f * Time.deltaTime;
                try
                {
                    characterController.Move(moveVector);
                }
                catch (Exception e)
                {
                    LogError($"CharacterMoveFailed error={e.Message}");
                }
            }
            else
            {
                // 非CharacterController：直接平移，保持Y不變
                var newPos = transform.position + moveVector;
                newPos.y = transform.position.y;
                transform.position = newPos;
            }

            var after = body.position;
            var actual = Horizontal(after - before);
            return actual;
        }
        // 是否卡住
        private static bool IsStuck(in Vector3 actualMove, in Vector3 bodyPos, in Vector3 target, float idleThreshold)
        {
            return actualMove.magnitude < 0.001f && Horizontal(target - bodyPos).magnitude > idleThreshold * 2f;
        }
        
        // 嘗試解卡：CharacterController 上抬一點；否則無法處理
        private bool TryUnstuck()
        {
            if (characterController && characterController.enabled)
            {
                try
                {
                    characterController.Move(Vector3.up * 0.1f);
                    return true;
                }
                catch (Exception e)
                {
                    LogError($"UnstuckMoveFailed error={e.Message}");
                    return false;
                }
            }
            return false;
        }
        
        // 進度過少：時間過半但前進距離不到總距離的10%
        private static bool IsMinimalProgress(float elapsed, float maxDuration, in Vector3 start, in Vector3 current, in Vector3 target)
        {
            if (elapsed <= maxDuration * 0.5f) return false;

            float total = Horizontal(target - start).magnitude;
            float progress = Horizontal(current - start).magnitude;

            // 避免除0
            if (total <= 0.0001f) return false;

            return progress < total * 0.1f;
        }

        // 最終貼位：對齊XZ，保持當前Y
        private void SnapToTargetXZKeepY(in Vector3 target)
        {
            var finalPos = new Vector3(target.x, transform.position.y, target.z);
            transform.position = finalPos;
        }
        
        // FollowMOve 
        public async Task FollowToPosition(Vector3 targetPosition,float speed = 0f)
        {
            Trace($"FollowToPosition target={targetPosition}");
            if (speed <= 0f)
            {
                speed = followSpeed;
            }
            await MoveToDestination(targetPosition, speed);
        }

        private async Task MoveToDestination(Vector3 targetPosition, float speed)
        {
            await MoveToPosition(targetPosition,speed);
            FinishMove();
        }
        
        
        /// <summary>
        /// 设置角色朝向方向（基于方向向量）
        /// </summary>
        /// <param name="direction">目标方向向量</param>
        private async Task SetCharacterDirectionVector(Vector3 direction)
        {
            direction.y = 0f;
            // 检查方向向量是否有效（在标准化之前）
            if (direction.magnitude < 0.01f) return;

            direction.Normalize();

            // 标准Unity旋转计算
            float targetYRotation = Mathf.Atan2(direction.x, direction.z) * Mathf.Rad2Deg;
            Quaternion targetRotation = Quaternion.Euler(0f, targetYRotation - 90, 0f);
            if (smoothRotation)
            {
                Quaternion startRotation = body.rotation;
                float rotationTime = 0f;

                while (rotationTime < rotationDuration)
                {
                    rotationTime += Time.deltaTime;
                    float t = rotationTime / rotationDuration;
                    body.rotation = Quaternion.Slerp(startRotation, targetRotation, t);
                    await Awaiters.NextFrame;
                }
            }
            body.rotation = targetRotation;
            Trace($"SetDirection target={direction} targetY={targetYRotation:F1} finalRotation={targetRotation.eulerAngles}");
        }
        
        // private IEnumerator TriggerNextFrame(string state)
        // {
        //     // animator.SetTrigger(BackToIdle);
        //     yield return null; // 等待一帧，让Animator处理BackToIdle的触发
        //     // animator.SetTrigger(BasicGathering);
        //     SetAnimationState(state);
        // }

        

        public async Task PlayMining( /*float duration */ )
        {
            Trace("PlayMining");
            SetAnimationState("gathering");
            // await Awaiters.Seconds(duration);
            // SetAnimationState("idle");
            _gatherNum = 0;
            _playMiningTcs = new TaskCompletionSource<bool>();
            await _playMiningTcs.Task;
        }

        public int GetAnimatorShowType()
        {
            return animator?.GetInteger(ShowType) ?? 0;
        }
        public void SetIdle()
        {
            // animator.SetTrigger(BackToIdle);
            // SetAnimationState("idle");
            // _ = UpdateShowType(0);
            var showType = animator.GetInteger(ShowType);
            Trace($"SetIdle showType={showType}");
            {
                animator.SetInteger(CurrentStatus,0);
                animator.SetTrigger(BackToIdle);
            }
        }
        public void SetAnimationState(string state)
        {
            var stateName = GetStateName();
            if (!animator) return;
            if (!state.Equals("idle"))
            {
                animator.ResetTrigger(BackToIdle);
            }
            var showType = animator.GetInteger(ShowType);
            Trace($"SetAnimationState state={state} currentState={stateName} showType={showType}");
            
            switch (state)
            {
                case "moving":
                    animator.SetInteger(CurrentStatus,1);
                    if (showType == 0)
                    {
                        animator.SetTrigger(ToBasic);
                        // GContext.Publish(new EventUISound("audio_ui_partnermining_npc_basicrun"));
                        
                    }else if (showType == 1)
                    {
                        animator.SetTrigger(AdvancedMove);
                        // GContext.Publish(new EventUISound("audio_ui_partnermining_npc_advancedrun"));
                    }else if (showType == 2)
                    {
                        animator.SetTrigger(MasterMove);
                        // GContext.Publish(new EventUISound("audio_ui_partnermining_npc_masterrun"));
                    }
                    PlayMoveSoundEffect();
                    break;
                case "gathering":
                    animator.SetInteger(CurrentStatus,2);
                    StopMoveAudio();
                    if (showType == 0)
                    {
                        PlayBasicGathering();
                    }else if (showType == 1)
                    {
                        PlayAdvancedGathering();
                    }else if (showType == 2)
                    {
                        var status = animator.GetInteger(CurrentStatus);
                        Trace($"AnimatorStatusUpdate status={status}");
                        PlayMasterGathering();
                    }
                    break;
                case "celebrate":
                    // StartCelebrate();
                    StopMoveAudio();
                    animator.SetInteger(CurrentStatus,3);
                    animator.SetTrigger(Celebrate);
                    break;
                default:
                    throw new NotSupportedException();
            }
        }

        private void PlayMasterGathering()
        {
            animator.SetTrigger(MasterGathering);
            // GContext.Publish(new EventUISound("audio_ui_partnermining_target_mastergather"));
        }

        private void PlayAdvancedGathering()
        {
            animator.SetTrigger(AdvancedGathering);
            // GContext.Publish(new EventUISound("audio_ui_partnermining_target_advancedgather"));
        }

        private void PlayBasicGathering()
        {
            animator.SetTrigger(BasicGathering);
            // GContext.Publish(new EventUISound("audio_ui_partnermining_target_basicgather"));
        }

        private void StartCelebrate()
        {
            _playCelebrateTcs = new TaskCompletionSource<bool>();
        }
        
        // private float moveTypeduration = 0.25f; 
        
        public async Task UpdateShowType(int showType)
        {
            var oldShowType = animator.GetInteger(ShowType);
            Trace($"UpdateShowType old={oldShowType} new={showType}");
            if (oldShowType == showType)
            {
                return;
            }
            _changeShowTypeTask = new TaskCompletionSource<bool>();
            animator.SetInteger(ShowType,showType);
            switch (showType)
            {
                case 0:
                    animator.SetTrigger( BackToIdle);
                    if (oldShowType == 1)
                    {
                        _fx_advancedToBasic.gameObject.SetActive(true);
                    }
                    else
                    {
                        _fx_masterToBasic.gameObject.SetActive(true);
                    }
                        
                    break;
                case 1:
                    animator.SetTrigger(ToAdvance);
                    // await Awaiters.Seconds(0.2f);
                    _fx_basicToAdvanced.gameObject.SetActive(true);
                    GContext.Publish(new EventUISound("audio_ui_partnermining_npc_mastershow"));
                    break;
                case 2:
                    animator.SetTrigger(ToMaster);
                    _fx_basicToMaster.gameObject.SetActive(true);
                    GContext.Publish(new EventUISound("audio_ui_partnermining_npc_mastershow"));
                    break;
            }
            // _ = UpdateShowTypePosition(oldShowType, showType,basePos);
            await _changeShowTypeTask.Task;
        }
        
        public async Task WaitForCelebrateFinished()
        {
            _playCelebrateTcs = new TaskCompletionSource<bool>();
            await _playCelebrateTcs.Task;
        }

        private TaskCompletionSource<bool> _idleTask;
        public async Task WaitForIdleFinished()
        {
            _idleTask = new TaskCompletionSource<bool>();
            await _idleTask.Task;
        }
        
        // 获取当前是否在移动
        public bool IsMoving()
        {
            return animator && animator.GetBool(runAnimParam);
        }
        
        public void OnAnimEnter(string args)
        {
            if (args.Equals("Gather"))
            {
                _gatherNum += 1;
                Trace($"AnimEnter args={args} gatherNum={_gatherNum} gatherPerDuration={GatherNumPerDuration}");
                if (_gatherNum > GatherNumPerDuration)
                {
                    return;
                }
                var showType = animator.GetInteger(ShowType);
                switch (showType)
                {
                    case 0:
                        _fx_basicGather.gameObject.SetActive(true);
                        GContext.Publish(new EventUISound("audio_ui_partnermining_target_basicgather"));
                        break;
                    case 1:
                        GContext.Publish(new EventUISound("audio_ui_partnermining_target_advancedgather"));
                        if (_gatherNum == 1)
                        {
                            _fx_advancedGather.gameObject.SetActive(true);
                        }
                        break;
                    case 2:
                        GContext.Publish(new EventUISound("audio_ui_partnermining_target_mastergather"));
                        if (_gatherNum == 1)
                        {
                            _fx_masterGather.gameObject.SetActive(true);
                        }
                        break;
                }
            }
            
            if (args.Equals("Move"))
            {
                // PlayMoveSoundEffect();
            }
            
            if (args.Equals("Idle"))
            {
                FinishIdle();
            }
        }
        
        private void PlayMoveSoundEffect()
        {
            StopMoveAudio();
            
            if (!IsMainCharacter) return;
            
            var showType = animator.GetInteger(ShowType);
            switch (showType)
            {
                case 0:
                    soundMove = GContext.container.Resolve<ISoundService>().GetNewUISound(audioBasic);
                    break;
                case 1:
                    soundMove = GContext.container.Resolve<ISoundService>().GetNewUISound(audioAdvanced);
                    break;
                case 2:
                    soundMove = GContext.container.Resolve<ISoundService>().GetNewUISound(audioMaster);
                    break;
            }
            soundMove.audioSource.Play();
            soundMove.audioSource.loop = true;
        }

        public void OnAnimEnd(string args)
        {
            var stateName = GetStateName();
            // Log($"OnAnimEnd -> {args} {stateName}");
            if (args.Equals("Gather"))
            {
                _fx_basicGather.gameObject.SetActive(false);
                // StopGatheringEffect();
                Trace($"AnimEnd args={args} gatherNum={_gatherNum}");
                // GContext.Publish(new EventMiningOre{ Num = _gatherNum});
                if (_gatherNum >= GatherNumPerDuration)
                {
                    FinishGather();
                }
            }
            
            else if (args.Equals("ShowType"))
            {
                Trace($"AnimEnd args={args}");
                FinishUpdateShowType();
            }
            else if (args.Equals("Idle"))
            {
                // Log($"-----OnAnimEnd -> {args} ");
                FinishIdle();
            }
            else if (args.Equals("IdleSpecial"))
            {
                Trace($"AnimEndToIdle args={args}");
                FinishIdleSpecial();
            }
            else if (args.Equals("Celebrate"))
            {
                FinishCelebrate();
            }
        }
        
        public void OnAnimEvent(string args)
        {
            if (args.Equals("Mining"))
            {
                GContext.Publish(new EventMiningOre{ Num = _gatherNum});
            }

            if (_gatherNum == 1)
            {
                GContext.Publish(new EventUISound("audio_ui_partnermining_resource_break01"));
            }
            else if (_gatherNum == 2)
            {
                GContext.Publish(new EventUISound("audio_ui_partnermining_resource_break02"));
            }
            else if (_gatherNum == 3)
            {
                GContext.Publish(new EventUISound("audio_ui_partnermining_resource_break03"));
            }
        }
        private void StopGatheringEffect()
        {
            // 挖矿特效
            _fx_basicGather.gameObject.SetActive(false);
            _fx_advancedGather.gameObject.SetActive(false) ;
            _fx_masterGather.gameObject.SetActive(false);
        }
        
        public async Task WaitIdleSpecialFinish()
        {
            Trace("WaitIdleSpecialFinish");
            animator.SetInteger(CurrentStatus,0);
            var showType = animator.GetInteger(ShowType);
            if (showType != 0)
            {
                _idleSpecialTask  = new TaskCompletionSource<bool>();
                await _idleSpecialTask.Task;
                Trace($"WaitIdleSpecialFinishState showType={showType} endIdle={EndIdle}");
                animator.SetTrigger(EndIdle);
                await UpdateShowType(0);
            }
        }
        
        private void FinishIdle()
        {
            // Log("FinishIdle->");
            var success = _idleTask?.TrySetResult(true) ?? false;
            if (success)
            {
                Trace("FinishIdle result=success");
            }
        }
        private void FinishIdleSpecial()
        {
            Trace("FinishedIdleSpecial");
            var success = _idleSpecialTask?.TrySetResult(true) ?? false;
            if (success)
            {
                Trace("FinishedIdleSpecial result=success");
            }
        }

        private void FinishUpdateShowType()
        {
            Trace("FinishUpdateShowType");
            var success = _changeShowTypeTask.TrySetResult(true);
            if (!success)
            {
                Trace("SetTaskResultSkipped reason=AlreadyCompleted");
            }
            _fx_basicToAdvanced.gameObject.SetActive(false);
            _fx_advancedToBasic.gameObject.SetActive(false);
            _fx_basicToMaster.gameObject.SetActive(false);
            _fx_masterToBasic.gameObject.SetActive(false);
        }
        
        private void FinishGather()
        {
            Trace("FinishGather");
            _gatherNum = 0;
            GatherNumPerDuration = -1;
            var ret = _playMiningTcs?.TrySetResult(true) ?? false;
            if (ret)
            {
                Trace("FinishGather result=true");
            }
            
            StopGatheringEffect();
            SetIdle();
        }

        public void FinishMove()
        {
            var showType = animator.GetInteger(ShowType);
            if (showType == 0)
            {
                animator.ResetTrigger(ToBasic);
            }else if (showType == 1)
            {
                animator.ResetTrigger(AdvancedMove);
            }else if (showType == 2)
            {
                animator.ResetTrigger(MasterMove);
            }
            
            StopMoveAudio();
            SetIdle();
        }
        private void FinishCelebrate()
        {
            Trace("FinishCelebrate");
            var ret = _playCelebrateTcs?.TrySetResult(true) ?? false;
            if (ret)
            {
                Trace("FinishCelebrate result=true");
            }
        }
        
        /// <summary>
        /// 立即设置角色朝向（基于方向向量，不带动画）
        /// </summary>
        /// <param name="direction">目标方向向量</param>
        public void SetDirectionVectorImmediate(Vector3 direction)
        {
            direction.y = 0f;
            // 检查方向向量是否有效（在标准化之前）
            if (direction.magnitude < 0.01f) return;
            direction.Normalize();
            // 标准Unity旋转计算
            float targetYRotation = Mathf.Atan2(direction.x, direction.z) * Mathf.Rad2Deg;
            body.rotation = Quaternion.Euler(0f, targetYRotation, 0f);
            Trace($"SetDirectionImmediate target={direction} targetY={targetYRotation:F1}");
        }

        /// <summary>
        /// 立即朝向目标位置（不带动画）
        /// </summary>
        /// <param name="targetPosition">目标位置</param>
        public void LookAtPositionImmediate(Vector3 targetPosition)
        {
            Vector3 direction = (targetPosition - body.position).normalized;
            SetDirectionVectorImmediate(direction);
        }

        /// <summary>
        /// 重置到默认朝向
        /// </summary>
        public void ResetToDefaultRotation()
        {
            body.rotation = Quaternion.identity;
        }

        /// <summary>
        /// 获取当前面向的方向
        /// </summary>
        /// <returns>1为右，-1为左，0为其他方向</returns>
        public float GetCurrentDirection()
        {
            Vector3 forward = body.forward;
            float dot = Vector3.Dot(forward, Vector3.right);

            if (dot > 0.5f) return 1f;
            if (dot < -0.5f) return -1f;
            return 0f;
        }

#if UNITY_EDITOR
        // /// <summary>
        // /// 编辑器辅助：重置到默认朝向
        // /// </summary>
        // [UnityEngine.ContextMenu("重置到默认朝向")]
        // private void ResetToDefault()
        // {
        //     ResetToDefaultRotation();
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：测试朝向前
        // /// </summary>
        // [UnityEngine.ContextMenu("测试朝向前")]
        // private void TestFaceForward()
        // {
        //     SetDirectionVectorImmediate(Vector3.forward);
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：测试移动到指定位置
        // /// </summary>
        // [UnityEngine.ContextMenu("测试移动(右前方)")]
        // private async void TestMoveToPosition()
        // {
        //     Vector3 testTarget = body.position + new Vector3(5f, 0f, 5f);
        //     Debug.Log($"测试移动到位置: {testTarget}");
        //     await MoveToPosition(testTarget, 3f);
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：测试移动(向右)
        // /// </summary>
        // [UnityEngine.ContextMenu("测试移动(向右)")]
        // private async void TestMoveRight()
        // {
        //     Vector3 testTarget = body.position + new Vector3(3f, 0f, 0f);
        //     Debug.Log($"测试向右移动到: {testTarget}");
        //     await MoveToPosition(testTarget, 2f);
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：测试移动(向前)
        // /// </summary>
        // [UnityEngine.ContextMenu("测试移动(向前)")]
        // private async void TestMoveForward()
        // {
        //     Vector3 testTarget = body.position + new Vector3(0f, 0f, 3f);
        //     Debug.Log($"测试向前移动到: {testTarget}");
        //     await MoveToPosition(testTarget, 2f);
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：显示当前朝向信息
        // /// </summary>
        // [UnityEngine.ContextMenu("显示当前朝向")]
        // private void ShowCurrentDirection()
        // {
        //     Debug.Log($"=== 角色朝向信息 ===");
        //     Debug.Log($"当前旋转: {body.rotation.eulerAngles}");
        //     Debug.Log($"Forward: {body.forward.ToString("F3")}");
        //     Debug.Log($"Right: {body.right.ToString("F3")}");
        //     Debug.Log($"Up: {body.up.ToString("F3")}");
        // }
        //
        // /// <summary>
        // /// 编辑器辅助：验证旋转逻辑
        // /// </summary>
        // [UnityEngine.ContextMenu("验证旋转逻辑")]
        // private void ValidateRotationLogic()
        // {
        //     Debug.Log($"=== 标准Unity旋转逻辑验证 ===");
        //
        //     // 测试四个主要方向
        //     Vector3[] testDirections =
        //     {
        //         Vector3.right, // 向右 (1, 0, 0)
        //         Vector3.left, // 向左 (-1, 0, 0)  
        //         Vector3.forward, // 向前 (0, 0, 1)
        //         Vector3.back // 向后 (0, 0, -1)
        //     };
        //
        //     string[] directionNames = { "右", "左", "前", "后" };
        //
        //     for (int i = 0; i < testDirections.Length; i++)
        //     {
        //         Vector3 direction = testDirections[i];
        //         float expectedYRotation = Mathf.Atan2(direction.x, direction.z) * Mathf.Rad2Deg;
        //
        //         Debug.Log($"方向{directionNames[i]}: " +
        //                   $"输入向量{direction} -> " +
        //                   $"Y旋转{expectedYRotation:F1}°");
        //     }
        // }
#endif
        private static void ELog(object t)
        {
#if UNITY_EDITOR
            Debug.Log($"<color=cyan>EventPartnerMiningCharacterController-> {t} </color>");
#endif
        }
        private static void LogWarning(object t)
        {
            Debug.LogWarning($"<color=yellow>EventPartnerMiningCharacterController-> {t} </color>");
        }
        private static void LogError(object t)
        {
            Debug.LogError($"<color=red>EventPartnerMiningCharacterController-> {t} </color>");
        }
    
    [System.Diagnostics.Conditional("UNITY_EDITOR")]
    private static void Trace(object t)
    {
        if (!EnableTraceLogs) return;
        ELog(t);
    }
        public async void Test()
        {
            ELog("Test");

            // this.UpdateShowType(0);
            
            FinishMove();
            animator.SetTrigger(Celebrate);
            // throw new NotImplementedException();
            // await UpdateShowType(2);
            // animator.SetTrigger("_toAdvance");
            // animator.SetTrigger(MasterGathering);
            // animator.SetTrigger(MasterMove);
            // await Awaiters.Seconds(0.8f);
            // animator.ResetTrigger(MasterMove);
            // animator.SetTrigger(MasterGathering);
        }


        
    }
}