// Copyright 2025 https://yuewu.dev/en  All Rights Reserved.

#include "GMS_CharacterMovementSystemComponent.h"
#include "TimerManager.h"
#include "Components/CapsuleComponent.h"
#include "Curves/CurveFloat.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/PlayerController.h"
#include "Kismet/KismetMathLibrary.h"
#include "Net/UnrealNetwork.h"
#include "Components/SkeletalMeshComponent.h"
#include "Animation/AnimInstance.h"
#include "Locomotions/GMS_MainAnimInstance.h"
#include "Net/Core/PushModel/PushModel.h"
#include "Settings/GMS_SettingObjectLibrary.h"
#include "Utility/GMS_Constants.h"
#include "Utility/GMS_Log.h"
#include "Utility/GMS_Math.h"
#include "Utility/GMS_Rotation.h"
#include "Utility/GMS_Utility.h"
#include "Utility/GMS_Vector.h"

#include UE_INLINE_GENERATED_CPP_BY_NAME(GMS_CharacterMovementSystemComponent)

namespace GMS_MovementComponentConstants
{
	inline static constexpr auto TeleportDistanceThresholdSquared{FMath::Square(50.0f)};
}

UGMS_CharacterMovementSystemComponent::UGMS_CharacterMovementSystemComponent(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
	SetIsReplicatedByDefault(true);
	PrimaryComponentTick.bCanEverTick = true;
	bWantsInitializeComponent = true;
	bReplicateUsingRegisteredSubObjectList = true;

	MovementIntent = FVector::ZeroVector;

	MovementModeToTagMapping = {
		{MOVE_None, GMS_MovementModeTags::None},
		{MOVE_Walking, GMS_MovementModeTags::Grounded},
		{MOVE_NavWalking, GMS_MovementModeTags::Grounded},
		{MOVE_Falling, GMS_MovementModeTags::InAir},
		{MOVE_Swimming, GMS_MovementModeTags::Swimming},
		{MOVE_Flying, GMS_MovementModeTags::Flying},
	};
}

void UGMS_CharacterMovementSystemComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	FDoRepLifetimeParams Parameters;
	Parameters.bIsPushBased = true;

	Parameters.Condition = COND_SkipOwner;

	DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, DesiredMovementState, Parameters)
	DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, DesiredRotationMode, Parameters)
	DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, MovementIntent, Parameters)
}

void UGMS_CharacterMovementSystemComponent::InitializeComponent()
{
	Super::InitializeComponent();

	OwnerCharacter = Cast<ACharacter>(GetOwner());
	if (OwnerCharacter)
	{
		MovementState = DesiredMovementState;
		RotationMode = DesiredRotationMode;

		CharacterMovement = Cast<UCharacterMovementComponent>(OwnerCharacter->GetMovementComponent());
		OwnerCharacter->bUseControllerRotationPitch = false;
		OwnerCharacter->bUseControllerRotationRoll = false;
		OwnerCharacter->bUseControllerRotationYaw = false;
		CharacterMovement->bUseControllerDesiredRotation = false;
		CharacterMovement->bOrientRotationToMovement = false;

		AnimationInstance = GetMesh()->GetAnimInstance();
		// Make sure the mesh and animation blueprint are ticking after the character so they can access the most up-to-date character state.
		GetMesh()->AddTickPrerequisiteComponent(this);
		RefreshTargetYawAngleUsingActorRotation();
	}
}


void UGMS_CharacterMovementSystemComponent::BeginPlay()
{
	Super::BeginPlay();

	//This callback fires on both sides, including simulated proxy.
	OwnerCharacter->MovementModeChangedDelegate.AddDynamic(this, &ThisClass::OnCharacterMovementModeChanged);
	OnCharacterMovementModeChanged(OwnerCharacter, OwnerCharacter->GetCharacterMovement()->GetGroundMovementMode(), 0);

	RefreshRotationMode();

	RefreshMovementSetSetting();
}

void UGMS_CharacterMovementSystemComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	if (IsValid(OwnerCharacter))
	{
		OwnerCharacter->MovementModeChangedDelegate.RemoveDynamic(this, &ThisClass::OnCharacterMovementModeChanged);
	}
	Super::EndPlay(EndPlayReason);
}

void UGMS_CharacterMovementSystemComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	DECLARE_SCOPE_CYCLE_COUNTER(TEXT("UGMS_CharacterMovementSystemComponent::TickComponent"), STAT_GMS_MovementSystem_Tick, STATGROUP_GMS)
	TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__)

	if (!GetMovementDefinition().IsValid() || !IsValid(AnimationInstance) || !IsValid(ControlSetting))
	{
		Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
		return;
	}

	RefreshMovementBase();

	RefreshInput(DeltaTime);

	RefreshLocomotionEarly();

	RefreshView(DeltaTime);

	RefreshRotationMode();

	RefreshLocomotion(DeltaTime);

	RefreshDynamicMovementState();

	RefreshMovementState();

	RefreshRotation(DeltaTime);

	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	RefreshLocomotionLate(DeltaTime);
}

void UGMS_CharacterMovementSystemComponent::OnCharacterMovementModeChanged(ACharacter* InCharacter, EMovementMode PrevMovementMode, uint8 PreviousCustomMode)
{
	// Use the character movement mode to set the locomotion mode to the right value. This allows you to have a
	// custom set of movement modes but still use the functionality of the default character movement component.

	EMovementMode CharMovementMode = CharacterMovement->MovementMode;
	uint8 CharCustomMovementMode = CharacterMovement->CustomMovementMode;

	if (CharMovementMode != MOVE_Custom)
	{
		if (MovementModeToTagMapping.Contains(CharMovementMode) && MovementModeToTagMapping[CharMovementMode].IsValid())
		{
			SetLocomotionMode(MovementModeToTagMapping[CharMovementMode]);
		}
		else
		{
			GMS_CLOG(Error, "No locomotion mode mapping for MovementMode:%s", *UEnum::GetDisplayValueAsText(CharMovementMode).ToString());
		}
	}
	else
	{
		if (CustomMovementModeToTagMapping.Contains(CharCustomMovementMode) && CustomMovementModeToTagMapping[CharCustomMovementMode].IsValid())
		{
			SetLocomotionMode(CustomMovementModeToTagMapping[CharCustomMovementMode]);
		}
		else
		{
			GMS_CLOG(Error, "No locomotion mode mapping for CustomMovementMode:%d", CharCustomMovementMode);
		}
	}
}

void UGMS_CharacterMovementSystemComponent::OnReplicated_LocomotionMode(const FGameplayTag& PreviousLocomotionMode)
{
	// OnMovementModeChanged will fire on all clients(including simulated pawn), mover is not. so don't call parent. 
}

void UGMS_CharacterMovementSystemComponent::RefreshMovementState()
{
	if (!DesiredMovementState.IsValid())
	{
		return;
	}

	if (MovementState == DesiredMovementState)
	{
		return;
	}

	ApplyMovementSetting();

	SetMovementState(CalculateActualMovementState());
}

FGameplayTag UGMS_CharacterMovementSystemComponent::CalculateActualMovementState()
{
	check(GetNumOfMovementStateSettings() != 0)

	if (ControlSetting->MovementStates.Num() == 1)
	{
		return ControlSetting->MovementStates[0].Tag;
	}

	for (int32 i = 0; i < ControlSetting->MovementStates.Num(); i++)
	{
		float Speed = ControlSetting->MovementStates[i].Speed;
		if (Speed > 0.0f && LocomotionState.Speed < Speed + 10.0f)
		{
			return ControlSetting->MovementStates[i].Tag;
		}
	}

	return FGameplayTag::EmptyTag;
}

void UGMS_CharacterMovementSystemComponent::ApplyMovementSetting()
{
	if (bAllowRefreshCharacterMovementSettings && IsValid(ControlSetting))
	{
		if (const FGMS_MovementStateSetting* TempMS = ControlSetting->GetMovementStateSetting(DesiredMovementState, true))
		{
			CharacterMovement->MaxWalkSpeed = TempMS->Speed;
			CharacterMovement->MaxAcceleration = TempMS->Acceleration;
			CharacterMovement->BrakingDecelerationWalking = TempMS->BrakingDeceleration;
			CharacterMovement->MaxWalkSpeedCrouched = TempMS->Speed;
		}
	}
}

void UGMS_CharacterMovementSystemComponent::SetDesiredMovement(const FGameplayTag& NewDesiredMovement)
{
	SetDesiredMovement(NewDesiredMovement, true);
}

void UGMS_CharacterMovementSystemComponent::SetMovementState(const FGameplayTag& NewMovementState)
{
	if (NewMovementState.IsValid() && MovementState != NewMovementState)
	{
		const FGameplayTag PreviousMovementState{MovementState};

		MovementState = NewMovementState;

		OnMovementStateChanged(PreviousMovementState);
	}
}

const FGameplayTag& UGMS_CharacterMovementSystemComponent::GetMovementState() const
{
	return MovementState;
}

void UGMS_CharacterMovementSystemComponent::SetDesiredMovement(const FGameplayTag& NewDesiredMovement, bool bSendRpc)
{
	if (DesiredMovementState == NewDesiredMovement || GetOwner()->GetLocalRole() < ROLE_AutonomousProxy)
	{
		return;
	}
	const auto PreviousMovement{DesiredMovementState};

	DesiredMovementState = NewDesiredMovement;

	MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, DesiredMovementState, this)

	if (bSendRpc)
	{
		if (GetOwner()->GetLocalRole() >= ROLE_Authority)
		{
			ClientSetDesiredMovement(NewDesiredMovement);
		}
		else
		{
			ServerSetDesiredMovement(NewDesiredMovement);
		}
	}
}

void UGMS_CharacterMovementSystemComponent::ClientSetDesiredMovement_Implementation(const FGameplayTag& NewDesiredMovement)
{
	SetDesiredMovement(NewDesiredMovement, false);
}

void UGMS_CharacterMovementSystemComponent::ServerSetDesiredMovement_Implementation(const FGameplayTag& NewDesiredMovement)
{
	SetDesiredMovement(NewDesiredMovement, false);
}

const FGameplayTag& UGMS_CharacterMovementSystemComponent::GetDesiredRotationMode() const
{
	return DesiredRotationMode;
}

void UGMS_CharacterMovementSystemComponent::SetDesiredRotationMode(const FGameplayTag& NewDesiredRotationMode)
{
	SetDesiredRotationMode(NewDesiredRotationMode, true);
}

const FGameplayTag& UGMS_CharacterMovementSystemComponent::GetRotationMode() const
{
	return RotationMode;
}

void UGMS_CharacterMovementSystemComponent::SetRotationMode(const FGameplayTag& NewRotationMode)
{
	if (RotationMode != NewRotationMode)
	{
		if (bRespectAllowedRotationModesSettings && !GetMovementStateSetting().AllowedRotationModes.Contains(NewRotationMode))
		{
			GMS_CLOG(Warning, "current movement state(%s) doesn't allow new rotation mode(%s).", *MovementState.ToString(), *NewRotationMode.ToString());
			return;
		}
		const auto PreviousRotationMode{RotationMode};

		RotationMode = NewRotationMode;

		OnRotationModeChanged(PreviousRotationMode);
	}
}

void UGMS_CharacterMovementSystemComponent::RefreshRotationMode()
{
	SetRotationMode(DesiredRotationMode);
}


void UGMS_CharacterMovementSystemComponent::SetDesiredRotationMode(const FGameplayTag& NewDesiredRotationMode, bool bSendRpc)
{
	if (DesiredRotationMode == NewDesiredRotationMode || GetOwner()->GetLocalRole() < ROLE_AutonomousProxy)
	{
		return;
	}

	DesiredRotationMode = NewDesiredRotationMode;

	MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, DesiredRotationMode, this)

	if (bSendRpc)
	{
		if (GetOwner()->GetLocalRole() >= ROLE_Authority)
		{
			ClientSetDesiredRotationMode(DesiredRotationMode);
		}
		else
		{
			ServerSetDesiredRotationMode(DesiredRotationMode);
		}
	}
}

void UGMS_CharacterMovementSystemComponent::ClientSetDesiredRotationMode_Implementation(const FGameplayTag& NewDesiredRotationMode)
{
	SetDesiredRotationMode(NewDesiredRotationMode, false);
}

void UGMS_CharacterMovementSystemComponent::ServerSetDesiredRotationMode_Implementation(const FGameplayTag& NewDesiredRotationMode)
{
	SetDesiredRotationMode(NewDesiredRotationMode, false);
}


void UGMS_CharacterMovementSystemComponent::SetMovementIntent(FVector NewMovementIntent)
{
	NewMovementIntent = NewMovementIntent.GetSafeNormal();

	COMPARE_ASSIGN_AND_MARK_PROPERTY_DIRTY(ThisClass, MovementIntent, NewMovementIntent, this);
}

void UGMS_CharacterMovementSystemComponent::RefreshInput(float DeltaTime)
{
	// Using current acceleration as movement input.
	if (OwnerCharacter->GetLocalRole() >= ROLE_AutonomousProxy)
	{
		SetMovementIntent(CharacterMovement->GetCurrentAcceleration() / CharacterMovement->GetMaxAcceleration());
	}

	Super::RefreshInput(DeltaTime);
}

void UGMS_CharacterMovementSystemComponent::OnRotationModeChanged_Implementation(const FGameplayTag& PreviousRotationMode)
{
	Super::OnRotationModeChanged_Implementation(PreviousRotationMode);

	// if (PreviousRotationMode == GMS_RotationModeTags::VelocityDirection && !LocomotionState.bMoving)
	// {
	// 	// This prevents the actor from rotating in the last input direction after the
	// 	// rotation mode has been changed and the actor is not moving at that moment.
	// 	// LocomotionState.InputYawAngle = ViewState.Rotation.Yaw;
	// 	LocomotionState.TargetYawAngle = ViewState.Rotation.Yaw;
	// }
}

void UGMS_CharacterMovementSystemComponent::RefreshMovementBase()
{
	const FBasedMovementInfo& BasedMovement = OwnerCharacter->GetBasedMovement();
	if (BasedMovement.MovementBase != MovementBase.Primitive || BasedMovement.BoneName != MovementBase.BoneName)
	{
		MovementBase.Primitive = BasedMovement.MovementBase;
		MovementBase.BoneName = BasedMovement.BoneName;
		MovementBase.bBaseChanged = true;
	}
	else
	{
		MovementBase.bBaseChanged = false;
	}

	MovementBase.bHasRelativeLocation = BasedMovement.HasRelativeLocation();
	MovementBase.bHasRelativeRotation = MovementBase.bHasRelativeLocation && BasedMovement.bRelativeRotation;

	const auto PreviousRotation{MovementBase.Rotation};

	MovementBaseUtility::GetMovementBaseTransform(BasedMovement.MovementBase, BasedMovement.BoneName,
	                                              MovementBase.Location, MovementBase.Rotation);

	MovementBase.DeltaRotation = MovementBase.bHasRelativeLocation && !MovementBase.bBaseChanged
		                             ? (MovementBase.Rotation * PreviousRotation.Inverse()).Rotator()
		                             : FRotator::ZeroRotator;
}

const FGameplayTag& UGMS_CharacterMovementSystemComponent::GetDesiredMovementState() const
{
	return DesiredMovementState;
}

FVector UGMS_CharacterMovementSystemComponent::GetMovementIntent() const
{
	return MovementIntent;
}

void UGMS_CharacterMovementSystemComponent::RefreshView(const float DeltaTime)
{
	if (MovementBase.bHasRelativeRotation)
	{
		// Offset the rotations to keep them relative to the movement base.

		ViewState.Rotation.Pitch += MovementBase.DeltaRotation.Pitch;
		ViewState.Rotation.Yaw += MovementBase.DeltaRotation.Yaw;
		ViewState.Rotation.Normalize();
	}

	ViewState.PreviousYawAngle = UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw);

	// update view/control rotation.
	if (MovementBase.bHasRelativeRotation)
	{
		if (OwnerPawn->IsLocallyControlled())
		{
			// We can't depend on the view rotation sent by the character movement component
			// since it's in world space, so in this case we always send it ourselves.

			//将相对于平台的视角朝向设置为新的视角朝向。保持视角不变。
			SetReplicatedViewRotation((MovementBase.Rotation.Inverse() * OwnerPawn->GetViewRotation().Quaternion()).Rotator(), true);
		}
	}
	else
	{
		if (OwnerPawn->IsLocallyControlled() || (OwnerPawn->IsReplicatingMovement() && OwnerPawn->GetLocalRole() >= ROLE_Authority && IsValid(OwnerPawn->GetController())))
		{
			// The character movement component already sends the view rotation to the
			// server if movement is replicated, so we don't have to do this ourselves.
			SetReplicatedViewRotation(OwnerPawn->GetViewRotation().GetNormalized(), !OwnerPawn->IsReplicatingMovement());
		}
	}

	// update view rotation based on if movement is based.
	ViewState.Rotation = MovementBase.bHasRelativeRotation
		                     ? (MovementBase.Rotation * ReplicatedViewRotation.Quaternion()).Rotator()
		                     : ReplicatedViewRotation;

	// Set the yaw speed by comparing the current and previous view yaw angle, divided by
	// delta seconds. This represents the speed the camera is rotating from left to right.
	if (DeltaTime > UE_SMALL_NUMBER)
	{
		ViewState.YawSpeed = FMath::Abs(UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw - ViewState.PreviousYawAngle)) / DeltaTime;
	}
}

#pragma region Abstraction

bool UGMS_CharacterMovementSystemComponent::IsCrouching() const
{
	return CharacterMovement->IsCrouching();
}

float UGMS_CharacterMovementSystemComponent::GetMaxSpeed() const
{
	return CharacterMovement->GetMaxSpeed();
}

float UGMS_CharacterMovementSystemComponent::GetScaledCapsuleRadius() const
{
	return OwnerCharacter->GetCapsuleComponent()->GetScaledCapsuleRadius();
}

float UGMS_CharacterMovementSystemComponent::GetScaledCapsuleHalfHeight() const
{
	return OwnerCharacter->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
}

float UGMS_CharacterMovementSystemComponent::GetMaxAcceleration() const
{
	return CharacterMovement->GetMaxAcceleration();
}

float UGMS_CharacterMovementSystemComponent::GetMaxBrakingDeceleration() const
{
	return CharacterMovement->GetMaxBrakingDeceleration();
}

float UGMS_CharacterMovementSystemComponent::GetWalkableFloorZ() const
{
	return CharacterMovement->GetWalkableFloorZ();
}

float UGMS_CharacterMovementSystemComponent::GetGravityZ() const
{
	return CharacterMovement->GetGravityZ();
}

USkeletalMeshComponent* UGMS_CharacterMovementSystemComponent::GetMesh() const
{
	return OwnerCharacter ? OwnerCharacter->GetMesh() : nullptr;
}

bool UGMS_CharacterMovementSystemComponent::IsMovingOnGround() const
{
	return CharacterMovement->IsMovingOnGround();
}

#pragma endregion

#pragma region Locomotion
void UGMS_CharacterMovementSystemComponent::RefreshLocomotionEarly()
{
	if (!LocomotionState.bMoving &&
		RotationMode == GMS_RotationModeTags::VelocityDirection &&
		ControlSetting->VelocityDirectionSetting.Get().bInheritBaseRotation)
	{
		DesiredVelocityYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
			DesiredVelocityYawAngle + MovementBase.DeltaRotation.Yaw));

		LocomotionState.VelocityYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
			LocomotionState.VelocityYawAngle + MovementBase.DeltaRotation.Yaw));
	}

	if (MovementBase.bHasRelativeLocation)
	{
		// Offset the rotations (the actor's rotation too) to keep them relative to the movement base.

		LocomotionState.TargetYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
			LocomotionState.TargetYawAngle + MovementBase.DeltaRotation.Yaw));

		LocomotionState.ViewRelativeTargetYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
			LocomotionState.ViewRelativeTargetYawAngle + MovementBase.DeltaRotation.Yaw));

		LocomotionState.SmoothTargetYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
			LocomotionState.SmoothTargetYawAngle + MovementBase.DeltaRotation.Yaw));

		auto NewRotation{OwnerPawn->GetActorRotation()};
		NewRotation.Pitch += MovementBase.DeltaRotation.Pitch;
		NewRotation.Yaw += MovementBase.DeltaRotation.Yaw;
		NewRotation.Normalize();

		SetActorRotation(NewRotation);
	}

	LocomotionState.bAimingLimitAppliedThisFrame = false;
}

void UGMS_CharacterMovementSystemComponent::RefreshLocomotion(const float DeltaTime)
{
	const auto bHadVelocity{LocomotionState.bHasVelocity};

	LocomotionState.Velocity = OwnerPawn->GetVelocity();

	// Determine if the character is moving by getting its speed. The speed equals the length
	// of the horizontal velocity, so it does not take vertical movement into account. If the
	// character is moving, update the last velocity rotation. This value is saved because it might
	// be useful to know the last orientation of a movement even after the character has stopped.

	LocomotionState.Speed = UE_REAL_TO_FLOAT(LocomotionState.Velocity.Size2D());

	static constexpr auto HasSpeedThreshold{1.0f};

	LocomotionState.bHasVelocity = LocomotionState.Speed >= HasSpeedThreshold;

	if (LocomotionState.bHasVelocity)
	{
		LocomotionState.VelocityYawAngle = UE_REAL_TO_FLOAT(UGMS_Vector::DirectionToAngleXY(LocomotionState.Velocity));
	}

	// Character is moving if has speed and current acceleration, or if the speed is greater than the moving speed threshold.

	LocomotionState.bMoving = (LocomotionState.bHasInput && LocomotionState.bHasVelocity) ||
		LocomotionState.Speed > ControlSetting->MovingSpeedThreshold;
}

void UGMS_CharacterMovementSystemComponent::RefreshDynamicMovementState()
{
	if (bAllowRefreshCharacterMovementSettings)
	{
		return;
	}

	if (IsValid(SpeedToMovementStateCurve) && OwnerPawn->HasAuthority())
	{
		int32 Index = UKismetMathLibrary::Round(SpeedToMovementStateCurve->GetFloatValue(LocomotionState.Speed));
		FGMS_MovementStateSetting TempSetting;
		if (ControlSetting->GetStateByIndex(Index, TempSetting))
		{
			SetDesiredMovement(TempSetting.Tag);
		}
		else
		{
			GMS_CLOG(Warning, "Found invalid index output from SpeedToMovementStateCurve, Index(%d) of movement definitions can't be found. dynamic adjust movement state failed! Actor:%s",
			         Index, *GetOwner()->GetName());
		}
	}
}

void UGMS_CharacterMovementSystemComponent::RefreshLocomotionLate(const float DeltaTime)
{
	if (!LocomotionMode.IsValid())
	{
		RefreshTargetYawAngleUsingActorRotation();
	}

	LocomotionState.bResetAimingLimit = !LocomotionState.bAimingLimitAppliedThisFrame;
}

#pragma endregion

void UGMS_CharacterMovementSystemComponent::RefreshRotation_Implementation(float DeltaTime)
{
	RefreshGroundedRotation(DeltaTime);
	RefreshInAirRotation(DeltaTime);
}

void UGMS_CharacterMovementSystemComponent::RefreshGroundedRotation(const float DeltaTime)
{
	if (LocomotionMode != GMS_MovementModeTags::Grounded || GetGameplayTags().HasAny(GroundedRotationBlockingTags))
	{
		return;
	}

	if (OwnerCharacter->HasAnyRootMotion())
	{
		RefreshTargetYawAngleUsingActorRotation();
		return;
	}

	if (!LocomotionState.bMoving)
	{
		RefreshGroundedNotMovingRotation(DeltaTime);
	}
	else
	{
		RefreshGroundedMovingRotation(DeltaTime);
	}
}

void UGMS_CharacterMovementSystemComponent::RefreshGroundedNotMovingRotation(float DeltaTime)
{
	ApplyRotationYawSpeedAnimationCurve(DeltaTime);

	if (RefreshCustomGroundedNotMovingRotation(DeltaTime))
	{
		return;
	}

	if (RotationMode == GMS_RotationModeTags::ViewDirection)
	{
		if (const auto* Setting = ControlSetting->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Default>())
		{
			if (Setting->bEnableRotationWhenNotMoving)
			{
				// const auto& TargetYawAngle = LocomotionState.bHasInput ? ViewState.Rotation.Yaw : LocomotionState.TargetYawAngle;
				SetRotationExtraSmooth(ViewState.Rotation.Yaw, DeltaTime, Setting->RotationInterpolationSpeed, Setting->TargetYawAngleRotationSpeed);
				return;
			}
			return;
		}

		if (const auto* Setting = ControlSetting->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Aiming>())
		{
			// refresh not moving aiming rotation.
			{
				if (Setting->bEnableRotationWhenNotMoving) // 吸附到视角
				{
					SetRotationExtraSmooth(ViewState.Rotation.Yaw, DeltaTime, Setting->RotationInterpolationSpeed, Setting->TargetYawAngleRotationSpeed);
					return;
				}

				SetTargetYawAngle(ViewState.Rotation.Yaw);

				FRotator NewActorRotation{GetOwner()->GetActorRotation()};

				//Limit rotation so turn in place can catch up.
				if (ConstrainAimingRotation(NewActorRotation, DeltaTime, true))
				{
					SetActorRotation(NewActorRotation);
				}
			}
			return;
		}
	}

	if (RotationMode == GMS_RotationModeTags::VelocityDirection)
	{
		if (const auto* Setting = ControlSetting->VelocityDirectionSetting.GetPtr<FGMS_VelocityDirectionSetting_Default>())
		{
			if (Setting->bEnableRotationWhenNotMoving)
			{
				SetRotationExtraSmooth(LocomotionState.TargetYawAngle, DeltaTime, Setting->RotationInterpolationSpeed, Setting->TargetYawAngleRotationSpeed);
				return;
			}
		}

		if (const auto* Setting = ControlSetting->VelocityDirectionSetting.GetPtr<FGMS_VelocityDirectionSetting_RateBased>())
		{
			if (Setting->bEnableRotationWhenNotMoving)
			{
				SetRotationInstant(DesiredVelocityYawAngle, ETeleportType::None);
				return;
			}
		}
	}

	RefreshTargetYawAngleUsingActorRotation();
}

float UGMS_CharacterMovementSystemComponent::CalculateGroundedMovingRotationInterpolationSpeed(TObjectPtr<UCurveFloat> InterpolationSpeedCurve, float Default) const
{
	// Calculate the rotation speed by using the rotation speed curve in the rotation settings. Using
	// the curve in conjunction with the speed amount gives you a high level of control over the rotation
	// rates for each speed. Increase the speed if the camera is rotating quickly for more responsive rotation.

	const auto InterpolationHalfLife{
		IsValid(InterpolationSpeedCurve)
			? InterpolationSpeedCurve->GetFloatValue(FMath::Max(1.0f, GetMappedMovementSpeedLevel(UE_REAL_TO_FLOAT(LocomotionState.Velocity.Size2D()))))
			: Default
	};

	static constexpr auto MinInterpolationHalfLifeMultiplier{0.333333f};
	static constexpr auto ReferenceViewYawSpeed{300.0f};

	return InterpolationHalfLife * UGMS_Math::LerpClamped(1.0f, MinInterpolationHalfLifeMultiplier,
	                                                      ViewState.YawSpeed / ReferenceViewYawSpeed);
}

void UGMS_CharacterMovementSystemComponent::RefreshGroundedMovingRotation(float DeltaTime)
{
	// Moving.
	if (RefreshCustomGroundedMovingRotation(DeltaTime))
	{
		return;
	}

	if (RotationMode == GMS_RotationModeTags::ViewDirection)
	{
		if (const auto* Setting = ControlSetting->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Default>())
		{
			//TODO maybe use root yaw offset here?
			float RotationYawOffset = AnimationInstance->GetCurveValue(UGMS_Constants::RotationYawOffsetCurveName());
			const auto& TargetYawAngle = UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw + RotationYawOffset);
			GMS_CLOG(VeryVerbose, "rotating to target yaw angle(%f) with Yaw offset(%f)", TargetYawAngle, RotationYawOffset);

			const float CalculatedRotationInterpolationSpeed = CalculateGroundedMovingRotationInterpolationSpeed(Setting->RotationInterpolationSpeedCurve, Setting->RotationInterpolationSpeed);
			SetRotationExtraSmooth(TargetYawAngle, DeltaTime, CalculatedRotationInterpolationSpeed, Setting->TargetYawAngleRotationSpeed);
			return;
		}

		if (const auto* Setting = ControlSetting->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Aiming>())
		{
			//TODO Should use this if using root yaw offset?
			FRotator NewActorRotation{GetOwner()->GetActorRotation()};

			SetTargetYawAngleSmooth(UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw), DeltaTime, Setting->TargetYawAngleRotationSpeed);

			GMS_CLOG(VeryVerbose, "wants to aiming to target yaw angle(%f) with view yaw(%f)", NewActorRotation.Yaw, ViewState.Rotation.Yaw);

			NewActorRotation.Yaw = UGMS_Rotation::DamperExactAngle(
				UE_REAL_TO_FLOAT(FMath::UnwindDegrees(NewActorRotation.Yaw)), LocomotionState.SmoothTargetYawAngle, DeltaTime, Setting->RotationInterpolationSpeed);
			if (ConstrainAimingRotation(NewActorRotation, DeltaTime))
			{
				// Cancel the extra smooth rotation, otherwise the actor will rotate too weirdly.
				LocomotionState.SmoothTargetYawAngle = LocomotionState.TargetYawAngle;
			}

			GMS_CLOG(VeryVerbose, "aiming to target yaw angle(%f)", NewActorRotation.Yaw);

			SetActorRotation(NewActorRotation);

			return;
		}
	}

	if (RotationMode == GMS_RotationModeTags::VelocityDirection)
	{
		if (const auto* Setting = ControlSetting->VelocityDirectionSetting.GetPtr<FGMS_VelocityDirectionSetting_RateBased>())
		{
			SetRotationInstant(DesiredVelocityYawAngle, ETeleportType::None);
			return;
		}

		if (const auto* Setting = ControlSetting->VelocityDirectionSetting.GetPtr<FGMS_VelocityDirectionSetting_Default>())
		{
			if (LocomotionState.bHasInput)
			{
				const auto& TargetRotation = Setting->bOrientateToMoveInputIntent ? LocomotionState.InputYawAngle : LocomotionState.VelocityYawAngle;
				const float CalculatedRotationInterpolationSpeed = CalculateGroundedMovingRotationInterpolationSpeed(Setting->RotationInterpolationSpeedCurve, Setting->RotationInterpolationSpeed);
				GMS_CLOG(VeryVerbose, "rotating to target yaw angle(%f) at rotation speed(%f)", TargetRotation, CalculatedRotationInterpolationSpeed);
				SetRotationExtraSmooth(TargetRotation, DeltaTime, CalculatedRotationInterpolationSpeed, Setting->TargetYawAngleRotationSpeed);
			}
			return;
		}
	}

	RefreshTargetYawAngleUsingActorRotation();
}

bool UGMS_CharacterMovementSystemComponent::ConstrainAimingRotation(FRotator& ActorRotation, float DeltaTime, bool bApplySecondaryConstraint)
{
	const FGMS_ViewDirectionSetting_Aiming* Setting = ControlSetting->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Aiming>();
	if (Setting == nullptr)
	{
		return false;
	}

	LocomotionState.bAimingLimitAppliedThisFrame = true;

	if (LocomotionState.bResetAimingLimit)
	{
		LocomotionState.AimingYawAngleLimit = 180.0f;
	}

	// Limit the actor's rotation when aiming to prevent situations where the lower body noticeably
	// fails to keep up with the rotation of the upper body when the camera is rotating very fast.

	float ViewRelativeAngle{FRotator3f::NormalizeAxis(UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw - ActorRotation.Yaw))};

	if (FMath::Abs(ViewRelativeAngle) <= Setting->MinAimingYawAngleLimit + UE_KINDA_SMALL_NUMBER)
	{
		LocomotionState.AimingYawAngleLimit = Setting->MinAimingYawAngleLimit;
		return false;
	}

	ViewRelativeAngle = UGMS_Rotation::RemapAngleForCounterClockwiseRotation(ViewRelativeAngle);

	// Secondary constraint. Simply increases the actor's rotation speed. Typically only used when the actor is standing still.

	if (bApplySecondaryConstraint)
	{
		static constexpr auto RotationInterpolationHalfLife{0.1f};

		// Interpolate the angle only to the point where the constraints no longer apply to ensure a smoother completion of the rotation.

		const auto TargetViewRelativeAngle{
			FMath::Clamp(ViewRelativeAngle, -Setting->MinAimingYawAngleLimit,
			             Setting->MinAimingYawAngleLimit)
		};


		const auto DeltaAngle{FMath::UnwindDegrees(TargetViewRelativeAngle - ViewRelativeAngle)};

		if (FMath::IsNearlyZero(DeltaAngle, UE_KINDA_SMALL_NUMBER))
		{
			ViewRelativeAngle = TargetViewRelativeAngle;
		}
		else
		{
			const auto InterpolationAmount{UGMS_Math::DamperExactAlpha(DeltaTime, RotationInterpolationHalfLife)};
			ViewRelativeAngle = FMath::UnwindDegrees(ViewRelativeAngle + DeltaAngle * InterpolationAmount);
		}
	}

	// Primary constraint. Prevents the actor from rotating beyond a certain angle relative to the camera.

	if (FMath::Abs(ViewRelativeAngle) > LocomotionState.AimingYawAngleLimit + UE_KINDA_SMALL_NUMBER)
	{
		ViewRelativeAngle = FMath::Clamp(ViewRelativeAngle, -LocomotionState.AimingYawAngleLimit, LocomotionState.AimingYawAngleLimit);
	}
	else
	{
		LocomotionState.AimingYawAngleLimit = FMath::Max(FMath::Abs(ViewRelativeAngle), Setting->MinAimingYawAngleLimit);
	}

	const auto PreviousActorYawAngle{ActorRotation.Yaw};

	ActorRotation.Yaw = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw - ViewRelativeAngle));

	// We use UE_KINDA_SMALL_NUMBER here because even if ViewRelativeAngle hasn't
	// changed, converting it back to ActorRotation.Yaw may introduce a rounding
	// error, and FMath::IsNearlyZero() with default arguments will return false.

	return !FMath::IsNearlyZero(FMath::UnwindDegrees(ActorRotation.Yaw - PreviousActorYawAngle), UE_KINDA_SMALL_NUMBER);
}

bool UGMS_CharacterMovementSystemComponent::ApplyRotationYawSpeedAnimationCurve(float DeltaTime)
{
	// Use curve to drive actor rotation only if no root bone rotation. 仅在没有使用根骨旋转时，采用曲线驱动Actor旋转。
	if (UGMS_MainAnimInstance* AnimInst = Cast<UGMS_MainAnimInstance>(MainAnimInstance))
	{
		if (AnimInst->GetOffsetRootBoneRotationMode() != EOffsetRootBoneMode::Release)
		{
			return false;
		}
	}
	const float CurveValue = AnimationInstance->GetCurveValue(UGMS_Constants::RotationYawSpeedCurveName());
	const float DeltaYawAngle{CurveValue * DeltaTime};

	if (FMath::Abs(DeltaYawAngle) > UE_SMALL_NUMBER)
	{
		auto NewActorRotation{GetOwner()->GetActorRotation()};
		NewActorRotation.Yaw += DeltaYawAngle;

		SetActorRotation(NewActorRotation);

		RefreshTargetYawAngleUsingActorRotation();
		return true;
	}
	return false;
}

bool UGMS_CharacterMovementSystemComponent::RefreshCustomGroundedMovingRotation_Implementation(float DeltaTime)
{
	return false;
}

bool UGMS_CharacterMovementSystemComponent::RefreshCustomGroundedNotMovingRotation_Implementation(float DeltaTime)
{
	return false;
}

void UGMS_CharacterMovementSystemComponent::RefreshInAirRotation(const float DeltaTime)
{
	if (LocomotionMode != GMS_MovementModeTags::InAir || GetGameplayTags().HasAny(InAirRotationBlockingTags))
	{
		return;
	}

	if (RotationMode == GMS_RotationModeTags::VelocityDirection || RotationMode == GMS_RotationModeTags::ViewDirection)
	{
		switch (ControlSetting->InAirRotationMode)
		{
		case EGMS_InAirRotationMode::RotateToVelocityOnJump:
			if (LocomotionState.bMoving)
			{
				SetRotationSmooth(LocomotionState.VelocityYawAngle, DeltaTime, ControlSetting->InAirRotationInterpolationSpeed);
			}
			else
			{
				RefreshTargetYawAngleUsingActorRotation();
			}
			break;

		case EGMS_InAirRotationMode::KeepRelativeRotation:
			SetRotationSmooth(
				FRotator3f::NormalizeAxis(UE_REAL_TO_FLOAT(ViewState.Rotation.Yaw) - LocomotionState.ViewRelativeTargetYawAngle),
				DeltaTime, ControlSetting->InAirRotationInterpolationSpeed);
			break;

		default:
			RefreshTargetYawAngleUsingActorRotation();
			break;
		}
	}
	else
	{
		RefreshTargetYawAngleUsingActorRotation();
	}
}

void UGMS_CharacterMovementSystemComponent::SetRotationInstant_Implementation(const float TargetYawAngle, const ETeleportType Teleport)
{
	SetTargetYawAngle(TargetYawAngle);

	auto NewRotation{GetOwner()->GetActorRotation()};
	NewRotation.Yaw = TargetYawAngle;

	SetActorRotation(NewRotation);
}

void UGMS_CharacterMovementSystemComponent::SetRotationSmooth_Implementation(const float TargetYawAngle, const float DeltaTime, const float InterpolationHalfLife)
{
	SetTargetYawAngle(TargetYawAngle);

	auto DesiredRotation{OwnerPawn->GetActorRotation()};
	DesiredRotation.Yaw = UGMS_Rotation::DamperExactAngle(UE_REAL_TO_FLOAT(FMath::UnwindDegrees(DesiredRotation.Yaw)),
	                                                      LocomotionState.SmoothTargetYawAngle, DeltaTime, InterpolationHalfLife);


	SetActorRotation(DesiredRotation);
}

void UGMS_CharacterMovementSystemComponent::SetRotationExtraSmooth_Implementation(const float TargetYawAngle, const float DeltaTime,
                                                                                  const float InterpolationHalfLife, const float TargetYawAngleRotationSpeed)
{
	SetTargetYawAngleSmooth(TargetYawAngle, DeltaTime, TargetYawAngleRotationSpeed);

	auto DesiredRotation{OwnerPawn->GetActorRotation()};
	DesiredRotation.Yaw = UGMS_Rotation::DamperExactAngle(UE_REAL_TO_FLOAT(FMath::UnwindDegrees(DesiredRotation.Yaw)),
	                                                      LocomotionState.SmoothTargetYawAngle, DeltaTime, InterpolationHalfLife);

	SetActorRotation(DesiredRotation);
}

void UGMS_CharacterMovementSystemComponent::RefreshTargetYawAngleUsingActorRotation()
{
	const auto YawAngle{UE_REAL_TO_FLOAT(OwnerPawn->GetActorRotation().Yaw)};

	SetTargetYawAngle(YawAngle);
}

void UGMS_CharacterMovementSystemComponent::SetTargetYawAngle(const float TargetYawAngle)
{
	LocomotionState.TargetYawAngle = FMath::UnwindDegrees(TargetYawAngle);

	RefreshViewRelativeTargetYawAngle();

	LocomotionState.SmoothTargetYawAngle = LocomotionState.TargetYawAngle;
}

void UGMS_CharacterMovementSystemComponent::SetTargetYawAngleSmooth(float TargetYawAngle, float DeltaTime, float RotationSpeed)
{
	LocomotionState.TargetYawAngle = FMath::UnwindDegrees(TargetYawAngle);

	LocomotionState.SmoothTargetYawAngle = UGMS_Rotation::InterpolateAngleConstant(
		LocomotionState.SmoothTargetYawAngle, LocomotionState.TargetYawAngle, DeltaTime, RotationSpeed);

	RefreshViewRelativeTargetYawAngle();
}

void UGMS_CharacterMovementSystemComponent::RefreshViewRelativeTargetYawAngle()
{
	LocomotionState.ViewRelativeTargetYawAngle = FMath::UnwindDegrees(UE_REAL_TO_FLOAT(
		ViewState.Rotation.Yaw - LocomotionState.TargetYawAngle));
}

void UGMS_CharacterMovementSystemComponent::SetActorRotation(FRotator DesiredRotation)
{
	const bool bWantsToBeVertical = CharacterMovement->ShouldRemainVertical();

	if (bWantsToBeVertical)
	{
		DesiredRotation.Pitch = 0.f;
		DesiredRotation.Yaw = FMath::UnwindDegrees(DesiredRotation.Yaw);
		DesiredRotation.Roll = 0.f;
	}
	else
	{
		DesiredRotation.Normalize();
	}
	OwnerPawn->SetActorRotation(DesiredRotation);
}

FGMS_PredictGroundMovementPivotLocationParams UGMS_CharacterMovementSystemComponent::GetPredictGroundMovementPivotLocationParams() const
{
	FGMS_PredictGroundMovementPivotLocationParams Params;
	if (CharacterMovement)
	{
		Params.Acceleration = CharacterMovement->GetCurrentAcceleration();
		Params.Velocity = CharacterMovement->GetLastUpdateVelocity();
		Params.GroundFriction = CharacterMovement->GroundFriction;
	}
	return Params;
}

FGMS_PredictGroundMovementStopLocationParams UGMS_CharacterMovementSystemComponent::GetPredictGroundMovementStopLocationParams() const
{
	FGMS_PredictGroundMovementStopLocationParams Params;
	if (CharacterMovement)
	{
		Params.Velocity = CharacterMovement->GetLastUpdateVelocity();
		Params.bUseSeparateBrakingFriction = CharacterMovement->bUseSeparateBrakingFriction;
		Params.BrakingFriction = CharacterMovement->BrakingFriction;
		Params.GroundFriction = CharacterMovement->GroundFriction;
		Params.BrakingFrictionFactor = CharacterMovement->BrakingFrictionFactor;
		Params.BrakingDecelerationWalking = CharacterMovement->BrakingDecelerationWalking;
	}
	return Params;
}