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


#include "SkillManager.h"
#include "Skill.h"
#include "ProjectFish/DataAsset/BagConfigAsset.h"

void USkillManager::Tick(float DeltaTime)
{
	for (auto Skill : Skills)
	{
		Skill->TickSkill(DeltaTime);
	}
}

bool USkillManager::IsTickable() const
{
	return !bGameEnd;
}

TStatId USkillManager::GetStatId() const
{
	return Super::GetStatID();
}

void USkillManager::AddPawn(class APawnWithSkill* Pawn, FIntPoint BagSize)
{
	PawnInfo.Add(Pawn, BagSize);
	TMap<FIntPoint, int32> states;
	for (int y = 0; y < BagSize.Y; y++)
	{
		for (int x = 0; x < BagSize.X; x++)
		{
			states.Add(FIntPoint(x, y), -1);
		
		}
	}
	PawnBagState.Add(Pawn, states);
}

void USkillManager::AddBagWithSkills(UBagConfigAsset* Bag, APawnWithSkill* Pawn, TArray<USkill*>& SkillObjects,
	TArray<FIntPoint>& BagPositions)
{
	FIntPoint BagSize = *PawnInfo.Find(Pawn);
	for (auto PlacedSkill: Bag->PlacedSkills)
	{
		USkill* skill = NewObject<USkill>(this);
		skill->InitSkill(Pawn, this, PlacedSkill);
		SkillObjects.Add(skill);
		BagPositions.Add(FIntPoint(PlacedSkill.PositionX, PlacedSkill.PositionY));
		Skills.Add(skill);
	}
	
	
}

void USkillManager::OnAllSkillAdded()
{
	//所有技能初始化后，初始化技能的触发器
	for (auto Skill : Skills)
	{
		Skill->InitSkillTrigger();
	}
}



int32 USkillManager::GetSkillIndex(USkill* Skill)
{
	return Skills.Find(Skill);
}

TArray<USkill*> USkillManager::GetSkillsAround(USkill* TargetSkill)
{
	TArray<USkill*> aroundSkills;
	TMap<FIntPoint, int32> *BagStates = PawnBagState.Find(TargetSkill->GetOwner());
	FIntPoint BagPos = TargetSkill->GetBagPos();
	FIntPoint BagSize = *PawnInfo.Find(TargetSkill->GetOwner());
	TObjectPtr<USkillAsset> data = TargetSkill->GetSkillData();
	int beginX = FMath::Max(0, BagPos.X- 1);
	int endX = FMath::Min(BagSize.X - 1, BagPos.X + 1);
	int beginY = FMath::Max(0, BagPos.Y - 1);
	int endY = FMath::Min(BagSize.Y - 1, BagPos.Y + 1);
	for (int x = beginX; x <= endX; x++)
	{
		for (int y = beginY; y <= endY; y++)
		{
			
			int32 skillIndex = *BagStates->Find(FIntPoint(x, y));
			if (skillIndex != -1 && skillIndex != GetSkillIndex(TargetSkill) && !aroundSkills.Contains(Skills[skillIndex]))
			{
				aroundSkills.Add(Skills[skillIndex]);
			}
		}
	}
	return aroundSkills;
}

void USkillManager::RemoveSkill(USkill* Skill)
{
	Skills.Remove(Skill);
}

TArray<APawnWithSkill*> USkillManager::GetAllPawns() 
{
	TArray<APawnWithSkill*> Pawns;
	for (auto info: PawnInfo)
	{
		Pawns.Add(info.Key);
	}
	return Pawns;
}

APawnWithSkill* USkillManager::GetEnemyPawn(const APawnWithSkill* SelfPawn)
{
	for (auto info: PawnInfo)
	{
		if (SelfPawn != info.Key)
			return info.Key;
	}
	return nullptr;
}

TArray<class USkill*> USkillManager::GetSkillsByOwner(APawnWithSkill* Pawn)
{
	TArray<class USkill*> skills;
	for (auto Skill : Skills)
	{
		if (Skill->GetOwner() == Pawn)
			skills.Add(Skill);
	}
	return skills;
}

TArray<class USkill*> USkillManager::GetSkillsByOwnerAndID(APawnWithSkill* Pawn, FGuid SkillID)
{
	TArray<class USkill*> skills;
	for (auto Skill : Skills)
	{
		if (Skill->GetOwner() == Pawn && Skill->GetSkillData()->SkillID == SkillID)
			skills.Add(Skill);
	}
	return skills;
}

TArray< USkill*> USkillManager::GetAllSkills()
{
	return Skills;
}

TArray<USkill*> USkillManager::GetSkillsByType(ESkillType SkillType) const
{
	TArray<USkill*> Result;
	for (USkill* Skill : Skills)
	{
		if (Skill && Skill->GetSkillData())
		{
			for (const ESkillType& Type : Skill->GetSkillData()->SkillTypes)
			{
				if (Type == SkillType)
				{
					Result.Add(Skill);
					break;
				}
			}
		}
	}
	return Result;
}