// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "WeaponBase.generated.h"

UENUM(BlueprintType)
enum class EWeaponType : uint8
{
	WT_DualSword UMETA(DisplayName = "DualSword"),
	WT_Hammer UMETA(DisplayName = "Hammer"),
	WT_Nunchaku UMETA(DisplayName = "Nunchaku"),
	WT_Spear UMETA(DisplayName = "Spear"),
	WT_Sword UMETA(DisplayName = "Sword")
};

enum class EDualWeaponDirection
{
	Left, Right
};

USTRUCT(Atomic, BlueprintType)
struct FWeaponInfo
{
	GENERATED_USTRUCT_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		EWeaponType WeaponType;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimMontage* AtkMontage;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int MaxComboCount;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		TArray<int> ComboDamage;
};

UCLASS()
class MAINPLAYERCODES_API AWeaponBase : public AActor
{
	GENERATED_BODY()

public:
	// Sets default values for this actor's properties
	AWeaponBase();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	void SetActiveActor(bool IsActive);

protected:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh")
	class USkeletalMeshComponent* WeaponMesh;

private:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh", meta = (AllowPrivateAccess = "True"))
	FWeaponInfo WeaponInfo;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Mesh", meta = (AllowPrivateAccess = "True"))
	float CurrentDamage;

public:
	virtual void AttachToPlayer();

	virtual void Deattach();

	virtual void Equip();

	virtual void TakeOff();

	virtual void AttackStart(const int32& ComboIndex, const float& AddDamage);

	virtual void AttackEnd();

	virtual void DualAttackStart(const int32& ComboIndex, const float& AddDamage, const EDualWeaponDirection& WeaponDirection);

	virtual void DualAttackEnd(const EDualWeaponDirection& WeaponDirection);

protected:
	UFUNCTION()
		virtual void WeaponBeginOverlap(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

public:
	FORCEINLINE const FWeaponInfo& GetWeaponInfo() const { return WeaponInfo; }

	FORCEINLINE const float& GetCurrentDamage() const { return CurrentDamage; }
	FORCEINLINE void SetCurrentDamage(const float& Damage) { CurrentDamage = Damage; }
};

// Fill out your copyright notice in the Description page of Project Settings.


#include "WeaponBase.h"

#include "Kismet/GameplayStatics.h"
#include "GameFramework/Character.h"
#include "Components/SkinnedMeshComponent.h"

#include "MainPlayer.h"

// Sets default values
AWeaponBase::AWeaponBase()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
	
	WeaponMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("WeaponMesh"));
	RootComponent = WeaponMesh;
	//WeaponMesh->SetupAttachment(RootComponent);
}

// Called when the game starts or when spawned
void AWeaponBase::BeginPlay()
{
	Super::BeginPlay();
	
}

// Called every frame
void AWeaponBase::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

void AWeaponBase::SetActiveActor(bool IsActive)
{
	SetActorHiddenInGame(!IsActive);

	SetActorEnableCollision(!IsActive);

	SetActorTickEnabled(!IsActive);
}

void AWeaponBase::AttachToPlayer()
{
	ACharacter* PlayerCharacter = UGameplayStatics::GetPlayerCharacter(GetWorld(),0);
	
	WeaponMesh->USkinnedMeshComponent::SetMasterPoseComponent(PlayerCharacter->GetMesh(), true);
	AttachToComponent(PlayerCharacter->GetMesh(), FAttachmentTransformRules::SnapToTargetIncludingScale);
	AMainPlayer* MainPlayer = Cast<AMainPlayer>(PlayerCharacter);
	if (MainPlayer)
	{
		MainPlayer->AttachWeapon(this);
	}
}

void AWeaponBase::Deattach()
{
	
}

void AWeaponBase::Equip()
{
	SetActiveActor(true);
}

void AWeaponBase::TakeOff()
{
	SetActiveActor(false);
}

void AWeaponBase::AttackStart(const int32& ComboIndex, const float& AddDamage)
{
	CurrentDamage = GetWeaponInfo().ComboDamage[ComboIndex - 1] + AddDamage;
}

void AWeaponBase::AttackEnd()
{
}

void AWeaponBase::DualAttackStart(const int32& ComboIndex, const float& AddDamage, const EDualWeaponDirection& WeaponDirection)
{
	CurrentDamage = GetWeaponInfo().ComboDamage[ComboIndex - 1] + AddDamage;
}

void AWeaponBase::DualAttackEnd(const EDualWeaponDirection& WeaponDirection)
{
}

void AWeaponBase::WeaponBeginOverlap(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	// 공격
}