using System;
using System.Collections.Generic;
using System.Diagnostics;
using Godot;

/// <summary>
/// 校园学生角色控制器
/// </summary>
public partial class CampusStudent : CharacterBody2D
{
    /// <summary>
    /// 饰品精灵
    /// </summary>
    private Sprite2D _accessory;
    /// <summary>
    /// 动画播放器
    /// </summary>
    private AnimationPlayer _animationPlayer;

    /// <summary>
    /// 身体精灵
    /// </summary>
    private Sprite2D _body;
    /// <summary>
    /// 眼睛精灵
    /// </summary>
    private Sprite2D _eye;
    /// <summary>
    /// 发型精灵
    /// </summary>
    private Sprite2D _hairstyle;
    /// <summary>
    /// 上一帧的时间间隔
    /// </summary>
    private double _lastDelta;
    
    /// <summary>
    /// 面朝方向
    /// </summary>
    private enum FacingDirection
    {
        Up,
        Down,
        Left,
        Right
    }
    
    /// <summary>
    /// 上一次的面朝方向
    /// </summary>
    private FacingDirection _lastFacing = FacingDirection.Down;
    /// <summary>
    /// 上一次的位置
    /// </summary>
    private Vector2 _lastPosition;

    /// <summary>
    /// 导航代理
    /// </summary>
    private NavigationAgent2D _navigationAgent;
    /// <summary>
    /// 服装精灵
    /// </summary>
    private Sprite2D _outfit;
    /// <summary>
    /// 是否已配置巡逻
    /// </summary>
    private bool _patrolConfigured;
    /// <summary>
    /// 当前巡逻点索引
    /// </summary>
    private int _patrolIndex;
    /// <summary>
    /// 巡逻点列表
    /// </summary>
    private List<Vector2> _patrolPoints = new();
    /// <summary>
    /// 手机精灵
    /// </summary>
    private Sprite2D _smartphone;
    /// <summary>
    /// 卡住计时器
    /// </summary>
    private float _stuckTimer;
    /// <summary>
    /// 导航地图RID
    /// </summary>
    private Rid _navigationMap;
    /// <summary>
    /// 当前目标点
    /// </summary>
    private Vector2 _currentTarget = Vector2.Zero;
    /// <summary>
    /// 是否有目标
    /// </summary>
    private bool _hasTarget;
    /// <summary>
    /// 是否启用行为控制
    /// </summary>
    private bool _behaviorControlEnabled;
    /// <summary>
    /// 行为目标点
    /// </summary>
    private Vector2 _behaviorTarget = Vector2.Zero;
    /// <summary>
    /// 是否有行为目标
    /// </summary>
    private bool _behaviorHasTarget;
    /// <summary>
    /// 手机闲置动画是否激活
    /// </summary>
    private bool _phoneIdleActive;
    /// <summary>
    /// 手机退出动作锁定
    /// </summary>
    private bool _phoneExitLocked;
    /// <summary>
    /// 是否使用物理移动
    /// </summary>
    private bool _usePhysicsMovement = true;
    /// <summary>
    /// 网格路径列表
    /// </summary>
    private readonly List<Vector2> _gridPath = new();
    /// <summary>
    /// 当前网格路径索引
    /// </summary>
    private int _gridPathIndex;
    /// <summary>
    /// 网格路径是否激活
    /// </summary>
    private bool _gridPathActive;
    /// <summary>
    /// 网格路径是否挂起
    /// </summary>
    private bool _gridPathPending;
    /// <summary>
    /// AStar网格
    /// </summary>
    private AStarGrid2D _astarGrid;
    /// <summary>
    /// AStar区域
    /// </summary>
    private Rect2I _astarRegion;
    /// <summary>
    /// AStar地图迭代版本
    /// </summary>
    private int _astarMapIteration;
    /// <summary>
    /// 网格重新寻路重试计时器
    /// </summary>
    private float _gridPathRetryTimer;
    /// <summary>
    /// 导航区域引用
    /// </summary>
    private NavigationRegion2D _navigationRegion;
    
    /// <summary>
    /// 移动速度
    /// </summary>
    [Export] public float MoveSpeed { get; set; } = 60.0f;
    /// <summary>
    /// 目标到达判定距离
    /// </summary>
    [Export] public float TargetReachDistance { get; set; } = 6.0f;
    /// <summary>
    /// 是否使用16x16精灵
    /// </summary>
    [Export] public bool Use16X16Sprites { get; set; } = true;
    /// <summary>
    /// 是否启用避让
    /// </summary>
    [Export] public bool EnableAvoidance { get; set; }
    /// <summary>
    /// 卡住重新寻路时间
    /// </summary>
    [Export] public float StuckRepathSeconds { get; set; } = 0.6f;
    /// <summary>
    /// 卡住距离阈值
    /// </summary>
    [Export] public float StuckDistanceEpsilon { get; set; } = 2.0f;
    /// <summary>
    /// 导航网格吸附距离
    /// </summary>
    [Export] public float NavMeshClampDistance { get; set; } = 6.0f;
    /// <summary>
    /// 是否使用网格寻路
    /// </summary>
    [Export] public bool UseGridPathfinding { get; set; } = true;
    /// <summary>
    /// 网格单元大小
    /// </summary>
    [Export] public float GridCellSize { get; set; } = 8.0f;
    /// <summary>
    /// 网格可行走容差
    /// </summary>
    [Export] public float GridWalkableTolerance { get; set; } = 2.0f;
    /// <summary>
    /// 网格搜索节点限制
    /// </summary>
    [Export] public int GridSearchNodeLimit { get; set; } = 8000;
    /// <summary>
    /// 网格重新寻路间隔
    /// </summary>
    [Export] public float GridRepathInterval { get; set; } = 0.25f;
    /// <summary>
    /// 调试绘制网格
    /// </summary>
    [Export] public bool DebugDrawGrid { get; set; }
    /// <summary>
    /// 调试仅绘制实心点
    /// </summary>
    [Export] public bool DebugDrawSolidOnly { get; set; } = true;
    /// <summary>
    /// 调试绘制路径
    /// </summary>
    [Export] public bool DebugDrawPath { get; set; }
    /// <summary>
    /// 调试绘制半径单元数
    /// </summary>
    [Export] public int DebugDrawRadiusCells { get; set; } = 20;
    /// <summary>
    /// 调试日志网格
    /// </summary>
    [Export] public bool DebugLogGrid { get; set; }
    /// <summary>
    /// 环境碰撞掩码
    /// </summary>
    [Export] public uint EnvironmentCollisionMask { get; set; } = 1u;
    /// <summary>
    /// 学生碰撞层
    /// </summary>
    [Export] public uint StudentCollisionLayer { get; set; } = 1u << 1;

    /// <summary>
    /// 准备就绪时调用
    /// </summary>
    public override void _Ready()
    {
        _navigationAgent = GetNodeOrNull<NavigationAgent2D>("NavigationAgent2D");
        _animationPlayer = GetNodeOrNull<AnimationPlayer>("AnimationPlayer");
        _navigationRegion = FindNavigationRegion();
        CacheSprites();
        ConfigureCollision();

        if (_animationPlayer != null)
        {
            _animationPlayer.AnimationFinished += OnAnimationFinished;
        }

        if (_navigationAgent != null)
        {
            // 强制关闭避让，学生之间直接穿过
            EnableAvoidance = false;

            // 让寻路点更“贴近目标”，避免走到边缘时抖动
            _navigationAgent.PathDesiredDistance = TargetReachDistance;
            _navigationAgent.TargetDesiredDistance = TargetReachDistance;
            _navigationAgent.AvoidanceEnabled = EnableAvoidance;

            if (EnableAvoidance)
                // 开启避让时使用安全速度回调进行移动
                _navigationAgent.VelocityComputed += OnVelocityComputed;

            if (_patrolConfigured) AdvanceTarget();
        }

        PlayIdleAnimation();
        _lastPosition = GlobalPosition;
    }

    /// <summary>
    /// 物理处理
    /// </summary>
    /// <param name="delta">时间间隔</param>
    public override void _PhysicsProcess(double delta)
    {
        _lastDelta = delta;
        if (DebugDrawGrid || DebugDrawPath)
        {
            QueueRedraw();
        }
        if ((DebugDrawGrid || DebugDrawPath) && _astarGrid == null)
        {
            EnsureAStarGrid();
        }
        if (_gridPathRetryTimer > 0.0f)
        {
            _gridPathRetryTimer = Mathf.Max(0.0f, _gridPathRetryTimer - (float)delta);
        }
        if (_phoneExitLocked)
        {
            Velocity = Vector2.Zero;
            if (!EnableAvoidance && _usePhysicsMovement)
            {
                MoveAndSlide();
            }
            return;
        }

        if (_behaviorControlEnabled && _behaviorHasTarget)
        {
            TryBuildPendingGridPath();
            if (_gridPathActive)
            {
                if (ProcessGridPathMovement(delta))
                {
                    return;
                }
            }
            else if (UseGridPathfinding && _gridPathPending)
            {
                Velocity = Vector2.Zero;
                if (!EnableAvoidance && _usePhysicsMovement)
                {
                    MoveAndSlide();
                }

                if (!_phoneIdleActive && !_phoneExitLocked)
                {
                    PlayIdleAnimation();
                }
                UpdateStuckTimer(delta);
                return;
            }
        }
        if (_navigationAgent == null || (!_behaviorControlEnabled && _patrolPoints.Count == 0) || (_behaviorControlEnabled && !_behaviorHasTarget))
        {
            if (!_phoneIdleActive && !_phoneExitLocked)
            {
                PlayIdleAnimation();
            }
            return;
        }

        // 到达目标点或无路可走时，切换到下一个巡游点
        if (_navigationAgent.IsNavigationFinished())
        {
            if (_behaviorControlEnabled)
            {
                Velocity = Vector2.Zero;
                if (!EnableAvoidance && _usePhysicsMovement)
                {
                    MoveAndSlide();
                }

                if (!_phoneIdleActive && !_phoneExitLocked)
                {
                    PlayIdleAnimation();
                }
                UpdateStuckTimer(delta);
                return;
            }

            AdvanceTarget();
        }

        var nextPosition = _navigationAgent.GetNextPathPosition();
        var toNext = nextPosition - GlobalPosition;
        if (toNext.LengthSquared() < 0.01f)
        {
            if (!EnableAvoidance && _usePhysicsMovement)
            {
                Velocity = Vector2.Zero;
                MoveAndSlide();
            }

            if (!_phoneIdleActive && !_phoneExitLocked)
            {
                PlayIdleAnimation();
            }
            UpdateStuckTimer(delta);
            return;
        }

        var direction = toNext.Normalized();
        var desiredVelocity = direction * MoveSpeed;

        if (EnableAvoidance)
        {
            // 交给导航系统做群体避让
            _navigationAgent.Velocity = desiredVelocity;
        }
        else
        {
            // 未启用避让时直接移动
            Velocity = ClampVelocityToNavMesh(desiredVelocity);
            ApplyMovement(delta);
            UpdateFacingAnimation(Velocity);
            UpdateStuckTimer(delta);
        }
    }

    /// <summary>
    /// 绘制调试信息
    /// </summary>
    public override void _Draw()
    {
        if (!DebugDrawGrid && !DebugDrawPath) return;
        if (_astarGrid == null || GridCellSize <= 0.0f) return;

        var cellSize = Mathf.Max(1.0f, GridCellSize);
        var half = new Vector2(cellSize * 0.5f, cellSize * 0.5f);

        if (DebugDrawGrid)
        {
            var radius = Mathf.Max(1, DebugDrawRadiusCells);
            var originCell = WorldToGrid(GlobalPosition);
            var minX = Math.Max(_astarRegion.Position.X, originCell.X - radius);
            var maxX = Math.Min(_astarRegion.Position.X + _astarRegion.Size.X - 1, originCell.X + radius);
            var minY = Math.Max(_astarRegion.Position.Y, originCell.Y - radius);
            var maxY = Math.Min(_astarRegion.Position.Y + _astarRegion.Size.Y - 1, originCell.Y + radius);

            var solidFill = new Color(1.0f, 0.3f, 0.3f, 0.25f);
            var solidOutline = new Color(1.0f, 0.3f, 0.3f, 0.6f);
            var walkFill = new Color(0.2f, 0.8f, 0.3f, 0.08f);
            var walkOutline = new Color(0.2f, 0.8f, 0.3f, 0.2f);

            for (var x = minX; x <= maxX; x++)
            {
                for (var y = minY; y <= maxY; y++)
                {
                    var cell = new Vector2I(x, y);
                    var isSolid = _astarGrid.IsPointSolid(cell);
                    if (DebugDrawSolidOnly && !isSolid)
                    {
                        continue;
                    }

                    var worldCenter = GridToWorld(cell);
                    // Draw around the cell center to verify path alignment.
                    var localTopLeft = ToLocal(worldCenter) - half;
                    var rect = new Rect2(localTopLeft, new Vector2(cellSize, cellSize));
                    DrawRect(rect, isSolid ? solidFill : walkFill);
                    DrawRect(rect, isSolid ? solidOutline : walkOutline, false, 1.0f);
                }
            }
        }

        if (DebugDrawPath && _gridPath.Count > 0 && _gridPathIndex < _gridPath.Count)
        {
            var pathColor = new Color(0.2f, 0.7f, 1.0f, 0.9f);
            var current = ToLocal(GlobalPosition);
            for (var i = _gridPathIndex; i < _gridPath.Count; i++)
            {
                var next = ToLocal(_gridPath[i]);
                DrawLine(current, next, pathColor, 2.0f);
                DrawCircle(next, 2.5f, pathColor);
                current = next;
            }
        }
    }

    /// <summary>
    /// 配置巡逻
    /// </summary>
    /// <param name="points">巡逻点列表</param>
    /// <param name="startIndex">起始索引</param>
    public void ConfigurePatrol(List<Vector2> points, int startIndex)
    {
        _patrolPoints = points ?? new List<Vector2>();
        if (_patrolPoints.Count == 0) return;

        _patrolIndex = (startIndex % _patrolPoints.Count + _patrolPoints.Count) % _patrolPoints.Count;
        _patrolConfigured = true;
        ApplyRandomTheme();

        if (_navigationAgent != null) AdvanceTarget();
    }

    /// <summary>
    /// 启用行为控制
    /// </summary>
    public void EnableBehaviorControl()
    {
        _behaviorControlEnabled = true;
        _behaviorHasTarget = false;
        _patrolConfigured = false;
        _patrolPoints.Clear();
    }

    /// <summary>
    /// 设置行为目标
    /// </summary>
    /// <param name="target">目标位置</param>
    public void SetBehaviorTarget(Vector2 target)
    {
        _behaviorControlEnabled = true;
        target = ClampTargetToNavMesh(target);
        _behaviorTarget = target;
        _behaviorHasTarget = true;
        _currentTarget = target;
        _hasTarget = true;
        _stuckTimer = 0.0f;
        _gridPathActive = false;
        _gridPathPending = false;
        _gridPathIndex = 0;
        _gridPathRetryTimer = 0.0f;
        _gridPath.Clear();

        if (UseGridPathfinding)
        {
            _gridPathPending = true;
            TryBuildPendingGridPath();
        }

        if (!UseGridPathfinding && _navigationAgent != null)
        {
            _navigationAgent.TargetPosition = target;
        }
    }

    /// <summary>
    /// 清除行为目标
    /// </summary>
    public void ClearBehaviorTarget()
    {
        _behaviorHasTarget = false;
        _hasTarget = false;
        _currentTarget = Vector2.Zero;
        _stuckTimer = 0.0f;
        _gridPathActive = false;
        _gridPathPending = false;
        _gridPathIndex = 0;
        _gridPathRetryTimer = 0.0f;
        _gridPath.Clear();
    }

    /// <summary>
    /// 是否已到达行为目标
    /// </summary>
    /// <returns>到达返回true</returns>
    public bool HasReachedBehaviorTarget()
    {
        if (!_behaviorHasTarget) return true;
        if (_gridPathActive)
        {
            return _gridPathIndex >= _gridPath.Count;
        }
        if (_gridPathPending)
        {
            return false;
        }
        if (_navigationAgent == null) return true;
        return _navigationAgent.IsNavigationFinished();
    }

    /// <summary>
    /// 开始玩手机
    /// </summary>
    public void StartPhoneIdle()
    {
        if (_animationPlayer == null || !_animationPlayer.HasAnimation("phone_up")) return;
        if (_phoneIdleActive) return;

        _phoneExitLocked = false;
        _phoneIdleActive = true;
        _animationPlayer.Play("phone_up");
    }

    /// <summary>
    /// 停止玩手机
    /// </summary>
    /// <param name="lockMovement">是否锁定移动</param>
    public void StopPhoneIdle(bool lockMovement = false)
    {
        if (_animationPlayer == null)
        {
            _phoneIdleActive = false;
            _phoneExitLocked = false;
            return;
        }

        if (_phoneExitLocked && !lockMovement)
        {
            return;
        }

        if (!_phoneIdleActive && !_phoneExitLocked)
        {
            return;
        }

        _phoneIdleActive = false;
        if (_animationPlayer.HasAnimation("phone_down"))
        {
            _phoneExitLocked = lockMovement;
            _animationPlayer.Play("phone_down");
        }
        else
        {
            _phoneExitLocked = false;
            PlayIdleAnimation();
        }
    }

    /// <summary>
    /// 设置导航地图
    /// </summary>
    /// <param name="map">地图RID</param>
    public void SetNavigationMap(Rid map)
    {
        // 由校园控制器传入导航地图，供本地边界夹紧使用
        _navigationMap = map;
        _astarGrid = null;
        _astarRegion = new Rect2I();
        _astarMapIteration = 0;
        _navigationRegion = FindNavigationRegion();
    }

    /// <summary>
    /// 应用随机主题
    /// </summary>
    public void ApplyRandomTheme()
    {
        // 随机替换身体与配件贴图，形成不同主题外观
        if (_body == null) CacheSprites();

        Debug.Assert(_body != null, nameof(_body) + " != null");
        _body.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Body, Use16X16Sprites));
        _hairstyle.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Hair, Use16X16Sprites));
        _outfit.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Outfit, Use16X16Sprites));
        _eye.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Eye, Use16X16Sprites));
        _accessory.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Accessory, Use16X16Sprites));
        _smartphone.Texture = ResourceLoader.Load<Texture2D>(Res.GetRandom(Res.Type.Phone, Use16X16Sprites));
    }

    /// <summary>
    /// 缓存精灵节点
    /// </summary>
    private void CacheSprites()
    {
        // 缓存子节点引用，避免每帧查找
        _body = GetNode<Sprite2D>("parts/body");
        _hairstyle = GetNode<Sprite2D>("parts/hairstyle");
        _outfit = GetNode<Sprite2D>("parts/outfit");
        _eye = GetNode<Sprite2D>("parts/eye");
        _accessory = GetNode<Sprite2D>("parts/accessory");
        _smartphone = GetNode<Sprite2D>("parts/smartphone");
    }

    /// <summary>
    /// 配置碰撞
    /// </summary>
    private void ConfigureCollision()
    {
        // 学生只与环境碰撞，不与其它学生碰撞
        CollisionLayer = StudentCollisionLayer;
        CollisionMask = EnvironmentCollisionMask;
        _usePhysicsMovement = true;
    }

    /// <summary>
    /// 推进到下一个目标
    /// </summary>
    private void AdvanceTarget()
    {
        if (_patrolPoints.Count == 0 || _navigationAgent == null) return;
        if (_behaviorControlEnabled) return;

        // 避免当前点过近导致原地抖动，最多尝试一轮
        for (var i = 0; i < _patrolPoints.Count; i++)
        {
            var target = _patrolPoints[_patrolIndex];
            _patrolIndex = (_patrolIndex + 1) % _patrolPoints.Count;
            if (GlobalPosition.DistanceTo(target) > TargetReachDistance * 1.5f)
            {
                _currentTarget = target;
                _hasTarget = true;
                _navigationAgent.TargetPosition = target;
                _stuckTimer = 0.0f;
                return;
            }
        }

        _currentTarget = _patrolPoints[_patrolIndex];
        _hasTarget = true;
        _navigationAgent.TargetPosition = _currentTarget;
        _stuckTimer = 0.0f;
    }

    /// <summary>
    /// 计算避让速度时的回调
    /// </summary>
    /// <param name="safeVelocity">安全速度</param>
    private void OnVelocityComputed(Vector2 safeVelocity)
    {
        if (_phoneExitLocked)
        {
            Velocity = Vector2.Zero;
            if (_usePhysicsMovement)
            {
                MoveAndSlide();
            }
            return;
        }
        // 使用安全速度移动，避免与其它角色硬碰硬卡住
        Velocity = ClampVelocityToNavMesh(safeVelocity);
        ApplyMovement(_lastDelta);
        UpdateFacingAnimation(Velocity);
        UpdateStuckTimer(_lastDelta);
    }

    /// <summary>
    /// 更新卡住计时器
    /// </summary>
    /// <param name="delta">时间间隔</param>
    private void UpdateStuckTimer(double delta)
    {
        if (StuckRepathSeconds <= 0.0f || !_hasTarget)
        {
            _lastPosition = GlobalPosition;
            return;
        }

        // 若短时间内几乎没有位移，则重新请求路径来脱困
        if (GlobalPosition.DistanceTo(_lastPosition) <= StuckDistanceEpsilon)
            _stuckTimer += (float)delta;
        else
            _stuckTimer = 0.0f;

        _lastPosition = GlobalPosition;

        if (_stuckTimer >= StuckRepathSeconds)
        {
            _stuckTimer = 0.0f;
            RepathToCurrentTarget();
        }
    }

    /// <summary>
    /// 重新规划路径到当前目标
    /// </summary>
    private void RepathToCurrentTarget()
    {
        if (!_hasTarget) return;

        if (UseGridPathfinding)
        {
            _gridPathActive = false;
            _gridPathPending = true;
            _gridPathIndex = 0;
            _gridPath.Clear();
            TryBuildPendingGridPath();
            return;
        }

        if (_navigationAgent == null) return;

        // 重新请求到同一目标点的路径，避免“固定时间换目的地”
        _navigationAgent.TargetPosition = _currentTarget;
    }

    /// <summary>
    /// 尝试构建挂起的网格路径
    /// </summary>
    private void TryBuildPendingGridPath()
    {
        if (!UseGridPathfinding || !_gridPathPending) return;
        if (_gridPathRetryTimer > 0.0f) return;
        if (!IsNavigationMapReady()) return;

        var path = BuildGridPath(GlobalPosition, _currentTarget);
        if (path == null || path.Count == 0)
        {
            _gridPathRetryTimer = Mathf.Max(0.1f, GridRepathInterval);
            return;
        }

        _gridPath.Clear();
        _gridPath.AddRange(path);
        _gridPathIndex = 0;
        _gridPathActive = true;
        _gridPathPending = false;
        if (DebugDrawGrid || DebugDrawPath)
        {
            QueueRedraw();
        }
    }

    /// <summary>
    /// 导航地图是否准备就绪
    /// </summary>
    /// <returns>准备就绪返回true</returns>
    private bool IsNavigationMapReady()
    {
        return _navigationMap.IsValid && NavigationServer2D.MapGetIterationId(_navigationMap) > 0;
    }

    /// <summary>
    /// 将速度限制在导航网格内
    /// </summary>
    /// <param name="velocity">目标速度</param>
    /// <returns>限制后的速度</returns>
    private Vector2 ClampVelocityToNavMesh(Vector2 velocity)
    {
        if (!IsNavigationMapReady()) return velocity;
        if (_lastDelta <= 0.0) return velocity;

        // 预测下一帧位置，若偏离导航网格过远则夹回网格内
        var candidate = GlobalPosition + velocity * (float)_lastDelta;
        var closest = NavigationServer2D.MapGetClosestPoint(_navigationMap, candidate);
        if (closest.DistanceTo(candidate) > NavMeshClampDistance)
        {
            var corrected = closest - GlobalPosition;
            if (corrected.LengthSquared() < 0.01f)
            {
                return Vector2.Zero;
            }
            return corrected / (float)_lastDelta;
        }

        return velocity;
    }

    /// <summary>
    /// 将目标点限制在导航网格内
    /// </summary>
    /// <param name="target">目标点</param>
    /// <returns>限制后的目标点</returns>
    private Vector2 ClampTargetToNavMesh(Vector2 target)
    {
        if (!IsNavigationMapReady()) return target;

        var closest = NavigationServer2D.MapGetClosestPoint(_navigationMap, target);
        if (closest.DistanceTo(target) <= 0.01f)
        {
            return target;
        }

        return closest;
    }

    /// <summary>
    /// 应用移动
    /// </summary>
    /// <param name="delta">时间间隔</param>
    private void ApplyMovement(double delta)
    {
        if (_usePhysicsMovement)
        {
            MoveAndSlide();
            return;
        }

        // 关闭碰撞时直接平移，避免 CharacterBody2D 在无碰撞层时不移动
        GlobalPosition += Velocity * (float)delta;
    }

    /// <summary>
    /// 更新面朝向动画
    /// </summary>
    /// <param name="velocity">当前速度</param>
    private void UpdateFacingAnimation(Vector2 velocity)
    {
        if (_phoneIdleActive || _phoneExitLocked)
        {
            return;
        }

        if (velocity.LengthSquared() < 0.01f)
        {
            PlayIdleAnimation();
            return;
        }

        if (Mathf.Abs(velocity.X) >= Mathf.Abs(velocity.Y))
            _lastFacing = velocity.X >= 0 ? FacingDirection.Right : FacingDirection.Left;
        else
            _lastFacing = velocity.Y >= 0 ? FacingDirection.Down : FacingDirection.Up;

        switch (_lastFacing)
        {
            case FacingDirection.Left:
                PlayAnimation("walk_left");
                break;
            case FacingDirection.Right:
                PlayAnimation("walk_right");
                break;
            case FacingDirection.Up:
                PlayAnimation("walk_up");
                break;
            case FacingDirection.Down:
                PlayAnimation("walk_down");
                break;
        }
    }

    /// <summary>
    /// 播放闲置动画
    /// </summary>
    private void PlayIdleAnimation()
    {
        if (_phoneIdleActive || _phoneExitLocked)
        {
            return;
        }

        switch (_lastFacing)
        {
            case FacingDirection.Left:
                PlayAnimation("idle_left");
                break;
            case FacingDirection.Right:
                PlayAnimation("idle_right");
                break;
            case FacingDirection.Up:
                PlayAnimation("idle_back");
                break;
            case FacingDirection.Down:
                PlayAnimation("idle_front");
                break;
        }
    }

    /// <summary>
    /// 播放指定动画
    /// </summary>
    /// <param name="animationName">动画名称</param>
    private void PlayAnimation(string animationName)
    {
        if (_animationPlayer == null) return;

        if (_animationPlayer.CurrentAnimation != animationName) _animationPlayer.Play(animationName);
    }

    /// <summary>
    /// 动画结束回调
    /// </summary>
    /// <param name="animationName">动画名称</param>
    private void OnAnimationFinished(StringName animationName)
    {
        if (_animationPlayer == null) return;

        if (animationName == "phone_up" && _phoneIdleActive)
        {
            if (_animationPlayer.HasAnimation("phone_loop"))
            {
                _animationPlayer.Play("phone_loop");
            }
            return;
        }

        if (animationName == "phone_down" && !_phoneIdleActive)
        {
            _phoneExitLocked = false;
            PlayIdleAnimation();
        }
    }

    /// <summary>
    /// 处理网格路径移动
    /// </summary>
    /// <param name="delta">时间间隔</param>
    /// <returns>如果正在移动返回true</returns>
    private bool ProcessGridPathMovement(double delta)
    {
        if (_gridPathIndex >= _gridPath.Count)
        {
            Velocity = Vector2.Zero;
            if (!EnableAvoidance && _usePhysicsMovement)
            {
                MoveAndSlide();
            }

            if (!_phoneIdleActive && !_phoneExitLocked)
            {
                PlayIdleAnimation();
            }
            UpdateStuckTimer(delta);
            return true;
        }

        var target = _gridPath[_gridPathIndex];
        var toNext = target - GlobalPosition;
        if (toNext.LengthSquared() <= TargetReachDistance * TargetReachDistance)
        {
            _gridPathIndex += 1;
            return true;
        }

        if (delta <= 0.0)
        {
            return true;
        }

        var axisVelocity = ToAxisVelocity(toNext);
        var step = axisVelocity * MoveSpeed * (float)delta;
        var candidate = GlobalPosition + step;
        if (!IsWorldWalkable(candidate))
        {
            Velocity = Vector2.Zero;
            if (!EnableAvoidance && _usePhysicsMovement)
            {
                MoveAndSlide();
            }
            RepathToCurrentTarget();
            UpdateStuckTimer(delta);
            return true;
        }

        Velocity = step / (float)delta;
        ApplyMovement(delta);
        UpdateFacingAnimation(Velocity);
        UpdateStuckTimer(delta);
        return true;
    }

    /// <summary>
    /// 转换为轴向速度
    /// </summary>
    /// <param name="delta">位移</param>
    /// <returns>轴向速度</returns>
    private Vector2 ToAxisVelocity(Vector2 delta)
    {
        if (Mathf.Abs(delta.X) >= Mathf.Abs(delta.Y))
        {
            return new Vector2(Mathf.Sign(delta.X), 0);
        }

        return new Vector2(0, Mathf.Sign(delta.Y));
    }

    /// <summary>
    /// 构建网格路径
    /// </summary>
    /// <param name="start">起点</param>
    /// <param name="target">终点</param>
    /// <returns>路径点列表</returns>
    private List<Vector2> BuildGridPath(Vector2 start, Vector2 target)
    {
        if (!IsNavigationMapReady() || GridCellSize <= 0.0f)
        {
            return null;
        }

        EnsureAStarGrid();
        if (_astarGrid == null)
        {
            return null;
        }

        var startCell = WorldToGrid(start);
        var targetCell = WorldToGrid(target);
        if (!IsCellInBounds(startCell) || !IsCellInBounds(targetCell))
        {
            if (DebugLogGrid)
            {
                GD.Print($"[AStarGrid] out_of_bounds start={startCell} target={targetCell} region={_astarRegion}");
            }
            return null;
        }

        startCell = FindNearestOpenCell(startCell, 6);
        targetCell = FindNearestOpenCell(targetCell, 6);
        if (!IsCellInBounds(startCell) || !IsCellInBounds(targetCell))
        {
            if (DebugLogGrid)
            {
                GD.Print($"[AStarGrid] no_open_cell start={startCell} target={targetCell}");
            }
            return null;
        }

        if (_astarGrid.IsPointSolid(startCell) || _astarGrid.IsPointSolid(targetCell))
        {
            if (DebugLogGrid)
            {
                GD.Print($"[AStarGrid] solid start={startCell} target={targetCell}");
            }
            return null;
        }

        var path = _astarGrid.GetIdPath(startCell, targetCell);
        if (path.Count == 0)
        {
            if (DebugLogGrid)
            {
                GD.Print($"[AStarGrid] empty_path start={startCell} target={targetCell}");
            }
            return null;
        }

        var result = new List<Vector2>(path.Count);
        foreach (Vector2I cell in path)
        {
            result.Add(GridToWorld(cell));
        }

        if (result.Count > 0)
        {
            result.RemoveAt(0);
        }

        RemoveImmediateBacktracks(result);
        return SimplifyGridPath(result);
    }

    /// <summary>
    /// 移除直接回头的路径点
    /// </summary>
    /// <param name="path">路径</param>
    private void RemoveImmediateBacktracks(List<Vector2> path)
    {
        if (path == null || path.Count < 3) return;

        var index = 2;
        while (index < path.Count)
        {
            if (path[index].DistanceTo(path[index - 2]) <= 0.01f)
            {
                path.RemoveAt(index - 1);
                index = Math.Max(2, index - 1);
                continue;
            }
            index += 1;
        }
    }

    /// <summary>
    /// 简化网格路径（移除共线点）
    /// </summary>
    /// <param name="path">路径</param>
    /// <returns>简化后的路径</returns>
    private List<Vector2> SimplifyGridPath(List<Vector2> path)
    {
        if (path == null || path.Count < 3) return path;

        var simplified = new List<Vector2> { path[0] };
        var lastDir = Vector2.Zero;

        for (var i = 1; i < path.Count; i++)
        {
            var delta = path[i] - path[i - 1];
            if (delta.LengthSquared() < 0.01f)
            {
                continue;
            }

            var axisDir = ToAxisVelocity(delta);
            if (simplified.Count == 1)
            {
                simplified.Add(path[i]);
                lastDir = axisDir;
                continue;
            }

            if (axisDir == lastDir)
            {
                simplified[simplified.Count - 1] = path[i];
            }
            else
            {
                simplified.Add(path[i]);
                lastDir = axisDir;
            }
        }

        return simplified;
    }

    /// <summary>
    /// 确保AStar网格已建立
    /// </summary>
    private void EnsureAStarGrid()
    {
        if (!IsNavigationMapReady()) return;

        var region = BuildGridRegion();
        if (region.Size.X <= 0 || region.Size.Y <= 0)
        {
            return;
        }

        var cellSize = new Vector2(Mathf.Max(1.0f, GridCellSize), Mathf.Max(1.0f, GridCellSize));
        var mapIteration = (int)NavigationServer2D.MapGetIterationId(_navigationMap);
        var needsRebuild = _astarGrid == null
            || _astarMapIteration != mapIteration
            || _astarRegion.Position != region.Position
            || _astarRegion.Size != region.Size
            || _astarGrid.CellSize != cellSize;

        if (!needsRebuild)
        {
            return;
        }

        _astarGrid ??= new AStarGrid2D();
        _astarGrid.Region = region;
        _astarGrid.CellSize = cellSize;
        _astarGrid.Offset = Vector2.Zero;
        _astarGrid.DiagonalMode = AStarGrid2D.DiagonalModeEnum.Never;
        _astarGrid.Update();

        for (var x = region.Position.X; x < region.Position.X + region.Size.X; x++)
        {
            for (var y = region.Position.Y; y < region.Position.Y + region.Size.Y; y++)
            {
                var cell = new Vector2I(x, y);
                var center = GridToWorld(cell);
                var walkable = IsCellWalkable(center);
                _astarGrid.SetPointSolid(cell, !walkable);
            }
        }

        _astarRegion = region;
        _astarMapIteration = mapIteration;
        if (DebugLogGrid)
        {
            GD.Print($"[AStarGrid] region={region} cell={cellSize}");
        }
        if (DebugDrawGrid || DebugDrawPath)
        {
            QueueRedraw();
        }
    }

    /// <summary>
    /// 构建网格区域
    /// </summary>
    /// <returns>网格区域</returns>
    private Rect2I BuildGridRegion()
    {
        var bounds = BuildWorldBounds();
        var cell = Mathf.Max(1.0f, GridCellSize);
        var minX = Mathf.FloorToInt(bounds.Position.X / cell);
        var minY = Mathf.FloorToInt(bounds.Position.Y / cell);
        var maxX = Mathf.CeilToInt((bounds.Position.X + bounds.Size.X) / cell);
        var maxY = Mathf.CeilToInt((bounds.Position.Y + bounds.Size.Y) / cell);
        var sizeX = Math.Max(1, maxX - minX);
        var sizeY = Math.Max(1, maxY - minY);
        return new Rect2I(new Vector2I(minX, minY), new Vector2I(sizeX, sizeY));
    }

    /// <summary>
    /// 构建世界边界
    /// </summary>
    /// <returns>世界边界</returns>
    private Rect2 BuildWorldBounds()
    {
        var viewport = GetViewportRect();
        var bounds = new Rect2(viewport.Position, viewport.Size);

        var navRegion = _navigationRegion ?? FindNavigationRegion();
        if (navRegion == null || navRegion.NavigationPolygon == null)
        {
            return bounds;
        }

        var polygon = navRegion.NavigationPolygon;
        var outlineCount = polygon.GetOutlineCount();
        if (outlineCount == 0)
        {
            return bounds;
        }

        var min = Vector2.Zero;
        var max = Vector2.Zero;
        var hasPoint = false;

        for (var i = 0; i < outlineCount; i++)
        {
            var outline = polygon.GetOutline(i);
            for (var j = 0; j < outline.Length; j++)
            {
                var world = navRegion.ToGlobal(outline[j]);
                if (!hasPoint)
                {
                    min = world;
                    max = world;
                    hasPoint = true;
                    continue;
                }

                min = new Vector2(Mathf.Min(min.X, world.X), Mathf.Min(min.Y, world.Y));
                max = new Vector2(Mathf.Max(max.X, world.X), Mathf.Max(max.Y, world.Y));
            }
        }

        if (!hasPoint)
        {
            return bounds;
        }

        var navBounds = new Rect2(min, max - min);
        return bounds.Merge(navBounds);
    }

    /// <summary>
    /// 单元格是否在区域内
    /// </summary>
    /// <param name="cell">单元格</param>
    /// <returns>如果在区域内返回true</returns>
    private bool IsCellInRegion(Vector2I cell)
    {
        return cell.X >= _astarRegion.Position.X
            && cell.X < _astarRegion.Position.X + _astarRegion.Size.X
            && cell.Y >= _astarRegion.Position.Y
            && cell.Y < _astarRegion.Position.Y + _astarRegion.Size.Y;
    }

    /// <summary>
    /// 单元格是否在边界内
    /// </summary>
    /// <param name="cell">单元格</param>
    /// <returns>如果在边界内返回true</returns>
    private bool IsCellInBounds(Vector2I cell)
    {
        if (_astarGrid != null)
        {
            return _astarGrid.IsInBounds(cell.X, cell.Y);
        }

        return IsCellInRegion(cell);
    }

    /// <summary>
    /// 世界坐标转网格坐标
    /// </summary>
    /// <param name="world">世界坐标</param>
    /// <returns>网格坐标</returns>
    private Vector2I WorldToGrid(Vector2 world)
    {
        var size = Mathf.Max(1.0f, GridCellSize);
        return new Vector2I(
            Mathf.FloorToInt(world.X / size),
            Mathf.FloorToInt(world.Y / size));
    }

    /// <summary>
    /// 网格坐标转世界坐标
    /// </summary>
    /// <param name="grid">网格坐标</param>
    /// <returns>世界坐标</returns>
    private Vector2 GridToWorld(Vector2I grid)
    {
        var size = Mathf.Max(1.0f, GridCellSize);
        return new Vector2((grid.X + 0.5f) * size, (grid.Y + 0.5f) * size);
    }

    /// <summary>
    /// 查找最近的开放单元格
    /// </summary>
    /// <param name="origin">起点</param>
    /// <param name="radius">搜索半径</param>
    /// <returns>最近的开放单元格</returns>
    private Vector2I FindNearestOpenCell(Vector2I origin, int radius)
    {
        if (_astarGrid == null) return origin;
        if (IsCellInBounds(origin) && !_astarGrid.IsPointSolid(origin)) return origin;

        for (var r = 1; r <= radius; r++)
        {
            for (var dx = -r; dx <= r; dx++)
            {
                var dy = r - Math.Abs(dx);
                var candidateA = new Vector2I(origin.X + dx, origin.Y + dy);
                if (IsCellInBounds(candidateA) && !_astarGrid.IsPointSolid(candidateA))
                {
                    return candidateA;
                }

                if (dy == 0) continue;
                var candidateB = new Vector2I(origin.X + dx, origin.Y - dy);
                if (IsCellInBounds(candidateB) && !_astarGrid.IsPointSolid(candidateB))
                {
                    return candidateB;
                }
            }
        }

        return origin;
    }

    /// <summary>
    /// 世界坐标是否可行走
    /// </summary>
    /// <param name="world">世界坐标</param>
    /// <returns>如果可行走返回true</returns>
    private bool IsWorldWalkable(Vector2 world)
    {
        if (!IsNavigationMapReady()) return false;
        var closest = NavigationServer2D.MapGetClosestPoint(_navigationMap, world);
        return closest.DistanceTo(world) <= GetGridTolerance();
    }

    /// <summary>
    /// 查找导航区域节点
    /// </summary>
    /// <returns>导航区域</returns>
    private NavigationRegion2D FindNavigationRegion()
    {
        return GetTree()?.CurrentScene?.FindChild("NavigationRegion2D", true, false) as NavigationRegion2D;
    }

    /// <summary>
    /// 单元格中心是否可行走
    /// </summary>
    /// <param name="center">中心点</param>
    /// <returns>如果可行走返回true</returns>
    private bool IsCellWalkable(Vector2 center)
    {
        if (!IsWorldWalkable(center)) return false;

        var half = Mathf.Max(1.0f, GridCellSize * 0.45f);
        var offsets = new[]
        {
            new Vector2(half, 0),
            new Vector2(-half, 0),
            new Vector2(0, half),
            new Vector2(0, -half),
            new Vector2(half, half),
            new Vector2(half, -half),
            new Vector2(-half, half),
            new Vector2(-half, -half)
        };

        for (var i = 0; i < offsets.Length; i++)
        {
            if (!IsWorldWalkable(center + offsets[i]))
            {
                return false;
            }
        }

        return true;
    }

    /// <summary>
    /// 获取网格容差
    /// </summary>
    /// <returns>网格容差</returns>
    private float GetGridTolerance()
    {
        return Mathf.Max(1.0f, GridWalkableTolerance);
    }
}