using UnityEngine;

namespace NBF
{
    public interface IWaterSurfaceProvider
    {
        float GetWaterHeight(Vector3 worldPos);
        Vector3 GetWaterNormal(Vector3 worldPos);
    }

    public enum BobberControlMode
    {
        AirPhysics,
        WaterPresentation,
    }
    
    public enum BobberBiteType
    {
        None,
        Tap,
        SlowSink,
        Lift,
        BlackDrift,
    }

    public enum BobberPosture
    {
        Lying,
        Tilted,
        Upright,
    }

    [DisallowMultipleComponent]
    [RequireComponent(typeof(Rigidbody))]
    public class FishingFloatFeature : FishingLineNodeMotionFeature
    {
        protected override int DefaultPriority => 100;

        [Header("Water")]
        [Tooltip("没有水提供器时使用固定水位")]
        public float fallbackWaterLevel;

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

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

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

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

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

        [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("水面轻微起伏频率")]
        public float surfaceBobFrequency = 1.2f;

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

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

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

        [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("平面方向对立漂/斜漂附加倾角的影响强度")]
        public float planarTiltFactor = 120f;

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

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

        [Tooltip("姿态平滑速度")]
        public float rotationLerpSpeed = 8f;

        [Header("Debug Input")]
        public bool debugResetKey = true;
        public bool debugTapKey = true;
        public bool debugSlowSinkKey = true;
        public bool debugLiftKey = true;
        public bool debugBlackDriftKey = true;

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

        public bool UseTestPosture;
        public BobberPosture TestPosture;

        public BobberControlMode CurrentMode => _mode;
        public BobberPosture CurrentPosture => _posture;
        public float CurrentVerticalRatio => _verticalRatio;
        public float CurrentPlanarRatio => _planarRatio;

        public float ExternalDownForce { get; set; }
        public bool IsBottomTouched { get; set; }
        public Vector2 ExternalPlanarOffset { get; set; }

        private Rigidbody _rb;
        private IWaterSurfaceProvider _waterProvider;
        private BobberControlMode _mode = BobberControlMode.AirPhysics;
        private BobberPosture _posture = BobberPosture.Lying;

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

        private Vector3 _waterAnchorPos;
        private Vector3 _xzSmoothVelocity;
        private float _ySmoothVelocity;
        private float _biteOffsetY;
        private float _biteOffsetYVelocity;
        private Quaternion _targetRotation;

        private BobberBiteType _activeBiteType = BobberBiteType.None;
        private float _biteTimer;
        private float _biteDuration;
        private float _biteAmplitude;
        private Vector3 _blackDriftDirection;

        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;

        private void Awake()
        {
            EnsureRuntimeReferences();
            InitializeRuntimeState();
        }

        private void Update()
        {
            HandleDebugKeys();
        }

        public override bool IsSupportedNode(FishingLineNode node)
        {
            return node != null && node.Type == FishingLineNode.NodeType.Float;
        }

        protected override void OnBind()
        {
            EnsureRuntimeReferences();
            InitializeRuntimeState();
        }

        public override bool CanControl()
        {
            EnsureRuntimeReferences();
            if (_rb == null || !IsSupportedNode(Node))
            {
                return false;
            }

            var waterY = GetWaterHeight(transform.position);
            var submergeDepth = waterY - GetBottomWorldPosition().y;
            if (_mode == BobberControlMode.WaterPresentation)
            {
                return submergeDepth >= exitWaterDepth;
            }

            return submergeDepth > enterWaterDepth;
        }

        public override void OnMotionActivated()
        {
            EnsureRuntimeReferences();
            EnterWaterPresentationMode();
        }

        public override void OnMotionDeactivated()
        {
            EnsureRuntimeReferences();
            ExitWaterPresentationMode();
        }

        public override void TickMotion(float deltaTime)
        {
            EnsureRuntimeReferences();
            if (_rb == null)
            {
                return;
            }

            var waterY = GetWaterHeight(transform.position);
            var submergeDepth = waterY - GetBottomWorldPosition().y;
            UpdateWaterPresentation(waterY, submergeDepth, deltaTime);

            if (drawDebug)
            {
                DrawDebug(waterY);
            }
        }

        public void PlayTap(float amplitude = 0.008f, float duration = 0.18f)
        {
            StartBite(BobberBiteType.Tap, amplitude, duration);
        }

        public void PlaySlowSink(float amplitude = 0.025f, float duration = 1.2f)
        {
            StartBite(BobberBiteType.SlowSink, amplitude, duration);
        }

        public void PlayLift(float amplitude = 0.015f, float duration = 1.2f)
        {
            StartBite(BobberBiteType.Lift, amplitude, duration);
        }

        public void PlayBlackDrift(float amplitude = 0.06f, float duration = 0.8f, Vector3? driftDirection = null)
        {
            StartBite(BobberBiteType.BlackDrift, amplitude, duration);
            _blackDriftDirection = (driftDirection ?? transform.forward).normalized;
        }

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

        private void EnsureRuntimeReferences()
        {
            if (_rb == null)
            {
                _rb = Node != null && Node.Body != null ? Node.Body : GetComponent<Rigidbody>();
            }

            if (_waterProvider == null && waterProviderBehaviour != null)
            {
                _waterProvider = waterProviderBehaviour as IWaterSurfaceProvider;
            }

        }

        private void InitializeRuntimeState()
        {
            if (_rb == null)
            {
                return;
            }

            if (!_defaultsCached)
            {
                _defaultLinearDamping = _rb.linearDamping;
                _defaultAngularDamping = _rb.angularDamping;
                _defaultUseGravity = _rb.useGravity;
                _defaultsCached = true;
            }

            _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;
        }

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

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

            UpdateBiteAnimation(deltaTime);

            var pos = transform.position;
            var 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,
                    deltaTime);
            }

            var targetXZ = CalculateTargetXZ();
            var planarPos = new Vector3(pos.x, 0f, pos.z);
            var planarTarget = new Vector3(targetXZ.x, 0f, targetXZ.z);
            planarPos = Vector3.SmoothDamp(
                planarPos,
                planarTarget,
                ref _xzSmoothVelocity,
                Mathf.Max(0.0001f, xzSmoothTime),
                Mathf.Infinity,
                deltaTime);

            pos.x = planarPos.x;
            pos.z = planarPos.z;
            transform.position = pos;

            EvaluatePostureByComponents(waterY, deltaTime);
            UpdateTargetRotationByPosture(deltaTime);

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

        private void EnterWaterPresentationMode()
        {
            if (_rb == null)
            {
                return;
            }

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

            _posture = BobberPosture.Lying;
            _verticalRatio = 0f;
            _planarRatio = 0f;
            _verticalDistance = 0f;
            _planarDistance = 0f;
            _pendingPosture = _posture;
            _pendingPostureTimer = 0f;
            _postureCooldownTimer = 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;
            RestoreAirPhysicsState();
        }

        private void RestoreAirPhysicsState()
        {
            if (_rb == null || !_defaultsCached)
            {
                return;
            }

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

        private float CalculateTargetY(float waterY)
        {
            var baseSinkDepth = floatHeight * Mathf.Clamp01(baseSubmergeRatio);
            var sinkByForce = Mathf.Clamp(ExternalDownForce * downForceToSink, 0f, maxExtraSink);

            var bottomAdjust = 0f;
            if (enableBottomTouchAdjust && IsBottomTouched)
            {
                bottomAdjust -= bottomTouchLift;
            }

            var surfaceBob = 0f;
            if (enableSurfaceBobbing)
            {
                surfaceBob = Mathf.Sin(Time.time * surfaceBobFrequency * Mathf.PI * 2f) * surfaceBobAmplitude;
            }

            var totalSink = baseSinkDepth + sinkByForce + bottomAdjust;
            var targetBottomY = waterY - totalSink;
            return targetBottomY - bottomOffsetLocalY + surfaceBob + _biteOffsetY;
        }

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

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

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

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

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

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

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

            var desiredPosture = DeterminePostureState(submergeRatio, hasLure);
            ApplyPostureWithStability(desiredPosture, deltaTime);
        }

        private BobberPosture DeterminePostureState(float submergeRatio, bool hasLure)
        {
            if (UseTestPosture)
            {
                return TestPosture;
            }

            if (!hasLure)
            {
                if (submergeRatio < minSubmergeToStand)
                {
                    return BobberPosture.Lying;
                }

                if (ExternalPlanarOffset.magnitude > 0.01f)
                {
                    return BobberPosture.Tilted;
                }

                return BobberPosture.Upright;
            }

            switch (_posture)
            {
                case BobberPosture.Lying:
                {
                    var canStandUpright =
                        submergeRatio >= minSubmergeToStand &&
                        _verticalRatio > verticalUprightThreshold + postureHysteresis &&
                        _planarRatio < planarTiltThreshold - postureHysteresis;

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

                    if (canStandUpright)
                    {
                        return BobberPosture.Upright;
                    }

                    if (canTilt)
                    {
                        return BobberPosture.Tilted;
                    }

                    return BobberPosture.Lying;
                }

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

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

                    if (shouldLie)
                    {
                        return BobberPosture.Lying;
                    }

                    if (shouldStand)
                    {
                        return BobberPosture.Upright;
                    }

                    return BobberPosture.Tilted;
                }

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

                    var 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, float deltaTime)
        {
            _postureCooldownTimer = Mathf.Max(0f, _postureCooldownTimer - deltaTime);
            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 += deltaTime;
            if (_pendingPostureTimer >= Mathf.Max(0f, postureConfirmTime))
            {
                _posture = desiredPosture;
                _pendingPosture = _posture;
                _pendingPostureTimer = 0f;
                _postureCooldownTimer = Mathf.Max(0f, postureSwitchCooldown);
            }
        }

        private void UpdateTargetRotationByPosture(float deltaTime)
        {
            var candidateDir = Vector3.zero;
            if (lureBody != null)
            {
                var delta = lureBody.worldCenterOfMass - _rb.worldCenterOfMass;
                candidateDir = Vector3.ProjectOnPlane(delta, 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();

            var dirDeadZone = Mathf.Max(0.0001f, planarDirectionDeadZone);
            if (candidateDir.sqrMagnitude > dirDeadZone * dirDeadZone)
            {
                candidateDir.Normalize();
                if (Vector3.Dot(candidateDir, _stablePlanarDir) < 0f)
                {
                    candidateDir = -candidateDir;
                }

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

            var planarDir = _stablePlanarDir;
            var tiltAxis = Vector3.Cross(Vector3.up, planarDir);
            if (tiltAxis.sqrMagnitude < 1e-6f)
            {
                tiltAxis = transform.right;
            }

            var angle = _posture switch
            {
                BobberPosture.Lying => lyingAngle,
                BobberPosture.Tilted => tiltedAngle,
                _ => 0f,
            };

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

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

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

            _biteTimer += deltaTime;
            var t = Mathf.Clamp01(_biteTimer / _biteDuration);
            var targetOffset = 0f;

            switch (_activeBiteType)
            {
                case BobberBiteType.Tap:
                    if (t < 0.35f)
                    {
                        var k = t / 0.35f;
                        targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, k);
                    }
                    else
                    {
                        var k = (t - 0.35f) / 0.65f;
                        targetOffset = -Mathf.Lerp(_biteAmplitude, 0f, k);
                    }
                    break;

                case BobberBiteType.SlowSink:
                    targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, t);
                    break;

                case BobberBiteType.Lift:
                    targetOffset = Mathf.SmoothStep(0f, _biteAmplitude, t);
                    break;

                case BobberBiteType.BlackDrift:
                    targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, t);
                    break;
            }

            _biteOffsetY = Mathf.SmoothDamp(
                _biteOffsetY,
                targetOffset,
                ref _biteOffsetYVelocity,
                0.03f,
                Mathf.Infinity,
                deltaTime);

            if (_biteTimer >= _biteDuration &&
                _activeBiteType != BobberBiteType.SlowSink &&
                _activeBiteType != BobberBiteType.BlackDrift)
            {
                _activeBiteType = BobberBiteType.None;
            }
        }

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

            return fallbackWaterLevel;
        }

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

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

            if (debugResetKey && Input.GetKeyDown(KeyCode.R))
            {
                StopBite();
            }

            if (debugTapKey && Input.GetKeyDown(KeyCode.T))
            {
                PlayTap();
            }

            if (debugSlowSinkKey && Input.GetKeyDown(KeyCode.G))
            {
                PlaySlowSink();
            }

            if (debugLiftKey && Input.GetKeyDown(KeyCode.H))
            {
                PlayLift();
            }

            if (debugBlackDriftKey && Input.GetKeyDown(KeyCode.B))
            {
                PlayBlackDrift();
            }
        }

        private void DrawDebug(float waterY)
        {
            var p = transform.position;
            var 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.WaterPresentation)
            {
                var 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);
            }

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

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

                var 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);
            ySmoothTime = Mathf.Max(0.001f, ySmoothTime);
            maxYSpeed = Mathf.Max(0.01f, maxYSpeed);
            xzSmoothTime = Mathf.Max(0.001f, xzSmoothTime);
            rotationLerpSpeed = Mathf.Max(0.01f, rotationLerpSpeed);

            maxPlanarOffset = Mathf.Max(0f, maxPlanarOffset);
            downForceToSink = Mathf.Max(0f, downForceToSink);
            maxExtraSink = Mathf.Max(0f, maxExtraSink);
            surfaceBobAmplitude = Mathf.Max(0f, surfaceBobAmplitude);
            surfaceBobFrequency = Mathf.Max(0f, surfaceBobFrequency);
            yDeadZone = Mathf.Max(0f, yDeadZone);

            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);
        }
#endif
    }
}