using UnityEngine;

namespace NBF
{
    /// <summary>
    /// 简单水面接口。你可以替换成自己的水系统。
    /// </summary>
    public interface IWaterSurfaceProvider
    {
        float GetWaterHeight(Vector3 worldPos);
        Vector3 GetWaterNormal(Vector3 worldPos);
    }

    /// <summary>
    /// 浮漂控制模式：
    /// 1. AirPhysics：空中/未入水，使用刚体物理
    /// 2. WaterPresentation：入水后，关闭重力，Y 和旋转由脚本控制
    /// </summary>
    public enum BobberControlMode
    {
        AirPhysics,
        WaterPresentation
    }

    /// <summary>
    /// 漂像事件类型
    /// </summary>
    public enum BobberBiteType
    {
        None,
        Tap, // 轻点：快速下顿再回弹
        MultiTap, // 连顿：连续多次下顿（鱼反复试探）
        SlowSink, // 缓沉：分段下沉，中途短暂停顿
        Lift, // 送漂：上抬至高位后轻微晃动稳住
        BlackDrift, // 黑漂：快速深沉并水平拖拽
        Tremble // 微颤：高频小幅抖动（鱼在蹭饵试探）
    }

    public enum BobberPosture
    {
        Lying, // 躺漂
        Tilted, // 斜漂
        Upright // 立漂
    }

    /// <summary>
    /// 入水后的内部阶段，可供外部查询或驱动 UI/音效
    /// </summary>
    public enum BobberWaterPhase
    {
        Settling, // 刚入水，正在稳定
        Stable, // 正常浮漂
        Biting // 漂像动画中
    }

    public struct BobberWaterConstraintState
    {
        public Vector3 TargetPosition;
        public float PlanarStrength;
        public float UpwardStrength;
        public float DownwardStrength;
        public float MaxCorrection;
    }

    [DisallowMultipleComponent]
    [RequireComponent(typeof(Rigidbody))]
    public class FLineNodeBobberProvider : MonoBehaviour, IFLineNodeConstraintProvider
    {
        [Header("Water")] [Tooltip("没有水提供器时使用固定水位")]
        public float fallbackWaterLevel = 0f;


        [Tooltip("可选：挂实现了 IWaterSurfaceProvider 的组件")]
        public MonoBehaviour waterProviderBehaviour;

        [Header("Enter Water")] [Tooltip("底部进入水面多少米后切换为漂像控制")]
        public float enterWaterDepth = 0.002f;

        [Tooltip("离开水面多少米后回到空中物理。一般给负值做滞回")] public float exitWaterDepth = -0.01f;

        [Header("Entry Animation")] [Tooltip("入水瞬间的初始下顿深度（米），形成自然入水感")]
        public float entryDipAmplitude = 0.012f;

        [Tooltip("入水稳定动画总时长（秒）")] public float entrySettleDuration = 0.8f;

        [Header("Air Hang")] [Tooltip("悬空时是否让浮漂长轴自然沿重力方向下挂")]
        public bool enableAirHangRotation = true;

        [Tooltip("悬空下垂旋转的跟随速度")] public float airHangRotationSpeed = 10f;

        [Tooltip("悬空时，上方支撑方向对平面朝向的影响权重。0=只看重力下垂，1=更多参考上方线段")] [Range(0f, 1f)]
        public float airHangLineInfluence = 0.75f;

        [Tooltip("悬空时优先让刚体本地重心方向朝向重力下方；重心方向不可用时才使用下面的手动轴")]
        public bool preferAirHangCenterOfMass = true;

        [UnityEngine.Serialization.FormerlySerializedAs("airHangUpAxisLocal")] [Tooltip("悬空时，浮漂本地哪个轴代表朝向底部/重心的长轴方向")]
        public Vector3 airHangDownAxisLocal = Vector3.down;

        [Tooltip("悬空时，用于确定绕长轴朝向的本地参考前向")] public Vector3 airHangForwardAxisLocal = Vector3.forward;

        [Header("Geometry")] [Tooltip("浮漂总高度（米）")]
        public float floatHeight = 0.08f;

        [Tooltip("如果 Pivot 在浮漂底部，这里填 0；如果 Pivot 在模型中心，就填底部相对 Pivot 的本地 Y")]
        public float bottomOffsetLocalY = 0f;

        [Header("Base Float")] [Tooltip("基础吃铅比例，决定静止时有多少在水下")] [Range(0.05f, 0.95f)]
        public float baseSubmergeRatio = 0.28f;

        [Tooltip("Y 轴平滑时间，越小响应越快")] public float ySmoothTime = 0.08f;

        [Tooltip("最大竖直速度限制（用于 SmoothDamp）")] public float maxYSpeed = 2f;

        [Tooltip("静止小死区，减少微抖")] public float yDeadZone = 0.0005f;

        [Header("Surface Motion")] [Tooltip("是否启用轻微水面起伏")]
        public bool enableSurfaceBobbing = true;

        [Tooltip("主水面起伏振幅（米）")] public float surfaceBobAmplitude = 0.0015f;

        [Tooltip("主水面起伏频率（Hz）")] public float surfaceBobFrequency = 1.2f;

        [Tooltip("次级起伏振幅比例（主振幅的倍率），使用黄金比例频率增加自然感")] [Range(0f, 1f)]
        public float surfaceBobSecondaryRatio = 0.35f;

        [Header("XZ Motion")] [Tooltip("入水后是否锁定 XZ 到入水点附近")]
        public bool lockXZAroundAnchor = true;

        [Tooltip("XZ 跟随平滑时间")] public float xzSmoothTime = 0.15f;

        [Tooltip("水流/拖拽带来的额外平面偏移最大值")] public float maxPlanarOffset = 0.15f;

        [Tooltip("移漂默认持续推力时间（秒）")] public float driftForceDuration = 0.45f;

        [Header("Water Constraint")] [Tooltip("接入 FLine 自定义约束时，使用求解器驱动水面目标，而不是脚本直接写世界坐标")]
        public bool useSolverWaterConstraint = true;

        [Tooltip("水面对目标 XZ 的平面跟随强度")] [Range(0f, 1f)]
        public float waterConstraintPlanarStrength = 0.12f;

        [Tooltip("浮漂低于目标水位时，向上托回去的强度")] [Range(0f, 1f)]
        public float waterConstraintUpwardStrength = 0.35f;

        [Tooltip("浮漂高于目标水位时，向下拉回去的强度。建议明显小于向上强度，这样鱼线才能把它拉出水面")] [Range(0f, 1f)]
        public float waterConstraintDownwardStrength = 0.05f;

        [Tooltip("每次约束迭代允许的最大修正位移（米）")] public float waterConstraintMaxCorrection = 0.01f;

        [Header("Sink By Weight / Tension")] [Tooltip("外部向下拉力映射为下沉量的系数。你可以把钩/铅/线组的等效向下拉力喂进来")]
        public float downForceToSink = 0.0025f;

        [Tooltip("向下拉力下沉的最大附加量")] public float maxExtraSink = 0.08f;

        [Header("Bottom Touch")] [Tooltip("触底时是否启用修正")]
        public bool enableBottomTouchAdjust = true;

        [Tooltip("触底后减少的下沉量（铅坠到底，漂会回升一点）")] public float bottomTouchLift = 0.01f;

        [Header("Posture Source")] [Tooltip("下方 Lure / 钩组 / 铅坠的刚体。姿态主要根据它和浮漂的相对位置判断")]
        public Rigidbody lureBody;

        [Tooltip("用于归一化的参考长度。一般填：浮漂到 Lure 在正常拉直时的大致长度")]
        public float referenceLength = 0.30f;

        [Header("Posture Threshold")] [Tooltip("最小入水比例。不够时优先躺漂")]
        public float minSubmergeToStand = 0.16f;

        [Tooltip("垂直分量比低于该值时，优先躺漂")] public float verticalLieThreshold = 0.18f;

        [Tooltip("垂直分量比高于该值，且水平分量较小时，允许立漂")] public float verticalUprightThreshold = 0.75f;

        [Tooltip("水平分量比高于该值时，不允许完全立漂")] public float planarTiltThreshold = 0.30f;

        [Tooltip("水平分量明显大于垂直分量时，优先躺漂")] public float planarDominanceMultiplier = 1.20f;

        [Tooltip("姿态切换滞回，防止边界抖动")] public float postureHysteresis = 0.04f;

        [Header("Posture Stability")] [Tooltip("候选姿态需持续多久才真正切换")]
        public float postureConfirmTime = 0.08f;

        [Tooltip("姿态切换后的最短冷却时间，避免来回闪烁")] public float postureSwitchCooldown = 0.10f;

        [Header("Posture Rotation")] [Tooltip("斜漂角度")]
        public float tiltedAngle = 38f;

        [Tooltip("躺漂角度")] public float lyingAngle = 88f;

        [Tooltip("立漂时，平面拉力可附加的最大倾角（度）")] public float uprightMaxTiltAngle = 8f;

        [Tooltip("平面拉力对立漂附加倾角的灵敏度（度/ratio）。值越大，斜向拉力对立漂的影响越明显")]
        public float planarTiltFactor = 120f;

        [Tooltip("平面方向死区，小于该值时保持上一帧方向")] public float planarDirectionDeadZone = 0.01f;

        [Tooltip("平面方向平滑速度")] public float planarDirectionLerpSpeed = 10f;

        [Tooltip("最终旋转 Slerp 速度")] public float rotationLerpSpeed = 8f;

        [Header("Posture Blend")] [Tooltip("躺漂 ↔ 斜漂 角度过渡平滑时间")]
        public float postureBlendSmoothTime = 0.15f;

        [Tooltip("斜漂 ↔ 立漂 角度过渡平滑时间（通常稍慢，立漂更庄重）")]
        public float postureBlendSmoothTimeUpright = 0.22f;

        [Header("Posture Wobble")] [Tooltip("姿态切换时是否启用旋转回弹抖动")]
        public bool enablePostureWobble = true;

        [Tooltip("切换触发的旋转抖动初始角速度（度/秒）")] public float postureWobbleStrength = 10f;

        [Tooltip("旋转抖动弹簧衰减速率。越大衰减越快，值等于 sqrt(k) 的临界阻尼系数")]
        public float postureWobbleDecay = 7f;

        [Header("Debug Input")] [Tooltip("调试：按 R 停止漂像")]
        public bool debugResetKey = true;

        [Tooltip("调试：按 T 触发轻点")] public bool debugTapKey = true;

        [Tooltip("调试：按 Y 触发连顿")] public bool debugMultiTapKey = true;

        [Tooltip("调试：按 G 触发缓沉")] public bool debugSlowSinkKey = true;

        [Tooltip("调试：按 H 触发送漂")] public bool debugLiftKey = true;

        [Tooltip("调试：按 B 触发黑漂")] public bool debugBlackDriftKey = true;

        [Tooltip("调试：按 V 触发微颤")] public bool debugTrembleKey = true;

        [Tooltip("调试：按 N 触发移漂（向 transform.forward 移动 0.1m）")]
        public bool debugDriftKey = true;

        [Header("Debug")] public bool drawDebug = false;

        public bool UseTestPosture;
        public BobberPosture TestPosture;

        // ── 只读公开状态 ──────────────────────────────────────────────
        public BobberControlMode CurrentMode => _mode;
        public BobberPosture CurrentPosture => _posture;
        public BobberWaterPhase CurrentWaterPhase => _waterPhase;
        public float CurrentVerticalRatio => _verticalRatio;
        public float CurrentPlanarRatio => _planarRatio;
        public bool UsesSolverWaterConstraint => useSolverWaterConstraint && _logicNode != null;

        /// <summary>连续姿态混合值：0=躺漂, 1=斜漂, 2=立漂。可直接驱动外部动画混合树。</summary>
        public float PostureBlendValue => _postureBlendValue;

        // ── 外部可写输入 ───────────────────────────────────────────────
        /// <summary>等效向下拉力（不必须是真实力，作为输入信号即可）</summary>
        public float ExternalDownForce { get; set; }

        /// <summary>是否触底</summary>
        public bool IsBottomTouched { get; set; }

        /// <summary>额外平面偏移（例如风、水流、拖拽）</summary>
        public Vector2 ExternalPlanarOffset { get; set; }

        // ── 事件 ──────────────────────────────────────────────────────
        /// <summary>姿态切换完成时触发：(旧姿态, 新姿态)</summary>
        public event System.Action<BobberPosture, BobberPosture> OnPostureChanged;

        public bool TryGetWaterConstraintState(out BobberWaterConstraintState state)
        {
            state = default;

            if (!UsesSolverWaterConstraint || _mode != BobberControlMode.WaterPresentation)
                return false;

            state.TargetPosition = _constraintTargetPosition;
            state.PlanarStrength = Mathf.Clamp01(waterConstraintPlanarStrength);
            state.UpwardStrength = Mathf.Clamp01(waterConstraintUpwardStrength);
            state.DownwardStrength = Mathf.Clamp01(waterConstraintDownwardStrength);
            state.MaxCorrection = Mathf.Max(0f, waterConstraintMaxCorrection);
            return true;
        }

        public bool TryGetConstraintState(out FLineNodeConstraintState state)
        {
            state = default;

            if (!TryGetWaterConstraintState(out BobberWaterConstraintState waterState))
                return false;

            state.TargetPosition = waterState.TargetPosition;
            state.PlanarStrength = waterState.PlanarStrength;
            state.UpwardStrength = waterState.UpwardStrength;
            state.DownwardStrength = waterState.DownwardStrength;
            state.MaxCorrection = waterState.MaxCorrection;
            return true;
        }

        // ── 核心私有字段 ───────────────────────────────────────────────
        private Rigidbody _rb;
        private FLineLogicNode _logicNode;
        private IWaterSurfaceProvider _waterProvider;
        private BobberControlMode _mode = BobberControlMode.AirPhysics;
        private BobberPosture _posture = BobberPosture.Lying;
        private BobberWaterPhase _waterPhase = BobberWaterPhase.Stable;

        private float _defaultLinearDamping;
        private float _defaultAngularDamping;
        private bool _defaultUseGravity;

        private Vector3 _waterAnchorPos;
        private Vector3 _xzSmoothVelocity;
        private float _ySmoothVelocity;

        private float _biteOffsetY;
        private float _biteOffsetYVelocity;
        private Quaternion _targetRotation;
        private Vector3 _constraintTargetPosition;

        // 漂像运行时
        private BobberBiteType _activeBiteType = BobberBiteType.None;
        private float _biteTimer;
        private float _biteDuration;
        private float _biteAmplitude;
        private Vector3 _blackDriftDirection;
        private int _multiTapTotalCount;
        private float _trembleRuntimeFreq = 10f;

        // 姿态判断运行时
        private float _verticalRatio;
        private float _planarRatio;
        private float _verticalDistance;
        private float _planarDistance;
        private BobberPosture _pendingPosture;
        private float _pendingPostureTimer;
        private float _postureCooldownTimer;
        private Vector3 _stablePlanarDir = Vector3.forward;

        // 姿态平滑混合（0=躺, 1=斜, 2=立）
        private float _postureBlendValue;
        private float _postureBlendVelocity;

        // 旋转回弹弹簧（spring-damper）
        private float _rotWobble;
        private float _rotWobbleVel;

        // 入水稳定动画
        private float _entrySettleTimer;
        private float _entrySettleOffsetY;

        // 移漂运行时：驱动水面锚点在 XZ 平面移动到目标距离后停下
        private bool _isDriftForceActive;
        private Vector3 _driftStartAnchorPos;
        private Vector3 _driftForceDirection;
        private float _driftForceTimer;
        private float _driftForceDuration;

        // 水面起伏实例随机相位
        private float _bobPhaseOffset;

        // Crest 波面查询
        private bool _hasCrestSampleThisFrame;
        private readonly Vector3[] _waterQueryPoints = new Vector3[1];
        private readonly Vector3[] _waterQueryResultDisplacements = new Vector3[1];
        private readonly Vector3[] _waterQueryResultVelocities = new Vector3[1];
        private readonly Vector3[] _waterQueryResultNormal = new Vector3[1];

        private void Awake()
        {
            _rb = GetComponent<Rigidbody>();
            _logicNode = GetComponent<FLineLogicNode>();

            _defaultLinearDamping = _rb.linearDamping;
            _defaultAngularDamping = _rb.angularDamping;
            _defaultUseGravity = _rb.useGravity;

            if (waterProviderBehaviour != null)
                _waterProvider = waterProviderBehaviour as IWaterSurfaceProvider;

            _pendingPosture = _posture;
            _pendingPostureTimer = 0f;
            _postureCooldownTimer = 0f;

            _stablePlanarDir = Vector3.ProjectOnPlane(transform.forward, Vector3.up);
            if (_stablePlanarDir.sqrMagnitude < 1e-6f) _stablePlanarDir = Vector3.forward;
            else _stablePlanarDir.Normalize();

            _targetRotation = transform.rotation;
            _constraintTargetPosition = transform.position;
            _postureBlendValue = PostureToBlend(_posture);

            // 随机相位，避免多个浮漂同步起伏
            _bobPhaseOffset = Random.value * Mathf.PI * 2f;
        }

        private void Update()
        {
            HandleDebugKeys();
        }

        private void FixedUpdate()
        {
            float waterY = GetWaterHeight(transform.position);
            Vector3 bottomWorld = GetBottomWorldPosition();
            float submergeDepth = waterY - bottomWorld.y;

            switch (_mode)
            {
                case BobberControlMode.AirPhysics:
                    UpdateAirPhysics(waterY, submergeDepth);
                    break;
                case BobberControlMode.WaterPresentation:
                    UpdateWaterPresentation(waterY, submergeDepth);
                    break;
            }

            if (drawDebug)
                DrawDebug(waterY);
        }

        #region Main Update

        private void UpdateAirPhysics(float waterY, float submergeDepth)
        {
            RestoreAirPhysicsState();
            UpdateAirHangRotation();

            if (submergeDepth > enterWaterDepth)
                EnterWaterPresentationMode(waterY);
        }

        private void UpdateWaterPresentation(float waterY, float submergeDepth)
        {
            if (submergeDepth < exitWaterDepth)
            {
                ExitWaterPresentationMode();
                return;
            }

            if (UsesSolverWaterConstraint)
            {
                UpdateSolverDrivenWaterPresentation(waterY);
                return;
            }

            // 入水后由脚本/约束统一驱动目标位姿，刚体速度压制掉避免额外干扰
            _rb.useGravity = false;
            _rb.linearVelocity = Vector3.zero;
            _rb.angularVelocity = Vector3.zero;
            _rb.linearDamping = 999f;
            _rb.angularDamping = 999f;

            TickWaterPresentationState();

            Vector3 pos = transform.position;

            // 1. 目标 Y
            float targetY = CalculateTargetY(waterY);

            if (Mathf.Abs(pos.y - targetY) < yDeadZone)
            {
                pos.y = targetY;
                _ySmoothVelocity = 0f;
            }
            else
            {
                pos.y = Mathf.SmoothDamp(
                    pos.y, targetY,
                    ref _ySmoothVelocity,
                    Mathf.Max(0.0001f, ySmoothTime),
                    maxYSpeed,
                    Time.fixedDeltaTime
                );
            }

            // 2. 目标 XZ
            Vector3 targetXZ = CalculateTargetXZ();
            Vector3 planarPos = new Vector3(pos.x, 0f, pos.z);
            Vector3 planarTarget = new Vector3(targetXZ.x, 0f, targetXZ.z);

            planarPos = Vector3.SmoothDamp(
                planarPos, planarTarget,
                ref _xzSmoothVelocity,
                Mathf.Max(0.0001f, xzSmoothTime),
                Mathf.Infinity,
                Time.fixedDeltaTime
            );
            pos.x = planarPos.x;
            pos.z = planarPos.z;

            transform.position = pos;
            _constraintTargetPosition = pos;

            UpdateWaterPresentationRotation(waterY);
        }

        private void UpdateSolverDrivenWaterPresentation(float waterY)
        {
            _rb.useGravity = false;
            _rb.angularVelocity = Vector3.zero;
            _rb.linearDamping = _defaultLinearDamping;
            _rb.angularDamping = _defaultAngularDamping;

            TickWaterPresentationState();
            UpdateConstraintTargetPosition(waterY);
            UpdateWaterPresentationRotation(waterY);
        }

        private void TickWaterPresentationState()
        {
            if (_entrySettleTimer > 0f)
            {
                _entrySettleTimer -= Time.fixedDeltaTime;
                if (_entrySettleTimer <= 0f)
                {
                    _entrySettleTimer = 0f;
                    _waterPhase = _activeBiteType != BobberBiteType.None
                        ? BobberWaterPhase.Biting
                        : BobberWaterPhase.Stable;
                }
            }

            UpdateBiteAnimation();
            UpdateDriftForce();
            UpdateRotationWobble();
        }

        private void UpdateConstraintTargetPosition(float waterY)
        {
            Vector3 pos = _constraintTargetPosition;

            float targetY = CalculateTargetY(waterY);
            if (Mathf.Abs(pos.y - targetY) < yDeadZone)
            {
                pos.y = targetY;
                _ySmoothVelocity = 0f;
            }
            else
            {
                pos.y = Mathf.SmoothDamp(
                    pos.y, targetY,
                    ref _ySmoothVelocity,
                    Mathf.Max(0.0001f, ySmoothTime),
                    maxYSpeed,
                    Time.fixedDeltaTime
                );
            }

            Vector3 targetXZ = CalculateTargetXZ();
            Vector3 planarPos = new Vector3(pos.x, 0f, pos.z);
            Vector3 planarTarget = new Vector3(targetXZ.x, 0f, targetXZ.z);

            planarPos = Vector3.SmoothDamp(
                planarPos, planarTarget,
                ref _xzSmoothVelocity,
                Mathf.Max(0.0001f, xzSmoothTime),
                Mathf.Infinity,
                Time.fixedDeltaTime
            );

            pos.x = planarPos.x;
            pos.z = planarPos.z;
            _constraintTargetPosition = pos;
        }

        private void UpdateWaterPresentationRotation(float waterY)
        {
            EvaluatePostureByComponents(waterY);
            UpdateTargetRotationByPosture();

            transform.rotation = Quaternion.Slerp(
                transform.rotation,
                _targetRotation,
                1f - Mathf.Exp(-rotationLerpSpeed * Time.fixedDeltaTime)
            );
        }

        #endregion

        #region Mode Switch

        private void EnterWaterPresentationMode(float waterY)
        {
            _mode = BobberControlMode.WaterPresentation;

            _waterAnchorPos = transform.position;
            _constraintTargetPosition = transform.position;
            _ySmoothVelocity = 0f;
            _xzSmoothVelocity = Vector3.zero;
            _biteOffsetY = 0f;
            _biteOffsetYVelocity = 0f;
            _activeBiteType = BobberBiteType.None;
            _biteTimer = 0f;

            // 启动入水稳定动画
            _entrySettleTimer = Mathf.Max(0f, entrySettleDuration);
            _entrySettleOffsetY = CalculateInitialEntrySettleOffset(waterY);
            _waterPhase = BobberWaterPhase.Settling;

            // 重置姿态至躺漂
            _posture = BobberPosture.Lying;
            _verticalRatio = 0f;
            _planarRatio = 0f;
            _verticalDistance = 0f;
            _planarDistance = 0f;
            _pendingPosture = _posture;
            _pendingPostureTimer = 0f;
            _postureCooldownTimer = 0f;
            _postureBlendValue = PostureToBlend(_posture);
            _postureBlendVelocity = 0f;

            // 重置旋转弹簧
            _rotWobble = 0f;
            _rotWobbleVel = 0f;

            // 重置移漂
            _isDriftForceActive = false;
            _driftStartAnchorPos = _waterAnchorPos;
            _driftForceDirection = Vector3.zero;
            _driftForceTimer = 0f;
            _driftForceDuration = 0f;

            _stablePlanarDir = Vector3.ProjectOnPlane(transform.forward, Vector3.up);
            if (_stablePlanarDir.sqrMagnitude < 1e-6f) _stablePlanarDir = Vector3.forward;
            else _stablePlanarDir.Normalize();

            _rb.useGravity = false;
            _rb.linearVelocity = Vector3.zero;
            _rb.angularVelocity = Vector3.zero;
            _rb.linearDamping = 999f;
            _rb.angularDamping = 999f;
        }

        private void ExitWaterPresentationMode()
        {
            _mode = BobberControlMode.AirPhysics;
            _waterPhase = BobberWaterPhase.Stable;
            _constraintTargetPosition = transform.position;
            _entrySettleOffsetY = 0f;
            RestoreAirPhysicsState();
        }

        private void RestoreAirPhysicsState()
        {
            _rb.useGravity = _defaultUseGravity;
            _rb.linearDamping = _defaultLinearDamping;
            _rb.angularDamping = _defaultAngularDamping;
        }

        private void UpdateAirHangRotation()
        {
            if (!enableAirHangRotation || !_rb || _rb.isKinematic)
                return;

            Vector3 gravity = Physics.gravity;
            if (gravity.sqrMagnitude < 1e-6f)
                return;

            Vector3 gravityDown = gravity.normalized;
            Vector3 gravityUp = -gravityDown;

            Vector3 supportUp = gravityUp;
            bool hasUpperSupport = TryGetAirHangSupportDirection(gravityUp, out supportUp);

            Vector3 targetDown = gravityDown;

            Vector3 forwardHint = Vector3.zero;
            if (hasUpperSupport)
            {
                Vector3 supportPlanar = Vector3.ProjectOnPlane(supportUp, targetDown);
                if (supportPlanar.sqrMagnitude > 1e-6f)
                {
                    supportPlanar.Normalize();

                    Vector3 stablePlanar = Vector3.ProjectOnPlane(_stablePlanarDir, targetDown);
                    if (stablePlanar.sqrMagnitude < 1e-6f)
                        stablePlanar = supportPlanar;
                    else
                        stablePlanar.Normalize();

                    forwardHint = Vector3.Slerp(stablePlanar, supportPlanar, Mathf.Clamp01(airHangLineInfluence));
                }
            }

            if (forwardHint.sqrMagnitude < 1e-6f)
                forwardHint = Vector3.ProjectOnPlane(_stablePlanarDir, targetDown);

            if (forwardHint.sqrMagnitude < 1e-6f)
                forwardHint = Vector3.ProjectOnPlane(transform.forward, targetDown);

            if (forwardHint.sqrMagnitude < 1e-6f)
                forwardHint = Vector3.ProjectOnPlane(Vector3.forward, targetDown);

            if (forwardHint.sqrMagnitude < 1e-6f)
                forwardHint = Vector3.ProjectOnPlane(Vector3.right, targetDown);

            forwardHint.Normalize();

            if (_stablePlanarDir.sqrMagnitude > 1e-6f && Vector3.Dot(forwardHint, _stablePlanarDir) < 0f)
                forwardHint = -forwardHint;

            Vector3 localDown = ResolveAirHangDownAxisLocal();
            Quaternion targetRotation = BuildAxisAlignedRotation(targetDown, forwardHint, localDown);
            float blend = 1f - Mathf.Exp(-Mathf.Max(0.01f, airHangRotationSpeed) * Time.fixedDeltaTime);
            Quaternion nextRotation = Quaternion.Slerp(_rb.rotation, targetRotation, blend);

            _rb.angularVelocity = Vector3.zero;
            _rb.MoveRotation(nextRotation);

            Vector3 projectedForward = Vector3.ProjectOnPlane(nextRotation * Vector3.forward, targetDown);
            if (projectedForward.sqrMagnitude > 1e-6f)
                _stablePlanarDir = projectedForward.normalized;
        }

        private bool TryGetAirHangSupportDirection(Vector3 gravityUp, out Vector3 supportUp)
        {
            supportUp = gravityUp;

            if (_logicNode == null ||
                !_logicNode.TryGetAdjacentBodies(out Rigidbody previousBody, out Rigidbody nextBody))
                return false;

            Vector3 currentPos = _rb.worldCenterOfMass;
            Vector3 upperDirection = Vector3.zero;
            float bestUpperDot = float.NegativeInfinity;

            TryConsumeNeighbor(previousBody, currentPos, gravityUp, ref upperDirection, ref bestUpperDot);
            TryConsumeNeighbor(nextBody, currentPos, gravityUp, ref upperDirection, ref bestUpperDot);

            if (upperDirection.sqrMagnitude > 1e-6f && bestUpperDot > 0.05f)
            {
                supportUp = upperDirection;
                return true;
            }

            return false;
        }

        private static void TryConsumeNeighbor(
            Rigidbody neighborBody,
            Vector3 currentPos,
            Vector3 gravityUp,
            ref Vector3 upperDirection,
            ref float bestUpperDot)
        {
            if (!neighborBody)
                return;

            Vector3 toNeighbor = neighborBody.worldCenterOfMass - currentPos;
            if (toNeighbor.sqrMagnitude < 1e-6f)
                return;

            Vector3 dir = toNeighbor.normalized;
            float upDot = Vector3.Dot(dir, gravityUp);
            if (upDot > bestUpperDot)
            {
                bestUpperDot = upDot;
                upperDirection = dir;
            }
        }

        private Vector3 ResolveAirHangDownAxisLocal()
        {
            if (preferAirHangCenterOfMass && _rb)
            {
                Vector3 centerOfMassLocal = _rb.centerOfMass;
                if (centerOfMassLocal.sqrMagnitude > 1e-6f)
                    return centerOfMassLocal.normalized;
            }

            return airHangDownAxisLocal.sqrMagnitude > 1e-6f
                ? airHangDownAxisLocal.normalized
                : Vector3.down;
        }

        private Quaternion BuildAxisAlignedRotation(Vector3 targetDown, Vector3 forwardHint, Vector3 localDownAxis)
        {
            Vector3 safeDown = targetDown.sqrMagnitude > 1e-6f ? targetDown.normalized : Vector3.down;
            Vector3 safeUp = -safeDown;
            Vector3 safeForward = Vector3.ProjectOnPlane(forwardHint, safeDown);
            if (safeForward.sqrMagnitude < 1e-6f)
                safeForward = Vector3.ProjectOnPlane(Vector3.forward, safeDown);
            if (safeForward.sqrMagnitude < 1e-6f)
                safeForward = Vector3.ProjectOnPlane(Vector3.right, safeDown);
            safeForward.Normalize();

            Vector3 localDown = localDownAxis.sqrMagnitude > 1e-6f ? localDownAxis.normalized : Vector3.down;
            Vector3 localUp = -localDown;
            Vector3 localForward = Vector3.ProjectOnPlane(airHangForwardAxisLocal, localDown);
            if (localForward.sqrMagnitude < 1e-6f)
                localForward = Vector3.ProjectOnPlane(Vector3.forward, localDown);
            if (localForward.sqrMagnitude < 1e-6f)
                localForward = Vector3.ProjectOnPlane(Vector3.right, localDown);
            localForward.Normalize();

            Quaternion worldBasis = Quaternion.LookRotation(safeForward, safeUp);
            Quaternion localBasis = Quaternion.LookRotation(localForward, localUp);
            return worldBasis * Quaternion.Inverse(localBasis);
        }

        private float CalculateInitialEntrySettleOffset(float waterY)
        {
            float baseTargetY = CalculateBaseTargetY(waterY);
            float currentOffset = Mathf.Min(0f, transform.position.y - baseTargetY);
            float configuredDip = -Mathf.Max(0f, entryDipAmplitude);
            return Mathf.Min(currentOffset, configuredDip);
        }

        #endregion

        #region Target Calculation

        private float CalculateTargetY(float waterY)
        {
            float targetPivotY = CalculateBaseTargetY(waterY);

            if (_entrySettleTimer <= 0f || entrySettleDuration <= 0f)
                return targetPivotY;

            float phase = 1f - Mathf.Clamp01(_entrySettleTimer / Mathf.Max(0.001f, entrySettleDuration));
            float riseT = Mathf.SmoothStep(0f, 1f, phase);
            return targetPivotY + Mathf.Lerp(_entrySettleOffsetY, 0f, riseT);
        }

        private float CalculateBaseTargetY(float waterY)
        {
            float baseSinkDepth = floatHeight * Mathf.Clamp01(baseSubmergeRatio);

            float sinkByForce = Mathf.Clamp(
                ExternalDownForce * downForceToSink,
                0f, maxExtraSink
            );

            float bottomAdjust = 0f;
            if (enableBottomTouchAdjust && IsBottomTouched)
                bottomAdjust -= bottomTouchLift;

            // 多层水面起伏：主波 + 次波（黄金比例频率），各实例相位随机
            float surfaceBob = 0f;
            if (enableSurfaceBobbing && !_hasCrestSampleThisFrame)
            {
                float t = Time.time;
                float primary = Mathf.Sin(t * surfaceBobFrequency * Mathf.PI * 2f + _bobPhaseOffset)
                                * surfaceBobAmplitude;
                float secondary = Mathf.Sin(t * surfaceBobFrequency * 1.618f * Mathf.PI * 2f + _bobPhaseOffset * 2.1f)
                                  * surfaceBobAmplitude * surfaceBobSecondaryRatio;
                surfaceBob = primary + secondary;
            }

            float totalSink = baseSinkDepth + sinkByForce + bottomAdjust;
            float targetBottomY = waterY - totalSink;
            float targetPivotY = targetBottomY - bottomOffsetLocalY + surfaceBob + _biteOffsetY;

            return targetPivotY;
        }

        private Vector3 CalculateTargetXZ()
        {
            Vector2 planarOffset = Vector2.ClampMagnitude(ExternalPlanarOffset, maxPlanarOffset);
            Vector3 basePos = lockXZAroundAnchor || _isDriftForceActive
                ? _waterAnchorPos
                : transform.position;

            if (_activeBiteType == BobberBiteType.BlackDrift)
            {
                float t = Mathf.Clamp01(_biteDuration > 0f ? _biteTimer / _biteDuration : 1f);
                float drift = Mathf.SmoothStep(0f, 1f, t) * 0.08f;
                Vector3 bd = _blackDriftDirection * drift;
                basePos += new Vector3(bd.x, 0f, bd.z);
            }

            return new Vector3(
                basePos.x + planarOffset.x,
                transform.position.y,
                basePos.z + planarOffset.y
            );
        }

        private void EvaluatePostureByComponents(float waterY)
        {
            float submergeRatio = Mathf.Clamp01(
                (waterY - GetBottomWorldPosition().y) / Mathf.Max(0.0001f, floatHeight)
            );

            bool hasLure = lureBody != null;

            if (!hasLure)
            {
                _verticalDistance = 0f;
                _planarDistance = 0f;
                _verticalRatio = 0f;
                _planarRatio = 0f;
            }
            else
            {
                Vector3 bobberPos = _rb.worldCenterOfMass;
                Vector3 lurePos = lureBody.worldCenterOfMass;
                Vector3 delta = lurePos - bobberPos;

                _verticalDistance = Mathf.Max(0f, Vector3.Dot(delta, Vector3.down));
                _planarDistance = Vector3.ProjectOnPlane(delta, Vector3.up).magnitude;

                float refLen = Mathf.Max(0.0001f, referenceLength);
                _verticalRatio = _verticalDistance / refLen;
                _planarRatio = _planarDistance / refLen;
            }

            BobberPosture desired = DeterminePostureState(submergeRatio, hasLure);
            ApplyPostureWithStability(desired);
        }

        /// <summary>
        /// 姿态状态判断的唯一入口。改规则只改这里，外部负责数据采样和旋转平滑。
        /// </summary>
        private BobberPosture DeterminePostureState(float submergeRatio, bool hasLure)
        {
            if (UseTestPosture)
                return TestPosture;

            // 无 Lure 时的兜底规则
            if (!hasLure)
            {
                if (submergeRatio < minSubmergeToStand)
                    return BobberPosture.Lying;
                if (ExternalPlanarOffset.magnitude > 0.01f)
                    return BobberPosture.Tilted;
                return BobberPosture.Upright;
            }

            // 带滞回的状态机：从当前状态出发，减少来回切换
            switch (_posture)
            {
                case BobberPosture.Lying:
                {
                    bool canStandUpright =
                        submergeRatio >= minSubmergeToStand &&
                        _verticalRatio > verticalUprightThreshold + postureHysteresis &&
                        _planarRatio < planarTiltThreshold - postureHysteresis;

                    bool canTilt =
                        submergeRatio >= minSubmergeToStand * 0.8f &&
                        _verticalRatio > verticalLieThreshold + postureHysteresis;

                    if (canStandUpright) return BobberPosture.Upright;
                    if (canTilt) return BobberPosture.Tilted;
                    return BobberPosture.Lying;
                }

                case BobberPosture.Tilted:
                {
                    bool shouldLie =
                        submergeRatio < minSubmergeToStand * 0.75f ||
                        _verticalRatio < verticalLieThreshold - postureHysteresis ||
                        _planarDistance > _verticalDistance * planarDominanceMultiplier;

                    bool shouldStand =
                        submergeRatio >= minSubmergeToStand &&
                        _verticalRatio > verticalUprightThreshold + postureHysteresis &&
                        _planarRatio < planarTiltThreshold - postureHysteresis;

                    if (shouldLie) return BobberPosture.Lying;
                    if (shouldStand) return BobberPosture.Upright;
                    return BobberPosture.Tilted;
                }

                default: // Upright
                {
                    bool shouldLie =
                        submergeRatio < minSubmergeToStand * 0.75f ||
                        _verticalRatio < verticalLieThreshold - postureHysteresis ||
                        _planarDistance > _verticalDistance * (planarDominanceMultiplier + 0.15f);

                    bool shouldTilt =
                        _verticalRatio < verticalUprightThreshold - postureHysteresis ||
                        _planarRatio > planarTiltThreshold + postureHysteresis;

                    if (shouldLie) return BobberPosture.Lying;
                    if (shouldTilt) return BobberPosture.Tilted;
                    return BobberPosture.Upright;
                }
            }
        }

        private void ApplyPostureWithStability(BobberPosture desiredPosture)
        {
            _postureCooldownTimer = Mathf.Max(0f, _postureCooldownTimer - Time.fixedDeltaTime);

            if (desiredPosture == _posture)
            {
                _pendingPosture = _posture;
                _pendingPostureTimer = 0f;
                return;
            }

            if (_postureCooldownTimer > 0f)
            {
                _pendingPosture = desiredPosture;
                _pendingPostureTimer = 0f;
                return;
            }

            if (_pendingPosture != desiredPosture)
            {
                _pendingPosture = desiredPosture;
                _pendingPostureTimer = 0f;
                return;
            }

            _pendingPostureTimer += Time.fixedDeltaTime;
            if (_pendingPostureTimer >= Mathf.Max(0f, postureConfirmTime))
            {
                BobberPosture oldPosture = _posture;
                _posture = desiredPosture;
                _pendingPosture = _posture;
                _pendingPostureTimer = 0f;
                _postureCooldownTimer = Mathf.Max(0f, postureSwitchCooldown);

                OnPostureTransition(oldPosture, _posture);
            }
        }

        /// <summary>
        /// 姿态切换完成时：触发外部事件，并向弹簧注入回弹初速。
        /// </summary>
        private void OnPostureTransition(BobberPosture from, BobberPosture to)
        {
            OnPostureChanged?.Invoke(from, to);

            if (!enablePostureWobble) return;

            // (int)Lying=0 < Tilted=1 < Upright=2
            // 向更立漂方向切换 → 角度减小 → 初始抖动为负（先过冲再弹回）
            // 向更躺漂方向切换 → 角度增大 → 初始抖动为正
            float sign = (int)to > (int)from ? -1f : 1f;
            _rotWobbleVel += sign * postureWobbleStrength;
        }

        private void UpdateTargetRotationByPosture()
        {
            // ── 更新平面稳定方向 ────────────────────────────────────────
            Vector3 candidateDir = Vector3.zero;

            if (lureBody != null)
                candidateDir = Vector3.ProjectOnPlane(
                    lureBody.worldCenterOfMass - _rb.worldCenterOfMass, Vector3.up);

            if (candidateDir.sqrMagnitude < 1e-6f)
                candidateDir = new Vector3(_xzSmoothVelocity.x, 0f, _xzSmoothVelocity.z);

            if (candidateDir.sqrMagnitude < 1e-6f)
                candidateDir = new Vector3(ExternalPlanarOffset.x, 0f, ExternalPlanarOffset.y);

            if (_stablePlanarDir.sqrMagnitude < 1e-6f)
            {
                _stablePlanarDir = Vector3.ProjectOnPlane(transform.forward, Vector3.up);
                if (_stablePlanarDir.sqrMagnitude < 1e-6f) _stablePlanarDir = Vector3.forward;
            }

            _stablePlanarDir.Normalize();

            float dirDeadZone = Mathf.Max(0.0001f, planarDirectionDeadZone);
            if (candidateDir.sqrMagnitude > dirDeadZone * dirDeadZone)
            {
                candidateDir.Normalize();

                // 避免 180° 翻转闪烁
                if (Vector3.Dot(candidateDir, _stablePlanarDir) < 0f)
                    candidateDir = -candidateDir;

                float k = 1f - Mathf.Exp(-Mathf.Max(0.01f, planarDirectionLerpSpeed) * Time.fixedDeltaTime);
                _stablePlanarDir = Vector3.Slerp(_stablePlanarDir, candidateDir, k);
                _stablePlanarDir.Normalize();
            }

            // ── 姿态混合值平滑（0=躺, 1=斜, 2=立）──────────────────────
            float targetBlend = PostureToBlend(_posture);

            // 躺↔斜 用较短时间，斜↔立 用较长时间（立漂更稳重）
            bool involveUpright = (_postureBlendValue > 1f) || (targetBlend > 1f);
            float blendTime = involveUpright ? postureBlendSmoothTimeUpright : postureBlendSmoothTime;

            _postureBlendValue = Mathf.SmoothDamp(
                _postureBlendValue, targetBlend,
                ref _postureBlendVelocity,
                Mathf.Max(0.001f, blendTime),
                Mathf.Infinity,
                Time.fixedDeltaTime
            );

            // ── 从混合值计算目标倾角 ────────────────────────────────────
            float baseAngle;
            if (_postureBlendValue <= 1f)
            {
                // 躺漂(lyingAngle) ↔ 斜漂(tiltedAngle)
                baseAngle = Mathf.Lerp(lyingAngle, tiltedAngle, _postureBlendValue);
            }
            else
            {
                // 斜漂(tiltedAngle) ↔ 立漂(uprightTilt)
                // 立漂时根据平面拉力给出微小附加倾角，planarTiltFactor 控制灵敏度
                float uprightTilt = Mathf.Clamp(_planarRatio * planarTiltFactor, 0f, uprightMaxTiltAngle);
                baseAngle = Mathf.Lerp(tiltedAngle, uprightTilt, _postureBlendValue - 1f);
            }

            // 叠加旋转回弹抖动
            float finalAngle = baseAngle + _rotWobble;

            // ── 构建目标旋转 ─────────────────────────────────────────────
            Vector3 tiltAxis = Vector3.Cross(Vector3.up, _stablePlanarDir);
            if (tiltAxis.sqrMagnitude < 1e-6f)
                tiltAxis = transform.right;

            _targetRotation = Quaternion.AngleAxis(finalAngle, tiltAxis.normalized);
        }

        /// <summary>
        /// 临界阻尼弹簧：k = decay², damper = 2*decay，每帧调用以衰减旋转抖动。
        /// </summary>
        private void UpdateRotationWobble()
        {
            if (Mathf.Abs(_rotWobble) < 0.01f && Mathf.Abs(_rotWobbleVel) < 0.01f)
            {
                _rotWobble = 0f;
                _rotWobbleVel = 0f;
                return;
            }

            float d = Mathf.Max(0.01f, postureWobbleDecay);
            float spring = -(d * d) * _rotWobble;
            float damper = -(2f * d) * _rotWobbleVel;

            _rotWobbleVel += (spring + damper) * Time.fixedDeltaTime;
            _rotWobble += _rotWobbleVel * Time.fixedDeltaTime;
        }

        #endregion

        #region Bite Presentation

        /// <summary>轻点：快速下顿再回弹</summary>
        public void PlayTap(float amplitude = 0.008f, float duration = 0.18f)
        {
            StartBite(BobberBiteType.Tap, amplitude, duration);
        }

        /// <summary>连顿：count 次连续下顿，每顿之间轻微回弹，振幅略微衰减</summary>
        public void PlayMultiTap(int count = 3, float amplitude = 0.006f, float intervalPerTap = 0.22f)
        {
            _multiTapTotalCount = Mathf.Max(1, count);
            StartBite(BobberBiteType.MultiTap, amplitude, intervalPerTap * _multiTapTotalCount);
        }

        /// <summary>缓沉：分段下沉，40% 处有短暂停顿感（鱼吞饵试探）</summary>
        public void PlaySlowSink(float amplitude = 0.025f, float duration = 1.2f)
        {
            StartBite(BobberBiteType.SlowSink, amplitude, duration);
        }

        /// <summary>送漂：快速上抬至峰值，之后轻微振荡稳住</summary>
        public void PlayLift(float amplitude = 0.015f, float duration = 1.2f)
        {
            StartBite(BobberBiteType.Lift, amplitude, duration);
        }

        /// <summary>黑漂：快速深沉并可配合平面拖拽</summary>
        public void PlayBlackDrift(float amplitude = 0.06f, float duration = 0.8f, Vector3? driftDirection = null)
        {
            StartBite(BobberBiteType.BlackDrift, amplitude, duration);
            _blackDriftDirection = (driftDirection ?? transform.forward).normalized;
        }

        /// <summary>微颤：高频小幅抖动，振幅随时间衰减（鱼蹭饵试探）</summary>
        public void PlayTremble(float amplitude = 0.004f, float duration = 1.5f, float frequency = 10f)
        {
            _trembleRuntimeFreq = Mathf.Max(1f, frequency);
            StartBite(BobberBiteType.Tremble, amplitude, duration);
        }

        /// <summary>移漂：按给定世界方向在 XZ 平面平移指定距离。</summary>
        public void PlayDrift(Vector3 direction, float distance)
        {
            PlayDrift(direction, distance, driftForceDuration);
        }

        /// <summary>移漂：沿给定方向在 XZ 平面移动指定距离，并在目标点停下。</summary>
        public void PlayDrift(Vector3 direction, float distance, float duration)
        {
            if (_mode != BobberControlMode.WaterPresentation)
                return;

            Vector3 planarDirection = Vector3.ProjectOnPlane(direction, Vector3.up);
            if (planarDirection.sqrMagnitude < 1e-6f || Mathf.Approximately(distance, 0f))
                return;

            float safeDuration = Mathf.Max(0.02f, duration);

            SyncWaterAnchorToCurrentXZ();

            _driftStartAnchorPos = _waterAnchorPos;
            _driftForceDirection = planarDirection.normalized * distance;
            _driftForceTimer = 0f;
            _driftForceDuration = safeDuration;
            _isDriftForceActive = true;
            _xzSmoothVelocity = Vector3.zero;
        }

        public void StopDrift()
        {
            _isDriftForceActive = false;
            _driftForceTimer = 0f;
            _driftForceDuration = 0f;
            _driftForceDirection = Vector3.zero;
            _xzSmoothVelocity = Vector3.zero;
            SyncWaterAnchorToCurrentXZ();
        }

        public void StopBite()
        {
            _activeBiteType = BobberBiteType.None;
            _biteTimer = 0f;
            _biteDuration = 0f;
            _biteAmplitude = 0f;
            _biteOffsetY = 0f;
            _biteOffsetYVelocity = 0f;

            if (_waterPhase == BobberWaterPhase.Biting)
                _waterPhase = BobberWaterPhase.Stable;
        }

        private void UpdateDriftForce()
        {
            if (!_isDriftForceActive)
                return;

            _driftForceTimer += Time.fixedDeltaTime;
            float t = Mathf.Clamp01(_driftForceTimer / Mathf.Max(0.0001f, _driftForceDuration));
            float easedT = Mathf.SmoothStep(0f, 1f, t);
            _waterAnchorPos = _driftStartAnchorPos + _driftForceDirection * easedT;

            if (t < 1f)
                return;

            _waterAnchorPos = _driftStartAnchorPos + _driftForceDirection;
            _isDriftForceActive = false;
            _driftForceTimer = 0f;
            _driftForceDuration = 0f;
            _driftForceDirection = Vector3.zero;
            _xzSmoothVelocity = Vector3.zero;
        }

        private void StartBite(BobberBiteType type, float amplitude, float duration)
        {
            if (_mode != BobberControlMode.WaterPresentation)
                return;

            _activeBiteType = type;
            _biteTimer = 0f;
            _biteDuration = Mathf.Max(0.01f, duration);
            _biteAmplitude = amplitude;
            _biteOffsetYVelocity = 0f;

            if (type == BobberBiteType.BlackDrift && _blackDriftDirection.sqrMagnitude < 1e-6f)
                _blackDriftDirection = transform.forward.sqrMagnitude > 1e-6f
                    ? transform.forward.normalized
                    : Vector3.forward;

            if (_waterPhase != BobberWaterPhase.Settling)
                _waterPhase = BobberWaterPhase.Biting;
        }

        private void UpdateBiteAnimation()
        {
            if (_activeBiteType == BobberBiteType.None)
            {
                _biteOffsetY = Mathf.SmoothDamp(
                    _biteOffsetY, 0f,
                    ref _biteOffsetYVelocity,
                    0.08f, Mathf.Infinity, Time.fixedDeltaTime
                );
                return;
            }

            _biteTimer += Time.fixedDeltaTime;
            float t = Mathf.Clamp01(_biteTimer / _biteDuration);
            float targetOffset = 0f;

            switch (_activeBiteType)
            {
                case BobberBiteType.Tap:
                {
                    // 前 35% 快速下顿，后 65% 回弹
                    targetOffset = t < 0.35f
                        ? -Mathf.SmoothStep(0f, _biteAmplitude, t / 0.35f)
                        : -Mathf.Lerp(_biteAmplitude, 0f, (t - 0.35f) / 0.65f);
                    break;
                }

                case BobberBiteType.MultiTap:
                {
                    // 每顿时间均分，每顿内模拟单次 Tap 曲线，振幅随顿次轻微衰减
                    int totalTaps = Mathf.Max(1, _multiTapTotalCount);
                    float tapLength = 1f / totalTaps;
                    float cycleT = Mathf.Repeat(t, tapLength) / tapLength;
                    float tapIndex = Mathf.Floor(t / tapLength);
                    float decay = 1f - tapIndex / totalTaps * 0.25f; // 末顿约 75% 振幅

                    targetOffset = cycleT < 0.35f
                        ? -Mathf.SmoothStep(0f, _biteAmplitude * decay, cycleT / 0.35f)
                        : -Mathf.Lerp(_biteAmplitude * decay, 0f, (cycleT - 0.35f) / 0.65f);
                    break;
                }

                case BobberBiteType.SlowSink:
                {
                    // 三段式缓沉：0~40% 渐沉至一半，40~60% 短暂停顿，60~100% 继续下沉
                    float sinkOffset;
                    if (t < 0.4f)
                        sinkOffset = Mathf.SmoothStep(0f, _biteAmplitude * 0.5f, t / 0.4f);
                    else if (t < 0.6f)
                        sinkOffset = _biteAmplitude * 0.5f;
                    else
                        sinkOffset = Mathf.SmoothStep(_biteAmplitude * 0.5f, _biteAmplitude, (t - 0.6f) / 0.4f);
                    targetOffset = -sinkOffset;
                    break;
                }

                case BobberBiteType.Lift:
                {
                    // 前 60% 平滑送起，60%~100% 顶部轻微振荡后稳住
                    if (t < 0.6f)
                    {
                        targetOffset = Mathf.SmoothStep(0f, _biteAmplitude, t / 0.6f);
                    }
                    else
                    {
                        float wobbleT = (t - 0.6f) / 0.4f;
                        float wobble = Mathf.Sin(wobbleT * Mathf.PI * 3f)
                                       * _biteAmplitude * 0.12f * (1f - wobbleT);
                        targetOffset = _biteAmplitude + wobble;
                    }

                    break;
                }

                case BobberBiteType.BlackDrift:
                {
                    // 前 60% 快速深沉，之后维持最大深度
                    float sinkT = Mathf.SmoothStep(0f, 1f, Mathf.Min(t / 0.6f, 1f));
                    targetOffset = -_biteAmplitude * sinkT;
                    break;
                }

                case BobberBiteType.Tremble:
                {
                    // 高频振荡，振幅线性衰减至 0
                    float decay2 = 1f - t;
                    targetOffset = Mathf.Sin(Time.time * _trembleRuntimeFreq * Mathf.PI * 2f)
                                   * _biteAmplitude * decay2;
                    break;
                }
            }

            // Tremble 需要快速响应，其余用标准平滑时间
            float smoothTime = _activeBiteType == BobberBiteType.Tremble ? 0.01f : 0.03f;
            _biteOffsetY = Mathf.SmoothDamp(
                _biteOffsetY, targetOffset,
                ref _biteOffsetYVelocity,
                smoothTime, Mathf.Infinity, Time.fixedDeltaTime
            );

            // 持续类漂像（缓沉/黑漂）到达终点后不自动结束，等外部调用 StopBite
            if (_biteTimer >= _biteDuration)
            {
                if (_activeBiteType == BobberBiteType.SlowSink ||
                    _activeBiteType == BobberBiteType.BlackDrift)
                    return;

                _activeBiteType = BobberBiteType.None;
                if (_waterPhase == BobberWaterPhase.Biting)
                    _waterPhase = BobberWaterPhase.Stable;
            }
        }

        #endregion

        #region Utilities

        private static float PostureToBlend(BobberPosture posture) => posture switch
        {
            BobberPosture.Lying => 0f,
            BobberPosture.Tilted => 1f,
            _ => 2f
        };

        private float GetWaterHeight(Vector3 worldPos)
        {
            if (_waterProvider != null)
            {
                _hasCrestSampleThisFrame = false;
                return _waterProvider.GetWaterHeight(worldPos);
            }

            _hasCrestSampleThisFrame = false;
            return fallbackWaterLevel;
        }

        private Vector3 GetBottomWorldPosition()
        {
            return transform.TransformPoint(new Vector3(0f, bottomOffsetLocalY, 0f));
        }

        private void SyncWaterAnchorToCurrentXZ()
        {
            Vector2 planarOffset = Vector2.ClampMagnitude(ExternalPlanarOffset, maxPlanarOffset);
            Vector3 pos = transform.position;
            _waterAnchorPos = new Vector3(
                pos.x - planarOffset.x,
                _waterAnchorPos.y,
                pos.z - planarOffset.y
            );
        }

        private void HandleDebugKeys()
        {
            if (!Application.isPlaying) return;

            if (debugResetKey && Input.GetKeyDown(KeyCode.R)) StopBite();
            if (debugTapKey && Input.GetKeyDown(KeyCode.T)) PlayTap();
            if (debugMultiTapKey && Input.GetKeyDown(KeyCode.Y)) PlayMultiTap();
            if (debugSlowSinkKey && Input.GetKeyDown(KeyCode.G)) PlaySlowSink();
            if (debugLiftKey && Input.GetKeyDown(KeyCode.H)) PlayLift();
            if (debugBlackDriftKey && Input.GetKeyDown(KeyCode.B)) PlayBlackDrift();
            if (debugTrembleKey && Input.GetKeyDown(KeyCode.V)) PlayTremble();
            if (debugDriftKey && Input.GetKeyDown(KeyCode.N)) PlayDrift(transform.forward, 0.1f);
        }

        private void DrawDebug(float waterY)
        {
            Vector3 p = transform.position;
            Vector3 b = GetBottomWorldPosition();

            Debug.DrawLine(
                new Vector3(p.x - 0.05f, waterY, p.z),
                new Vector3(p.x + 0.05f, waterY, p.z),
                Color.cyan
            );
            Debug.DrawLine(b, b + Vector3.up * floatHeight, Color.yellow);

            if (_mode == BobberControlMode.AirPhysics && enableAirHangRotation)
            {
                Vector3 hangDown = transform.TransformDirection(ResolveAirHangDownAxisLocal());
                Debug.DrawLine(p, p + hangDown * 0.08f, Color.gray);
            }

            if (_mode == BobberControlMode.WaterPresentation)
            {
                Vector3 a = _waterAnchorPos;
                Debug.DrawLine(a + Vector3.left * 0.03f, a + Vector3.right * 0.03f, Color.green);
                Debug.DrawLine(a + Vector3.forward * 0.03f, a + Vector3.back * 0.03f, Color.green);

                // 姿态混合值可视化：白线高度代表 PostureBlendValue（0~2）
                Debug.DrawLine(p, p + Vector3.up * (_postureBlendValue * 0.02f), Color.white);

                if (UsesSolverWaterConstraint)
                {
                    Debug.DrawLine(p, _constraintTargetPosition, Color.cyan);
                    Debug.DrawLine(
                        _constraintTargetPosition + Vector3.left * 0.02f,
                        _constraintTargetPosition + Vector3.right * 0.02f,
                        Color.cyan
                    );
                }
            }

            if (lureBody != null)
            {
                Vector3 bobber = _rb.worldCenterOfMass;
                Vector3 lure = lureBody.worldCenterOfMass;
                Debug.DrawLine(bobber, lure, Color.magenta);

                Vector3 verticalEnd = bobber + Vector3.down * _verticalDistance;
                Debug.DrawLine(bobber, verticalEnd, Color.red);

                Vector3 planar = Vector3.ProjectOnPlane(lure - bobber, Vector3.up);
                Debug.DrawLine(verticalEnd, verticalEnd + planar, Color.blue);
            }
        }

#if UNITY_EDITOR
        private void OnValidate()
        {
            floatHeight = Mathf.Max(0.001f, floatHeight);
            airHangRotationSpeed = Mathf.Max(0.01f, airHangRotationSpeed);
            airHangLineInfluence = Mathf.Clamp01(airHangLineInfluence);
            ySmoothTime = Mathf.Max(0.001f, ySmoothTime);
            maxYSpeed = Mathf.Max(0.01f, maxYSpeed);
            xzSmoothTime = Mathf.Max(0.001f, xzSmoothTime);
            driftForceDuration = Mathf.Max(0.02f, driftForceDuration);
            waterConstraintMaxCorrection = Mathf.Max(0f, waterConstraintMaxCorrection);
            rotationLerpSpeed = Mathf.Max(0.01f, rotationLerpSpeed);
            maxPlanarOffset = Mathf.Max(0f, maxPlanarOffset);
            waterConstraintPlanarStrength = Mathf.Clamp01(waterConstraintPlanarStrength);
            waterConstraintUpwardStrength = Mathf.Clamp01(waterConstraintUpwardStrength);
            waterConstraintDownwardStrength = Mathf.Clamp01(waterConstraintDownwardStrength);
            downForceToSink = Mathf.Max(0f, downForceToSink);
            maxExtraSink = Mathf.Max(0f, maxExtraSink);
            surfaceBobAmplitude = Mathf.Max(0f, surfaceBobAmplitude);
            surfaceBobFrequency = Mathf.Max(0f, surfaceBobFrequency);
            surfaceBobSecondaryRatio = Mathf.Clamp01(surfaceBobSecondaryRatio);
            yDeadZone = Mathf.Max(0f, yDeadZone);

            if (airHangDownAxisLocal.sqrMagnitude < 1e-6f)
                airHangDownAxisLocal = Vector3.down;

            if (airHangForwardAxisLocal.sqrMagnitude < 1e-6f)
                airHangForwardAxisLocal = Vector3.forward;

            referenceLength = Mathf.Max(0.0001f, referenceLength);
            minSubmergeToStand = Mathf.Clamp01(minSubmergeToStand);
            verticalLieThreshold = Mathf.Clamp(verticalLieThreshold, 0f, 2f);
            verticalUprightThreshold = Mathf.Max(verticalLieThreshold, verticalUprightThreshold);
            planarTiltThreshold = Mathf.Clamp(planarTiltThreshold, 0f, 2f);
            planarDominanceMultiplier = Mathf.Max(0.1f, planarDominanceMultiplier);
            postureHysteresis = Mathf.Clamp(postureHysteresis, 0f, 0.3f);
            postureConfirmTime = Mathf.Max(0f, postureConfirmTime);
            postureSwitchCooldown = Mathf.Max(0f, postureSwitchCooldown);

            tiltedAngle = Mathf.Clamp(tiltedAngle, 0f, 89f);
            lyingAngle = Mathf.Clamp(lyingAngle, tiltedAngle, 89.9f);
            uprightMaxTiltAngle = Mathf.Clamp(uprightMaxTiltAngle, 0f, tiltedAngle);
            planarTiltFactor = Mathf.Max(0f, planarTiltFactor);
            planarDirectionDeadZone = Mathf.Max(0.0001f, planarDirectionDeadZone);
            planarDirectionLerpSpeed = Mathf.Max(0.01f, planarDirectionLerpSpeed);

            postureBlendSmoothTime = Mathf.Max(0.001f, postureBlendSmoothTime);
            postureBlendSmoothTimeUpright = Mathf.Max(0.001f, postureBlendSmoothTimeUpright);
            postureWobbleStrength = Mathf.Max(0f, postureWobbleStrength);
            postureWobbleDecay = Mathf.Max(0.01f, postureWobbleDecay);
            entryDipAmplitude = Mathf.Max(0f, entryDipAmplitude);
            entrySettleDuration = Mathf.Max(0f, entrySettleDuration);
        }
#endif

        #endregion
    }
}