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


#include "Skill.h"

#include "SkillTrigger.h"
#include "SkillEffects/SkillEffect_Charge.h"
#include "SkillEffects/SkillEffect_Damage.h"
#include "SkillEffects/SkillEffect_DamageReduce.h"
#include "SkillEffects/SkillEffect_EnhanceFishRod.h"
#include "SkillEffects/SkillEffect_EnhanceSkill.h"
#include "SkillEffects/SkillEffect_Heal.h"
#include "SkillEffects/SkillEffect_ModifyCD.h"
#include "SkillEffects/SkillEffect_ModifySpeed.h"
#include "SkillEffects/SkillEffect_SER.h"

void USkill::InitSkill(APawnWithSkill* owner, USkillManager* skillManager, FSkillData skillData, FIntPoint BagPos)
{
	this->Owner = owner;
	this->SkillManager = skillManager;
	this->SkillData = skillData;
	this->BagPosition = BagPos;
	this->RemainingTime = SkillData.CD;
	this->RemainingEndurance = SkillData.Endurance;
	for (auto effectData: skillData.SkillEffects)
	{
		USkillEffect* skillEffect = nullptr ;
		switch (effectData.EffectType)
		{
		case ESkillEffectType::Damage:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_Damage::StaticClass());
			break;
		case ESkillEffectType::Heal:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_Heal::StaticClass());
			break;
		case ESkillEffectType::ModifyCooldown:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_ModifyCD::StaticClass());
			break;
		case ESkillEffectType::Charge:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_Charge::StaticClass());
			break;
		case ESkillEffectType::ModifySpeed:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_ModifySpeed::StaticClass());
			break;
		case ESkillEffectType::SkillEnduranceRestore:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_SER::StaticClass());
			break;
		case ESkillEffectType::EnhanceFishRod:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_EnhanceFishRod::StaticClass());
			break;
		case ESkillEffectType::EnhanceSkill:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_EnhanceSkill::StaticClass());
			break;
		case ESkillEffectType::DamageReduce:
			skillEffect = NewObject<USkillEffect>(this, USkillEffect_DamageReduce::StaticClass());
			break;
		default:
				const UEnum* EnumPtr = StaticEnum<ESkillEffectType>();
				UE_LOG(LogTemp, Error, TEXT("没有配置 %s类型的Skill Effect"), *EnumPtr->GetNameStringByValue(static_cast<int64>(effectData.EffectType)))
		}
		if (IsValid(skillEffect))
		{
			skillEffect->InitSkillEffect(this, effectData);
			this->SkillEffects.Add(skillEffect);
		}
	
	}
}

void USkill::InitSkillTrigger()
{
	if (!SkillData.bActiveSkill)
	{
		if (SkillData.SkillTrigger)
		{
			USkillTrigger* SkillTrigger = NewObject<USkillTrigger>(this, SkillData.SkillTrigger);
			FSkillContext context;
			context.OwnerSkill = this;
			context.SkillManager = SkillManager;
			SkillTrigger->Init(context);
		}
		else
		{
			//UE_LOG(LogTemp, Warning, TEXT("没有Trigger的被动技能，直接触发"));
			ExecuteSkill();
		}
	}
}


bool USkill::SkillTickAble()
{
	//剩余次数无限制或者拥有者没有被韧性眩晕
	return (RemainingEndurance >0 || RemainingEndurance == -1  ) && Owner->CurrentTenacity > 0 && SkillData.bActiveSkill;
}

void USkill::TickSkill(float deltaTime)
{
	if (SkillTickAble())
		RemainingTime -= deltaTime * SkillData.Speed;
	if (RemainingTime <= 0 )
	{
		ExecuteSkill();
	}
	if (RemainingEndurance == 0)
	{
		FSkillContext context;
		context.OwnerSkill = this;
		context.SkillManager = SkillManager;
		for (auto Effect: SkillEffects)
		{
			Effect->EffectEnded(context);
		}
	}
}

void USkill::ExecuteSkill()
{
	RemainingTime = 0;
	if (RemainingEndurance >0)
		--RemainingEndurance;
	FSkillContext context;
	context.OwnerSkill = this;
	context.SkillManager = SkillManager;
	for (auto Effect: SkillEffects)
	{
		Effect->Execute(context);
	}
	RemainingTime = SkillData.CD;
	OnSkillExecute.Broadcast(SkillData.SkillName.ToString());
}

FString USkill::GetSkillName() const
{
	return SkillData.SkillName.ToString();;
}

FSkillData& USkill::GetSkillData()
{
	return SkillData;
}

FIntPoint USkill::GetBagPos()
{
	return BagPosition;
}

void USkill::SetSkillData(FSkillData data)
{
	SkillData = data;
	OnSkillUpdate.Broadcast();
}

void USkill::ApplyRemainingTimeOffset(int timeOffset)
{
	this->RemainingTime += timeOffset;
}

void USkill::ApplyRemainingRemainingEnduranceOffset(int Offset)
{
	if (SkillData.Endurance != -1)
		this->RemainingEndurance = FMath::Max(this->RemainingEndurance + Offset, SkillData.Endurance);
}

class APawnWithSkill* USkill::GetOwner()
{
	return Owner;
}