// Copyright Damir Halilovic 2014 - 2015

#include "ProjectWa.h"
#include "DamageTypePhysical.h"
#include "WaSharedCharacter.h"
#include "EnemyPawnBase.h"
#include "WaCharacterBase.h"
#include "EnemyCharacterBase.h"
#include "WeaponBase.h"


// Sets default values
AWeaponBase::AWeaponBase(const FObjectInitializer& OI)
    : Super(OI)
{
    PrimaryActorTick.bCanEverTick = true;

    DamageType = UDamageTypePhysical::StaticClass();
    DamageMultiplier = 1.0f;


    Mesh = CreateDefaultSubobject<USkeletalMeshComponent>("Mesh");
    if (Mesh != nullptr)
    {
        RootComponent = Mesh;
    }

    WeaponDamageArea = CreateDefaultSubobject<UBoxComponent>("DamageArea");
    if (WeaponDamageArea != nullptr)
    {
        WeaponDamageArea->SetBoxExtent(FVector(20.f, 20.f, 20.f), false);
        WeaponDamageArea->AttachTo(RootComponent);


    }

}

// Called when the game starts
void AWeaponBase::BeginPlay()
{
    Super::BeginPlay();
    WeaponDamageArea->OnComponentBeginOverlap.AddDynamic(this, &AWeaponBase::OnDamageAreaBeginOverlap);
    WeaponDamageArea->OnComponentEndOverlap.AddDynamic(this, &AWeaponBase::OnDamageAreaEndOverlap);

}

void AWeaponBase::InitializeWeapon(UCombatComponent* OwnerCombatComponent)
{
    CombatComponent = OwnerCombatComponent;
    SetWeaponVisibility(CombatComponent->bWieldingRanged == IsRanged());
}

void AWeaponBase::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
    WeaponDamageArea->OnComponentBeginOverlap.RemoveDynamic(this, &AWeaponBase::OnDamageAreaBeginOverlap);
}

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

}

APawn* AWeaponBase::GetOwnerPawn()
{
    return CombatComponent == nullptr ? nullptr : Cast<APawn>(CombatComponent->GetOwner());
}

void AWeaponBase::OnDamageAreaBeginOverlap(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (!bDoingDamage)
    {
        OverlappingActors.Add(OtherActor);
    }
    else
    {
        APawn* OwnerPawn = GetOwnerPawn();
        if (OwnerPawn == nullptr)
        {
            UE_LOG(WaGeneral, Error, TEXT("The owner pawn of a weapon is null."));
            return;
        }

        ProcessDamage(OtherActor, OwnerPawn);
    }
}

void AWeaponBase::OnDamageAreaEndOverlap(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    OverlappingActors.RemoveSingleSwap(OtherActor);
}

void AWeaponBase::ProcessDamageOnOverlapping()
{
    if (OverlappingActors.Num() > 0)
    {
        APawn* OwnerPawn = GetOwnerPawn();
        if (OwnerPawn == nullptr)
        {
            UE_LOG(WaGeneral, Error, TEXT("The owner pawn of a weapon is null."));
            return;
        }
        for (auto* Actor : OverlappingActors)
        {
            ProcessDamage(Actor, OwnerPawn);
        }
        OverlappingActors.Empty();
    }
}

bool AWeaponBase::ProcessDamage(AActor* OtherActor, APawn* OwnerPawn, const bool bIsProjectile)
{
    if (OtherActor != nullptr && (bDoingDamage || bIsProjectile) && OtherActor != OwnerPawn && IsHostile(OtherActor) && !DamagedActors.Contains(OtherActor))
    {
        float Damage = CombatComponent->GetWeaponDamage(DamageType, DamageMultiplier);
        float Force = WeaponForce;

        if (DamageMultiplierCurve != nullptr)
        {
            Damage *= DamageMultiplierCurve->GetFloatValue(CombatComponent->ConsequentAttacks - 1);
        }

        if (ForceMultiplierCurve != nullptr)
        {
            Force *= ForceMultiplierCurve->GetFloatValue(CombatComponent->ConsequentAttacks - 1);
        }

        FDamageEvent Event(DamageType);

        if (OtherActor->IsA(AWaSharedCharacter::StaticClass()))
        {
            AWaSharedCharacter* WaCharacter = Cast<AWaSharedCharacter>(OtherActor);
            WaCharacter->TakeDamageWithStatusEffects(Damage, DamageType, OwnerPawn->GetController(), OwnerPawn, Force, GetOnHitTargetStatusEffects());
        }
        else if (OtherActor->IsA(AEnemyPawnBase::StaticClass()))
        {
            AEnemyPawnBase* EnemyPawn = Cast<AEnemyPawnBase>(OtherActor);
            EnemyPawn->TakeDamageWithStatusEffects(Damage, DamageType, OwnerPawn->GetController(), OwnerPawn, Force, GetOnHitTargetStatusEffects());
        }
        else if (OtherActor->IsA(AEnemyCharacterBase::StaticClass()))
        {
            AEnemyCharacterBase* EnemyCharacter = Cast<AEnemyCharacterBase>(OtherActor);
            EnemyCharacter->TakeDamageWithStatusEffects(Damage, DamageType, OwnerPawn->GetController(), OwnerPawn, Force, GetOnHitTargetStatusEffects());
        }
        else
        {
            UE_LOG(WaGeneral, Warning, TEXT("Hit something that shouldn't be possible to hit: %s"), *OtherActor->GetName());
        }

        CombatComponent->ApplyStatusEffects(GetOnHitSelfStatusEffects());

        DamagedActors.Add(OtherActor);

        return true;
    }
    else if (DamagedActors.Contains(OtherActor))
    {
        UE_LOG(WaGeneral, Log, TEXT("The damaged actors for this swing already contains %s"), *OtherActor->GetName());
        return false;
    }


    return false;
}

TArray<UStatusEffect*> AWeaponBase::GetOnHitTargetStatusEffects()
{
    TArray<UStatusEffect*> StatusEffects;

    for (FWeaponEnhancement Enhancement : Enhancements)
    {
        float Chance = FMath::FRand();
        if (Chance <= Enhancement.ChanceToApply)
        {
            if (Enhancement.ApplicationTarget == EEnhancementTarget::ET_TARGET)
            {
                StatusEffects.Add(Enhancement.Effect);
            }
        }
    }

    return StatusEffects;
}

TArray<UStatusEffect*> AWeaponBase::GetOnHitSelfStatusEffects()
{
    TArray<UStatusEffect*> StatusEffects;

    for (FWeaponEnhancement Enhancement : Enhancements)
    {
        float Chance = FMath::FRand();
        if (Chance <= Enhancement.ChanceToApply)
        {
            if (Enhancement.ApplicationTarget == EEnhancementTarget::ET_SELF)
            {
                StatusEffects.Add(Enhancement.Effect);
            }
        }
    }

    return StatusEffects;
}

void AWeaponBase::ClearDamagedActors()
{
    DamagedActors.Empty();
}

float AWeaponBase::GetSwingStaminaCost(int32 SubsequentSwing)
{
    if (StaminaCostMultiplierCurve == nullptr)
    {
        return StaminaCost;
    }
    else
    {
        return StaminaCost * StaminaCostMultiplierCurve->GetFloatValue(SubsequentSwing);
    }
}



void AWeaponBase::SetWeaponVisibility(bool bVisible)
{
    bIsVisible = bVisible;
    RootComponent->SetVisibility(bIsVisible, true);
    SetActorHiddenInGame(!bIsVisible);
    SetActorEnableCollision(bIsVisible);
    SetActorTickEnabled(bIsVisible);
    //bHiddenEd = !bIsVisible;


#if WITH_EDITOR
    SetIsTemporarilyHiddenInEditor(!bIsVisible);
#endif

    FString VisibilityString = bVisible ? "True" : "False";
    UE_LOG(WaGeneral, Log, TEXT("Setting the visibility of %s to %s"), *GetName(), *VisibilityString);
}

bool AWeaponBase::GetWeaponVisibility()
{
    return bIsVisible;
}

bool AWeaponBase::IsRanged()
{
    return this->IsA(ARangedWeaponBase::StaticClass());
}

bool AWeaponBase::IsHostile(AActor* OtherActor) const
{
    return CombatComponent->IsHostile(OtherActor);
}