ASpawnpointParent::ASpawnpointParent()
{
 	// 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;

	// Collision for detecting when the player's center of the screen is hovering over a spawnpoint.
	rayCastCollision = CreateDefaultSubobject<USphereComponent>(TEXT("RaycastCollision"));
	rayCastCollision->OnComponentHit.AddDynamic(this, &ASpawnpointParent::OnHit);

	// Sets the raycast collision as the root component
	RootComponent = rayCastCollision;

	// Collision for the player. To avoid the player getting too close and being awkardly on top of the spawnpoint
	playerCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("PlayerCollision"));
	playerCollision->SetupAttachment(rayCastCollision);

	// Static mesh
	mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BushMesh"));
	mesh->SetupAttachment(rayCastCollision);

	// Arrow component for the direction of the leaf/dirt burst.
	arrowcomponent = CreateDefaultSubobject<UArrowComponent>(TEXT("ArrowComponent"));
	arrowcomponent->SetupAttachment(mesh);

	// Spring arm component for where the fuzzy should spawn.
	springArmComponent = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComponent"));
	springArmComponent->SetupAttachment(mesh);

	// Default containsFuzzy should be false
	containsFuzzy = false;
	
	static ConstructorHelpers::FClassFinder<AFuzzy> FuzzyBlueprint(TEXT("/Game/Blueprints/MyFuzzy"));
	if (FuzzyBlueprint.Succeeded())
	{
		fuzzyBP = FuzzyBlueprint.Class;
	}
	
}

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

	// Setting the color for the main mesh/the color of the leaf/dirt burst
	if (dmiMat)
	{
		dmiMat->SetVectorParameterValue("SpawnpointColor", meshColor);

	}
	// Create outline material
	overlayMatInstance = UMaterialInstanceDynamic::Create(overlayMat, this);
	mesh->SetOverlayMaterial(overlayMatInstance);

	// Setting the color for the outline
	if(overlayMatInstance)
	{
		overlayMatInstance->SetVectorParameterValue("Color", offColor);
	}
	// Getting the value of the arrow rotation for later use
	arrowRotation = arrowcomponent->GetComponentRotation();
}

void ASpawnpointParent::SetMeshColor()
{
		
	meshColor = GetRandColor();

	// Create mesh material
	dmiMat = UMaterialInstanceDynamic::Create(bushMat, this);
	mesh->SetMaterial(0, dmiMat);
}


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

	// check current # of fuzzies prepared
	// when you capture one, lower the number
	// if num < max
	// PlaceFuzzies

}

void ASpawnpointParent::FuzzyPrepared()
// For when a fuzzy is hiding in the object but hasn't been spawned yet.
{
	// Enable Sound
	// https://forums.unrealengine.com/t/how-to-get-a-random-number-in-range-c/721860/3
	if (GetWorld()->GetTimerManager().IsTimerActive(TimerHandle))
	{
		GetWorld()->GetTimerManager().UnPauseTimer(TimerHandle);
	}
	else
	{
		GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &ASpawnpointParent::PlaySound, FMath::RandRange(soundTimeMin, soundTimeMax), true);

	}


}

void ASpawnpointParent::ContainsFuzzy()
// CAUTION. NOT used to return whether a spawnpoint contains a Fuzzy. This is used to CHANGE THE VALUE CONTAINS FUZZY = TRUE/FALSE;
{
	if (!containsFuzzy)
	{
		containsFuzzy = true;
		FuzzyPrepared();
	}
}

FLinearColor ASpawnpointParent::GetRandColor()
// Must be overridden by child class. Cyan is default color.
{

	FColor tempColor = FColor::Cyan;
	return tempColor;
}

bool ASpawnpointParent::DoesContainFuzzy()
{
	if (containsFuzzy)
	{
		return true;
	}
	else if (!containsFuzzy)
	{
		return false;
	}
	else
	{
		return false;
	}
}

void ASpawnpointParent::PlaySound()
{
	if (!playing)
	{
		// Pick a random Fuzzy sound from the list
		// Plays Fuzzy Sound at the location of the root component (raycastcollision)
		
		playing = true;
		int index = FMath::RandRange(0, (fuzzySounds.Num()) - 1);
		if (fuzzySounds.IsValidIndex(index))
		{
			UGameplayStatics::PlaySoundAtLocation(this, fuzzySounds[index], GetActorLocation());
		}
		else
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Invalid index in FuzzySounds!!"));

		}
	}
	else
	{
		LeavesBurst(arrowRotation, true);
		playing = false;
	}
}

void ASpawnpointParent::LeavesBurst(FRotator rotation, bool spawnSound)
{
	UNiagaraComponent* particleComp = UNiagaraFunctionLibrary::SpawnSystemAttached(particleBurst, arrowcomponent, NAME_None, FVector(0.f, 0.f, 0.f), rotation, EAttachLocation::KeepRelativeOffset, true);
	if (particleComp) {
		particleComp->SetNiagaraVariableLinearColor(FString("ParticleColor"), meshColor);
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("particle spawned"));

		// Set a new random time
		int index = FMath::RandRange(0, (rustleSounds.Num()) - 1);
		if (rustleSounds.IsValidIndex(index) && spawnSound) 
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Playing leaves sounds"));
			UGameplayStatics::PlaySoundAtLocation(this, rustleSounds[index], GetActorLocation());
		}
		else
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Invalid index in LeavesSounds!!"));
		}
	}
}

void ASpawnpointParent::OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
{
	FHitResult hit;
	FCollisionQueryParams CollisionParams;
	CollisionParams.AddIgnoredActor(this);

	if (Hit.bBlockingHit && IsValid(Hit.GetActor()))
	{
		UInteract_I* Interface = Cast<UInteract_I>(Hit.GetActor());
	}
}

// Returns the arrowcomponent's location in world space.
FVector ASpawnpointParent::GetArrowComponentLocation()
{
	if (arrowcomponent)
	{
		FVector location = this->arrowcomponent->GetComponentLocation();
		return location;
	}
	else
	{
		return FVector(99.f, 99.f, 99.f);
	}
}

void ASpawnpointParent::EnableOutline()
{

	if (overlayMatInstance)
	{
		overlayMatInstance->SetScalarParameterValue("Line Thickness", 2.f);
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("overlayMatInstance null"));

	}
}

void ASpawnpointParent::DisableOutline()
{
	if (overlayMatInstance)
	{
		overlayMatInstance->SetScalarParameterValue("Line Thickness", 0.f);
	}
}

void ASpawnpointParent::SpawnFuzzy()
{
	FVector spawnpointLoc = springArmComponent->GetComponentLocation();
	//spawnpointLoc = FVector(spawnpointLoc.X, spawnpointLoc.Y, spawnpointLoc.Z + 300.f);
	FActorSpawnParameters spawnParameters;
	AFuzzy* fuzzy = GetWorld()->SpawnActor<AFuzzy>(fuzzyBP, spawnpointLoc, FRotator::ZeroRotator, spawnParameters);
	if (fuzzy)
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, "Fuzzy spawned");
		containsFuzzy = false;
		GetWorld()->GetTimerManager().PauseTimer(TimerHandle);
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, "Fuzzy NOT spawned!");

	}
}

class UStaticMesh* ASpawnpointParent::GetMeshComponent()
{
	return mesh->GetStaticMesh();
	
}