// Copyright Epic Games, Inc. All Rights Reserved.

#include "ForestryCharacter.h"

#include "DebugMessages.h"
#include "Animation/AnimInstance.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "EnhancedInputComponent.h"
#include "InputActionValue.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Forestry.h"

AForestryCharacter::AForestryCharacter()
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(55.f, 96.0f);

// Create the first person mesh that will be viewed only by this character's owner
FirstPersonMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("First Person Mesh"));

FirstPersonMesh->SetupAttachment(GetMesh());
FirstPersonMesh->SetOnlyOwnerSee(true);
FirstPersonMesh->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::FirstPerson;
FirstPersonMesh->SetCollisionProfileName(FName("NoCollision"));

// Create the Camera Component
FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("First Person Camera"));
FirstPersonCameraComponent->SetupAttachment(FirstPersonMesh, FName("head"));
FirstPersonCameraComponent->SetRelativeLocationAndRotation(FVector(-2.8f, 5.89f, 0.0f), FRotator(0.0f, 90.0f, -90.0f));
FirstPersonCameraComponent->bUsePawnControlRotation = true;
FirstPersonCameraComponent->bEnableFirstPersonFieldOfView = true;
FirstPersonCameraComponent->bEnableFirstPersonScale = true;
FirstPersonCameraComponent->FirstPersonFieldOfView = 70.0f;
FirstPersonCameraComponent->FirstPersonScale = 0.6f;

// configure the character comps
GetMesh()->SetOwnerNoSee(true);
GetMesh()->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::WorldSpaceRepresentation;

GetCapsuleComponent()->SetCapsuleSize(34.0f, 96.0f);

// Interactable Searcher
InteractableSearcher = CreateDefaultSubobject<UInteractableSearcher>("Interactable Searcher");

// Statistics Component
StatisticsComponent = CreateDefaultSubobject<UStatisticsComponent>("Statistics");

// Flashlight Component
FlashlightComponent = CreateDefaultSubobject<UFlashlightComponent>("Flashlight");

// Crouch Helper
CrouchHelper = CreateDefaultSubobject<UCrouchHelper>("Crouch Helper");
CrouchHelper->Setup(GetCapsuleComponent());

// Configure character movement
GetCharacterMovement()->BrakingDecelerationFalling = 1500.0f;
GetCharacterMovement()->AirControl = 0.5f;
GetCharacterMovement()->MaxWalkSpeed = WalkSpeed;

// Physics Handle
PhysicsHandleComponent = CreateDefaultSubobject<UPhysicsHandleComponent>("PhysicsHandle");
PhysicsHandleComponent->LinearStiffness = 2000.f;
PhysicsHandleComponent->AngularStiffness = 2000.f;
PhysicsHandleComponent->LinearDamping = 100.f;
PhysicsHandleComponent->AngularDamping = 100.f;
}

bool AForestryCharacter::CanStand() const
{
if (!GetCapsuleComponent()) return false;

UCapsuleComponent* Capsule = GetCapsuleComponent();
float CurrentHalfHeight = Capsule->GetUnscaledCapsuleHalfHeight();
float DesiredHalfHeight = CrouchHelper->GetStandHeight();

if (CurrentHalfHeight >= DesiredHalfHeight)
return true;

float Radius = Capsule->GetUnscaledCapsuleRadius();

FVector Start = Capsule->GetComponentLocation() + FVector(0,0,CurrentHalfHeight);
FVector End = Capsule->GetComponentLocation() + FVector(0,0,DesiredHalfHeight);

FHitResult Hit;
FCollisionQueryParams Params;
Params.AddIgnoredActor(this);

bool bHit = GetWorld()->SweepSingleByChannel(
Hit,
Start,
End,
FQuat::Identity,
ECC_Visibility,
FCollisionShape::MakeCapsule(Radius, DesiredHalfHeight - CurrentHalfHeight),
Params
);

return !bHit;
}

void AForestryCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
// Set up action bindings
if (UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent))
{
// Crouching
EnhancedInputComponent->BindAction(CrouchAction, ETriggerEvent::Started, this, &AForestryCharacter::DoCrouchStart);
EnhancedInputComponent->BindAction(CrouchAction, ETriggerEvent::Completed, this, &AForestryCharacter::DoCrouchEnd);

// Sprinting
EnhancedInputComponent->BindAction(SprintAction, ETriggerEvent::Started, this, &AForestryCharacter::DoSprintStart);
EnhancedInputComponent->BindAction(SprintAction, ETriggerEvent::Completed, this, &AForestryCharacter::DoSprintEnd);

// Jumping
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &AForestryCharacter::DoJumpStart);
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &AForestryCharacter::DoJumpEnd);

// Moving
EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AForestryCharacter::MoveInput);

// Looking/Aiming
EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AForestryCharacter::LookInput);
EnhancedInputComponent->BindAction(MouseLookAction, ETriggerEvent::Triggered, this, &AForestryCharacter::LookInput);

if (InteractableSearcher) InteractableSearcher->SetupPlayerInput(EnhancedInputComponent);
if (FlashlightComponent) FlashlightComponent->SetupPlayerInput(EnhancedInputComponent);
}
else
{
UE_LOG(LogForestry, Error, TEXT("'%s' Failed to find an Enhanced Input Component! This template is built to use the Enhanced Input system. If you intend to use the legacy system, then you will need to update this C++ file."), *GetNameSafe(this));
}
}

void AForestryCharacter::TickActor(float DeltaTime, ELevelTick TickType, FActorTickFunction& ThisTickFunction)
{
Super::TickActor(DeltaTime, TickType, ThisTickFunction);

if (bIsCrouching)
{
if (bWannaStand)
{
if (!CanStand()) return;

bIsCrouching = false;
bWannaStand = false;
CrouchHelper->Stand();
ChangeMoveSpeed(WalkSpeed);
}
}
}


void AForestryCharacter::MoveInput(const FInputActionValue& Value)
{
// get the Vector2D move axis
FVector2D MovementVector = Value.Get<FVector2D>();

// pass the axis values to the move input
DoMove(MovementVector.X, MovementVector.Y);

// bool bIsMoving = MovementVector != FVector2D::ZeroVector;
}

void AForestryCharacter::LookInput(const FInputActionValue& Value)
{
// get the Vector2D look axis
FVector2D LookAxisVector = Value.Get<FVector2D>();

// pass the axis values to the aim input
DoAim(LookAxisVector.X, LookAxisVector.Y);
}

void AForestryCharacter::ChangeMoveSpeed(const float Speed) const
{
GetCharacterMovement()->MaxWalkSpeed = Speed;
}

void AForestryCharacter::DoAim(float Yaw, float Pitch)
{
if (GetController())
{
// pass the rotation inputs
AddControllerYawInput(Yaw);
AddControllerPitchInput(Pitch);
}
}

void AForestryCharacter::DoMove(float Right, float Forward)
{
if (GetController())
{
// pass the move inputs
AddMovementInput(GetActorRightVector(), Right);
AddMovementInput(GetActorForwardVector(), Forward);
}
}

void AForestryCharacter::DoJumpStart()
{
// pass Jump to the character
if (!bIsCrouching) Jump();
}

void AForestryCharacter::DoJumpEnd()
{
// pass StopJumping to the character
StopJumping();
}

void AForestryCharacter::DoSprintStart()
{
if (StatisticsComponent->GetStatisticCurrentValue(EStatisticType::STAMINA) < MinStaminaToSprint)
{
// TODO: Notify that stamina is too low!
printk(110, "Character: Stamina is too low to sprint!")
return;
}

if (bIsCrouching) return;
if (!GetCharacterMovement()->IsMovingOnGround()) return;

bIsSprinting = true;
StatisticsComponent->SetDrainMultiplierForType(EStatisticType::STAMINA, StatisticsComponent->StaminaSprintMultiplier);
StatisticsComponent->SetDrainMultiplierForType(EStatisticType::THIRST, StatisticsComponent->ThirstSprintMultiplier);
ChangeMoveSpeed(SprintSpeed);
}

void AForestryCharacter::DoSprintEnd()
{
if (!bIsSprinting) return;
bIsSprinting = false;

StatisticsComponent->SetDrainMultiplierForType(EStatisticType::STAMINA, StatisticsComponent->DefaultMultiplier);
StatisticsComponent->SetDrainMultiplierForType(EStatisticType::THIRST, StatisticsComponent->DefaultMultiplier);
ChangeMoveSpeed(WalkSpeed);
}

void AForestryCharacter::DoCrouchStart()
{
if (bIsCrouching) return;
if (bIsSprinting)
DoSprintEnd();

bWannaStand = false;
bIsCrouching = true;
CrouchHelper->Crouch();
ChangeMoveSpeed(CrouchSpeed);
}

void AForestryCharacter::DoCrouchEnd()
{
if (!bIsCrouching) return;
if (!bWannaStand) bWannaStand = true;
}