using UnityEngine;
using UnityEngine.Events;

public class RaftRiverController : MonoBehaviour
{
    [Header("Path")]
    [SerializeField] private Transform[] pathPoints;

    [Header("Steering Input")]
    [SerializeField] private SteeringKeyXR steeringKey;

    [Tooltip("Invert left/right steering input.")]
    [SerializeField] private bool reverseControl = true;

    [Header("Move Speed")]
    [SerializeField] private float forwardSpeed = 5f;
    [SerializeField] private float turnSpeed = 4f;

    [Header("Start Speed Control")]
    [Tooltip("0이면 정지, 1이면 정상 속도입니다. 시작 가속용으로 사용합니다.")]
    [SerializeField] private float speedMultiplier = 1f;

    [Header("Side Control")]
    [SerializeField] private float sideMoveSpeed = 16f;
    [SerializeField] private float sideAcceleration = 40f;

    [Tooltip("Maximum side movement from the raft center line.")]
    [SerializeField] private float maxSideOffset = 16f;

    [Header("Path Follow Feel")]
    [SerializeField] private float pathFollowSmoothTime = 0.28f;

    [Range(0f, 1f)]
    [SerializeField] private float rotationVelocityBlend = 0.45f;

    [SerializeField] private float steeringYawAngle = 18f;

    [Header("Manual Steering")]
    [Tooltip("Degrees per second SteeringKeyXR can turn the raft travel direction while held.")]
    [SerializeField] private float grabbedSteeringTurnSpeed = 75f;

    [Header("Arrival")]
    [SerializeField] private float pointReachDistance = 1.5f;
    [SerializeField] private float arrivalSlowDownDistance = 12f;
    [SerializeField] private float arrivalMinSpeed = 0.8f;

    [Header("Final Stop Guard")]
    [Tooltip("마지막 포인트에 가까워지면 거리 판정으로 도착 처리합니다.")]
    [SerializeField] private float finalPointReachDistance = 3.0f;

    [Tooltip("마지막 포인트 근처 몇 미터 안에서 지나침 감지를 할지 설정합니다.")]
    [SerializeField] private float finalStopGuardDistance = 20f;

    [Tooltip("목표점과의 X/Z 차이가 이 값 이상 다시 커지면 지나친 것으로 판단합니다.")]
    [SerializeField] private float finalStopGuardAxisEpsilon = 0.05f;

    [Tooltip("마지막 구간 방향 기준, 마지막 포인트를 넘어가면 즉시 도착 처리합니다.")]
    [SerializeField] private bool stopWhenPassedFinalPlane = true;

    [Tooltip("도착 처리 시 마지막 포인트 위치로 뗏목을 스냅할지 여부입니다.")]
    [SerializeField] private bool snapToFinalPointOnArrive = true;

    [Header("Events")]
    public UnityEvent onArrived;

    private int currentPointIndex = 0;

    private float sideOffset = 0f;
    private float sideVelocity = 0f;
    private float currentSteeringInput = 0f;

    private Vector3 currentCenterPosition;
    private Vector3 currentForward;
    private Vector3 currentRight;
    private Vector3 positionSmoothVelocity;
    private Vector3 previousPosition;
    private Vector3 startCenterPosition;

    private Vector3 previousFinalDelta;
    private bool hasPreviousFinalDelta;

    private bool isFinished = false;
    private bool warnedMissingSteeringKey;

    public bool IsFinished => isFinished;

    private void Awake()
    {
        ResolveSteeringKey();
    }

    private void Start()
    {
        ResolveSteeringKey();

        if (pathPoints == null || pathPoints.Length == 0)
        {
            Debug.LogWarning("[RaftRiverController] Path Points are empty.", this);
            enabled = false;
            return;
        }

        currentCenterPosition = transform.position;
        startCenterPosition = currentCenterPosition;

        currentForward = transform.forward;
        currentForward.y = 0f;

        if (currentForward.sqrMagnitude < 0.001f)
            currentForward = Vector3.forward;

        currentForward.Normalize();

        currentRight = Vector3.Cross(Vector3.up, currentForward).normalized;

        previousPosition = transform.position;
        currentPointIndex = 0;

        ResetFinalStopGuard();
    }

    private void Update()
    {
        if (isFinished)
            return;

        HandleSideControl();

        bool arrived = MoveAlongPath();

        if (arrived)
            return;

        ApplyRaftPositionAndRotation();
    }

    private bool MoveAlongPath()
    {
        SkipMissingPathPoints();

        int lastPointIndex = GetLastValidPathPointIndex();

        if (lastPointIndex < 0 || currentPointIndex >= pathPoints.Length)
        {
            FinishRaftRide();
            return true;
        }

        Transform targetPoint = pathPoints[currentPointIndex];

        if (targetPoint == null)
            return false;

        Vector3 toTarget = GetFlatVectorTo(targetPoint.position);
        float distance = toTarget.magnitude;

        bool isLastTarget = currentPointIndex == lastPointIndex;

        while (!isLastTarget && ShouldAdvancePathPoint(currentPointIndex, distance))
        {
            currentPointIndex++;
            SkipMissingPathPoints();

            if (currentPointIndex >= pathPoints.Length)
            {
                FinishAtFinalPoint();
                return true;
            }

            targetPoint = pathPoints[currentPointIndex];

            if (targetPoint == null)
                return false;

            toTarget = GetFlatVectorTo(targetPoint.position);
            distance = toTarget.magnitude;
            isLastTarget = currentPointIndex == lastPointIndex;
        }

        if (isLastTarget && IsCloseEnoughToFinalPoint(distance))
        {
            FinishAtFinalPoint();
            return true;
        }

        if (toTarget.sqrMagnitude < 0.001f)
            return false;

        Vector3 pathForward = toTarget.normalized;
        currentForward = GetTravelForward(pathForward);

        float currentSpeed = GetCurrentForwardSpeed(distance);
        float moveDistance = currentSpeed * Time.deltaTime;

        if (isLastTarget && moveDistance >= distance)
        {
            FinishAtFinalPoint();
            return true;
        }

        currentCenterPosition += currentForward * moveDistance;

        if (currentForward.sqrMagnitude > 0.001f)
            currentRight = Vector3.Cross(Vector3.up, currentForward).normalized;

        if (TryFinishAtFinalPointByGuards())
            return true;

        return false;
    }

    private void HandleSideControl()
    {
        float input = 0f;

        ResolveSteeringKey();

        if (steeringKey != null)
        {
            input = steeringKey.SteeringValue;
        }
        else
        {
            input = ReadLegacyHorizontalInput();

            if (!warnedMissingSteeringKey)
            {
                warnedMissingSteeringKey = true;
                Debug.LogWarning("[RaftRiverController] SteeringKeyXR reference is missing. Falling back to legacy horizontal input.", this);
            }
        }

        if (reverseControl)
            input *= -1f;

        currentSteeringInput = input;

        float targetSideVelocity = input * sideMoveSpeed;

        sideVelocity = Mathf.MoveTowards(
            sideVelocity,
            targetSideVelocity,
            sideAcceleration * Time.deltaTime
        );

        sideOffset += sideVelocity * Time.deltaTime;
        sideOffset = Mathf.Clamp(sideOffset, -maxSideOffset, maxSideOffset);

        if (Mathf.Approximately(Mathf.Abs(sideOffset), maxSideOffset) &&
            Mathf.Sign(sideVelocity) == Mathf.Sign(sideOffset))
        {
            sideVelocity = 0f;
        }
    }

    private void ApplyRaftPositionAndRotation()
    {
        previousPosition = transform.position;

        Vector3 targetPosition = currentCenterPosition + currentRight * sideOffset;
        targetPosition.y = transform.position.y;

        float smoothTime = Mathf.Max(0.01f, pathFollowSmoothTime);

        transform.position = Vector3.SmoothDamp(
            transform.position,
            targetPosition,
            ref positionSmoothVelocity,
            smoothTime
        );

        if (currentForward != Vector3.zero)
        {
            Vector3 frameVelocity = transform.position - previousPosition;
            frameVelocity.y = 0f;

            Vector3 lookDirection = currentForward;

            if (frameVelocity.sqrMagnitude > 0.0001f)
            {
                lookDirection = Vector3.Slerp(
                    currentForward,
                    frameVelocity.normalized,
                    rotationVelocityBlend
                );
            }

            if (lookDirection.sqrMagnitude < 0.001f)
                return;

            Quaternion targetRotation =
                Quaternion.LookRotation(lookDirection, Vector3.up) *
                Quaternion.Euler(0f, currentSteeringInput * steeringYawAngle, 0f);

            transform.rotation = Quaternion.Slerp(
                transform.rotation,
                targetRotation,
                turnSpeed * Time.deltaTime
            );
        }
    }

    private bool IsCloseEnoughToFinalPoint(float distance)
    {
        float reachDistance = Mathf.Max(pointReachDistance, finalPointReachDistance);
        return distance <= reachDistance;
    }

    private bool TryFinishAtFinalPointByGuards()
    {
        int lastPointIndex = GetLastValidPathPointIndex();

        if (lastPointIndex < 0)
            return false;

        if (currentPointIndex != lastPointIndex)
        {
            ResetFinalStopGuard();
            return false;
        }

        Transform finalPoint = pathPoints[lastPointIndex];

        if (finalPoint == null)
            return false;

        Vector3 finalDelta = finalPoint.position - currentCenterPosition;
        finalDelta.y = 0f;

        float distanceToFinal = finalDelta.magnitude;

        if (distanceToFinal <= finalPointReachDistance)
        {
            Debug.Log("[RaftRiverController] Final point reach distance 안에 들어와 도착 처리합니다.");
            FinishAtFinalPoint();
            return true;
        }

        if (stopWhenPassedFinalPlane && HasPassedFinalPlane())
        {
            Debug.Log("[RaftRiverController] 마지막 도착 평면을 지나 도착 처리합니다.");
            FinishAtFinalPoint();
            return true;
        }

        if (TryFinishIfMovingAwayFromFinalPoint(finalDelta, distanceToFinal))
            return true;

        return false;
    }

    private bool HasPassedFinalPlane()
    {
        int lastPointIndex = GetLastValidPathPointIndex();
        int penultimateIndex = GetPenultimateValidPathPointIndex();

        if (lastPointIndex < 0 || penultimateIndex < 0 || lastPointIndex == penultimateIndex)
            return false;

        Transform finalPoint = pathPoints[lastPointIndex];
        Transform previousPoint = pathPoints[penultimateIndex];

        if (finalPoint == null || previousPoint == null)
            return false;

        Vector3 previousPos = previousPoint.position;
        Vector3 finalPos = finalPoint.position;
        Vector3 centerPos = currentCenterPosition;

        previousPos.y = 0f;
        finalPos.y = 0f;
        centerPos.y = 0f;

        Vector3 finalSegmentDirection = finalPos - previousPos;

        if (finalSegmentDirection.sqrMagnitude < 0.001f)
            return false;

        finalSegmentDirection.Normalize();

        Vector3 fromFinalToRaft = centerPos - finalPos;

        float passedAmount = Vector3.Dot(fromFinalToRaft, finalSegmentDirection);

        return passedAmount >= 0f;
    }

    private bool TryFinishIfMovingAwayFromFinalPoint(Vector3 finalDelta, float distanceToFinal)
    {
        if (distanceToFinal > finalStopGuardDistance)
        {
            previousFinalDelta = finalDelta;
            hasPreviousFinalDelta = true;
            return false;
        }

        if (!hasPreviousFinalDelta)
        {
            previousFinalDelta = finalDelta;
            hasPreviousFinalDelta = true;
            return false;
        }

        Vector3 previousAbs = new Vector3(
            Mathf.Abs(previousFinalDelta.x),
            0f,
            Mathf.Abs(previousFinalDelta.z)
        );

        Vector3 currentAbs = new Vector3(
            Mathf.Abs(finalDelta.x),
            0f,
            Mathf.Abs(finalDelta.z)
        );

        bool xMovingAway = currentAbs.x > previousAbs.x + finalStopGuardAxisEpsilon;
        bool zMovingAway = currentAbs.z > previousAbs.z + finalStopGuardAxisEpsilon;

        if (xMovingAway || zMovingAway)
        {
            Debug.Log("[RaftRiverController] 마지막 포인트에서 멀어지는 것으로 판단하여 도착 처리합니다.");
            FinishAtFinalPoint();
            return true;
        }

        previousFinalDelta = finalDelta;
        return false;
    }

    private void FinishAtFinalPoint()
    {
        int lastPointIndex = GetLastValidPathPointIndex();

        if (lastPointIndex >= 0 && pathPoints[lastPointIndex] != null && snapToFinalPointOnArrive)
        {
            SnapToPathPoint(pathPoints[lastPointIndex]);
        }

        FinishRaftRide();
    }

    private void FinishRaftRide()
    {
        if (isFinished)
            return;

        isFinished = true;
        SetSpeedMultiplier(0f);

        sideVelocity = 0f;
        currentSteeringInput = 0f;
        positionSmoothVelocity = Vector3.zero;

        Debug.Log("[RaftRiverController] Arrived at destination. Raft stopped.");

        onArrived?.Invoke();
    }

    public void StopRaft()
    {
        isFinished = true;
        sideVelocity = 0f;
        currentSteeringInput = 0f;
        positionSmoothVelocity = Vector3.zero;
    }

    public void ResumeRaft()
    {
        isFinished = false;
        ResetFinalStopGuard();
    }

    public void SetSpeedMultiplier(float value)
    {
        speedMultiplier = Mathf.Clamp01(value);
    }

    public void SetSteeringKey(SteeringKeyXR newSteeringKey)
    {
        steeringKey = newSteeringKey;
        warnedMissingSteeringKey = false;
    }

    private void ResolveSteeringKey()
    {
        if (steeringKey != null)
            return;

        steeringKey = GetComponentInChildren<SteeringKeyXR>(true);
    }

    private Vector3 GetTravelForward(Vector3 fallbackForward)
    {
        Vector3 travelForward = currentForward;
        travelForward.y = 0f;

        if (travelForward.sqrMagnitude < 0.001f)
            travelForward = transform.forward;

        travelForward.y = 0f;

        if (travelForward.sqrMagnitude < 0.001f)
            travelForward = fallbackForward;

        if (steeringKey != null && steeringKey.IsGrabbed)
        {
            float turnAmount =
                currentSteeringInput *
                Mathf.Max(0f, grabbedSteeringTurnSpeed) *
                Time.deltaTime;

            travelForward = Quaternion.Euler(0f, turnAmount, 0f) * travelForward.normalized;
        }

        return travelForward.normalized;
    }

    private Vector3 GetFlatVectorTo(Vector3 worldPosition)
    {
        Vector3 delta = worldPosition - currentCenterPosition;
        delta.y = 0f;
        return delta;
    }

    private bool ShouldAdvancePathPoint(int targetIndex, float distanceToTarget)
    {
        return distanceToTarget < pointReachDistance || HasPassedPathPoint(targetIndex);
    }

    private bool HasPassedPathPoint(int targetIndex)
    {
        if (pathPoints == null ||
            targetIndex < 0 ||
            targetIndex >= pathPoints.Length ||
            pathPoints[targetIndex] == null)
        {
            return true;
        }

        Vector3 anchorPosition = GetPreviousPathAnchorPosition(targetIndex);
        Vector3 targetPosition = pathPoints[targetIndex].position;

        anchorPosition.y = currentCenterPosition.y;
        targetPosition.y = currentCenterPosition.y;

        Vector3 segment = targetPosition - anchorPosition;

        if (segment.sqrMagnitude < 0.001f)
            return false;

        Vector3 fromAnchor = currentCenterPosition - anchorPosition;
        fromAnchor.y = 0f;

        return Vector3.Dot(fromAnchor, segment.normalized) >= segment.magnitude;
    }

    private Vector3 GetPreviousPathAnchorPosition(int targetIndex)
    {
        if (pathPoints != null)
        {
            for (int i = targetIndex - 1; i >= 0; i--)
            {
                if (pathPoints[i] != null)
                    return pathPoints[i].position;
            }
        }

        return startCenterPosition;
    }

    private void SnapToPathPoint(Transform point)
    {
        if (point == null)
            return;

        Vector3 finalPosition = point.position;
        finalPosition.y = transform.position.y;

        currentCenterPosition = finalPosition;

        sideOffset = 0f;
        sideVelocity = 0f;
        currentSteeringInput = 0f;
        positionSmoothVelocity = Vector3.zero;
        previousPosition = finalPosition;

        transform.position = finalPosition;

        ResetFinalStopGuard();
    }

    private int GetPenultimateValidPathPointIndex()
    {
        if (pathPoints == null)
            return -1;

        int lastValidIndex = -1;

        for (int i = pathPoints.Length - 1; i >= 0; i--)
        {
            if (pathPoints[i] == null)
                continue;

            if (lastValidIndex < 0)
            {
                lastValidIndex = i;
                continue;
            }

            return i;
        }

        return lastValidIndex;
    }

    private float GetArrivalSlowDownDistance()
    {
        float fallbackDistance = Mathf.Max(pointReachDistance + 0.01f, arrivalSlowDownDistance);

        int penultimateIndex = GetPenultimateValidPathPointIndex();
        int lastPointIndex = GetLastValidPathPointIndex();

        if (penultimateIndex < 0 ||
            lastPointIndex < 0 ||
            penultimateIndex == lastPointIndex)
        {
            return fallbackDistance;
        }

        Vector3 penultimatePosition = pathPoints[penultimateIndex].position;
        Vector3 finalPosition = pathPoints[lastPointIndex].position;

        penultimatePosition.y = 0f;
        finalPosition.y = 0f;

        float finalSegmentDistance = Vector3.Distance(penultimatePosition, finalPosition);

        if (finalSegmentDistance <= pointReachDistance)
            return fallbackDistance;

        return Mathf.Max(pointReachDistance + 0.01f, finalSegmentDistance);
    }

    private float GetCurrentForwardSpeed(float distanceToTarget)
    {
        float baseSpeed;

        if (currentPointIndex != GetLastValidPathPointIndex())
        {
            baseSpeed = forwardSpeed;
        }
        else
        {
            float maxSpeed = Mathf.Max(0f, forwardSpeed);

            if (maxSpeed <= 0.01f)
            {
                baseSpeed = maxSpeed;
            }
            else
            {
                float slowDownDistance = GetArrivalSlowDownDistance();

                if (slowDownDistance <= pointReachDistance)
                {
                    baseSpeed = maxSpeed;
                }
                else
                {
                    float minSpeed = Mathf.Clamp(arrivalMinSpeed, 0.01f, maxSpeed);

                    float speedRatio = Mathf.InverseLerp(
                        pointReachDistance,
                        slowDownDistance,
                        distanceToTarget
                    );

                    speedRatio = speedRatio * speedRatio * (3f - 2f * speedRatio);

                    baseSpeed = Mathf.Lerp(minSpeed, maxSpeed, speedRatio);
                }
            }
        }

        return baseSpeed * speedMultiplier;
    }

    private int GetLastValidPathPointIndex()
    {
        if (pathPoints == null)
            return -1;

        for (int i = pathPoints.Length - 1; i >= 0; i--)
        {
            if (pathPoints[i] != null)
                return i;
        }

        return -1;
    }

    private void SkipMissingPathPoints()
    {
        while (currentPointIndex < pathPoints.Length && pathPoints[currentPointIndex] == null)
        {
            currentPointIndex++;
        }
    }

    private void ResetFinalStopGuard()
    {
        previousFinalDelta = Vector3.zero;
        hasPreviousFinalDelta = false;
    }

    private float ReadLegacyHorizontalInput()
    {
#if ENABLE_LEGACY_INPUT_MANAGER
        return Input.GetAxis("Horizontal");
#else
        return 0f;
#endif
    }
}