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

/// <summary>
///     校园学生角色控制器
/// </summary>
public partial class CampusStudent : CharacterBody2D {
    /// <summary>
    ///     网格路径列表
    /// </summary>
    private readonly List<Vector2> _gridPath = new();

    /// <summary>
    ///     外观主题
    /// </summary>
    private readonly SuitTheme _theme = new();

    /// <summary>
    ///     获取外观主题ID
    /// </summary>
    /// <returns>主题ID</returns>
    public ulong GetSuitThemeId() {
        return _theme.GetThemeId();
    }
    
    /// <summary>
    ///     动画播放器
    /// </summary>
    private AnimationPlayer _animationPlayer;

    /// <summary>
    ///     是否启用行为控制
    /// </summary>
    private bool _behaviorControlEnabled;

    /// <summary>
    ///     是否有行为目标
    /// </summary>
    private bool _behaviorHasTarget;

    /// <summary>
    ///     行为目标点
    /// </summary>
    private Vector2 _behaviorTarget = Vector2.Zero;

    /// <summary>
    ///     校园控制器
    /// </summary>
    private CampusController _campusController;

    /// <summary>
    ///     当前目标点
    /// </summary>
    private Vector2 _currentTarget = Vector2.Zero;

    /// <summary>
    ///     网格路径是否激活
    /// </summary>
    private bool _gridPathActive;

    /// <summary>
    ///     当前网格路径索引
    /// </summary>
    private int _gridPathIndex;

    /// <summary>
    ///     网格路径是否挂起
    /// </summary>
    private bool _gridPathPending;

    /// <summary>
    ///     网格重新寻路重试计时器
    /// </summary>
    private float _gridPathRetryTimer;

    /// <summary>
    ///     是否有目标
    /// </summary>
    private bool _hasTarget;

    /// <summary>
    ///     上一帧的时间间隔
    /// </summary>
    private double _lastDelta;

    /// <summary>
    ///     上一次的面朝方向
    /// </summary>
    private FacingDirection _lastFacing = FacingDirection.Down;

    /// <summary>
    ///     上一次的位置
    /// </summary>
    private Vector2 _lastPosition;

    /// <summary>
    ///     是否已配置巡逻
    /// </summary>
    private bool _patrolConfigured;

    /// <summary>
    ///     当前巡逻点索引
    /// </summary>
    private int _patrolIndex;

    /// <summary>
    ///     巡逻点列表
    /// </summary>
    private List<Vector2> _patrolPoints = new();

    /// <summary>
    ///     手机退出动作锁定
    /// </summary>
    private bool _phoneExitLocked;

    /// <summary>
    ///     手机闲置动画是否激活
    /// </summary>
    private bool _phoneIdleActive;

    /// <summary>
    ///     卡住计时器
    /// </summary>
    private float _stuckTimer;

    /// <summary>
    ///     是否使用物理移动
    /// </summary>
    private bool _usePhysicsMovement = true;

    /// <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 float StuckRepathSeconds { get; set; } = 0.6f;

    /// <summary>
    ///     卡住距离阈值
    /// </summary>
    [Export]
    public float StuckDistanceEpsilon { get; set; } = 2.0f;

    /// <summary>
    ///     网格重新寻路间隔
    /// </summary>
    [Export]
    public float GridRepathInterval { get; set; } = 0.25f;

    /// <summary>
    ///     调试绘制路径
    /// </summary>
    [Export]
    public bool DebugDrawPath { 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() {
        _animationPlayer = GetNodeOrNull<AnimationPlayer>("AnimationPlayer");
        _campusController = GetTree()?.CurrentScene as CampusController;
        _theme.IsPortrait = false;
        _theme.Use16 = Use16X16Sprites;
        CacheSprites();
        ConfigureCollision();

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

        if (_patrolConfigured) AdvanceTarget();

        PlayIdleAnimation();
        _lastPosition = GlobalPosition;
    }

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

        var hasPatrolTarget = !_behaviorControlEnabled && _patrolPoints.Count > 0;
        if (_behaviorControlEnabled && _behaviorHasTarget) {
            TryBuildPendingGridPath();
        }
        else if (hasPatrolTarget) {
            if (!_hasTarget || (!_gridPathPending && !_gridPathActive)) AdvanceTarget();
            TryBuildPendingGridPath();
        }
        else {
            if (!_phoneIdleActive && !_phoneExitLocked) PlayIdleAnimation();
            return;
        }

        if (_gridPathActive)
            if (ProcessGridPathMovement(delta)) {
                if (hasPatrolTarget && !_gridPathActive) AdvanceTarget();
                return;
            }

        if (_gridPathPending) {
            Velocity = Vector2.Zero;
            if (_usePhysicsMovement) MoveAndSlide();

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

        if (!_phoneIdleActive && !_phoneExitLocked) PlayIdleAnimation();
    }

    /// <summary>
    ///     绘制调试信息
    /// </summary>
    public override void _Draw() {
        if (!DebugDrawPath) return;

        if (_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();

        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;
        _behaviorTarget = target;
        _behaviorHasTarget = true;
        BeginGridTarget(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>
    /// <param name="locationId">地点ID</param>
    public void EnterBuilding(CampusLocationId locationId) {
        _campusController ??= GetTree()?.CurrentScene as CampusController;
        _campusController?.HandleStudentEnterBuilding(this, locationId);
    }

    /// <summary>
    ///     离开建筑时移除头像
    /// </summary>
    /// <param name="locationId">地点ID</param>
    public void ExitBuilding(CampusLocationId locationId) {
        _campusController ??= GetTree()?.CurrentScene as CampusController;
        _campusController?.HandleStudentExitBuilding(this, locationId);
    }

    /// <summary>
    ///     设置网格寻路目标
    /// </summary>
    /// <param name="target">目标位置</param>
    private void BeginGridTarget(Vector2 target) {
        _currentTarget = target;
        _hasTarget = true;
        _stuckTimer = 0.0f;
        _gridPathActive = false;
        _gridPathPending = true;
        _gridPathIndex = 0;
        _gridPathRetryTimer = 0.0f;
        _gridPath.Clear();
        TryBuildPendingGridPath();
    }

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

    /// <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>
    public void ApplyRandomTheme() {
        // 随机替换身体与配件贴图，形成不同主题外观
        if (_theme.IsEmpty()) CacheSprites();

        Debug.Assert(_theme != null, nameof(_theme) + " != null");

        for (Res.Type typeId = 0; typeId < Res.Type.ResTypeMax; typeId++)
            _theme.ApplyComponent(typeId, Res.GetResourcePathWithId(0, typeId, Use16X16Sprites, false, true));
    }

    /// <summary>
    ///     缓存精灵节点
    /// </summary>
    private void CacheSprites() {
        // 缓存子节点引用，避免每帧查找
        _theme.CacheComponent(Res.Type.Accessory, GetNode<Sprite2D>("parts/accessory"));
        _theme.CacheComponent(Res.Type.Body, GetNode<Sprite2D>("parts/body"));
        _theme.CacheComponent(Res.Type.Eye, GetNode<Sprite2D>("parts/eye"));
        _theme.CacheComponent(Res.Type.Hair, GetNode<Sprite2D>("parts/hairstyle"));
        _theme.CacheComponent(Res.Type.Outfit, GetNode<Sprite2D>("parts/outfit"));
        _theme.CacheComponent(Res.Type.Phone, GetNode<Sprite2D>("parts/smartphone"));
    }

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

    /// <summary>
    ///     推进到下一个目标
    /// </summary>
    private void AdvanceTarget() {
        if (_patrolPoints.Count == 0) 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) {
                BeginGridTarget(target);
                return;
            }
        }

        BeginGridTarget(_patrolPoints[_patrolIndex]);
    }

    /// <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;

        _gridPathActive = false;
        _gridPathPending = true;
        _gridPathIndex = 0;
        _gridPath.Clear();
        TryBuildPendingGridPath();
    }

    /// <summary>
    ///     尝试构建挂起的网格路径
    /// </summary>
    private void TryBuildPendingGridPath() {
        if (!_gridPathPending) return;
        if (_gridPathRetryTimer > 0.0f) 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 (DebugDrawPath) QueueRedraw();
    }

    /// <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 (_usePhysicsMovement) MoveAndSlide();

            if (!_phoneIdleActive && !_phoneExitLocked) PlayIdleAnimation();
            UpdateStuckTimer(delta);
            _gridPathActive = false;
            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;

        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 (_campusController == null) _campusController = GetTree()?.CurrentScene as CampusController;

        var path = _campusController?.RequestGridPath(start, target);
        if (path == null || path.Count == 0) return null;

        RemoveImmediateBacktracks(path);
        return SimplifyGridPath(path);
    }

    /// <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>
    ///     面朝方向
    /// </summary>
    private enum FacingDirection {
        Up,
        Down,
        Left,
        Right
    }
}