#pragma once

#include "CoreMinimal.h"
#include "Debug/DescentScenario.h"
#include "Debug/DescentDebugSubsystem.h"
#include "Core/DescentFlyPawn.h"
#include "World/DescentTerrainSubsystem.h"
#include "DescentUnits.h"
#include "TheDescent.h"

#include "AssetCompilingManager.h"
#include "RHIStats.h"
#include "RenderTimer.h"
#include "ShaderCompiler.h"
#include "Camera/PlayerCameraManager.h"
#include "Engine/StaticMeshActor.h"
#include "Components/StaticMeshComponent.h"
#include "Engine/StaticMesh.h"
#include "Materials/MaterialInstanceDynamic.h"
#include "Engine/World.h"
#include "EngineUtils.h"
#include "GameFramework/PlayerController.h"

/**
 * Scenario steps of the world / look track, written on top of the builder's `Do` and `Until` (DescentScenario.h is
 * not edited): possess a fly pawn explicitly (the real player replaces the fly pawn as the default pawn in M2), place
 * the view with the pawn so its headlamp goes along, and wait until the terrain has finished streaming.
 */
namespace DescentWorldScn
{
	/** Makes sure the first player controller possesses an ADescentFlyPawn and views through it. */
	inline ADescentFlyPawn* EnsureFlyPawn(UWorld* World)
	{
		APlayerController* PC = World ? World->GetFirstPlayerController() : nullptr;
		if (!PC) { return nullptr; }
		ADescentFlyPawn* Fly = Cast<ADescentFlyPawn>(PC->GetPawn());
		if (!Fly)
		{
			for (TActorIterator<ADescentFlyPawn> It(World); It; ++It) { Fly = *It; break; }
			if (!Fly)
			{
				const FVector Where = PC->GetPawn() ? PC->GetPawn()->GetActorLocation() : FVector::ZeroVector;
				FActorSpawnParameters Params;
				Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
				Fly = World->SpawnActor<ADescentFlyPawn>(Where, FRotator::ZeroRotator, Params);
			}
			if (Fly)
			{
				if (PC->GetPawn() && PC->GetPawn() != Fly) { PC->UnPossess(); }
				PC->Possess(Fly);
			}
		}
		if (Fly) { PC->SetViewTarget(Fly); }
		return Fly;
	}

	/** Puts the fly pawn at LocM looking at LookM (metres) and asks the terrain to stream around it. */
	inline bool PlaceView(UWorld* World, const FVector& LocM, const FVector& LookM, float FovDeg = 70.f)
	{
		ADescentFlyPawn* Fly = EnsureFlyPawn(World);
		APlayerController* PC = World ? World->GetFirstPlayerController() : nullptr;
		if (!Fly || !PC) { return false; }
		Fly->SetActorLocation(Descent::MetresToUU(LocM), false, nullptr, ETeleportType::TeleportPhysics);
		PC->SetControlRotation((LookM - LocM).Rotation());
		Fly->SetActorRotation((LookM - LocM).Rotation());
		if (PC->PlayerCameraManager) { PC->PlayerCameraManager->SetFOV(FovDeg); }
		if (UDescentTerrainSubsystem* T = UDescentTerrainSubsystem::Get(World)) { T->RequestReplan(); }
		return true;
	}

	/** Possess a fly pawn: the first step of every scenario of this track. */
	inline void StartWithFlyPawn(FDescentScenarioBuilder& S)
	{
		S.Do(TEXT("possess a fly pawn"), [](FDescentScenarioContext& C)
		{
			if (!EnsureFlyPawn(C.World)) { C.Fail(TEXT("could not possess a fly pawn")); }
		});
	}

	/** Moves the view to Loc looking at Look, then waits for the terrain. */
	inline void ViewAt(FDescentScenarioBuilder& S, const FString& Label, const FVector& LocM, const FVector& LookM, float FovDeg = 70.f)
	{
		S.Do(FString::Printf(TEXT("view %s"), *Label), [LocM, LookM, FovDeg](FDescentScenarioContext& C)
		{
			if (!PlaceView(C.World, LocM, LookM, FovDeg)) { C.Fail(TEXT("no pawn to place")); }
		});
	}

	/** Waits (wall clock, up to MaxSeconds) until no terrain job is running or queued and everything near the view is meshed. */
	inline void WaitStreamIdle(FDescentScenarioBuilder& S, float MaxSeconds = 120.f)
	{
		S.Do(TEXT("replan the stream"), [](FDescentScenarioContext& C)
		{
			if (UDescentTerrainSubsystem* T = UDescentTerrainSubsystem::Get(C.World)) { T->RequestReplan(); }
		});
		S.Until(TEXT("wait for the terrain stream to go idle"), [MaxSeconds](FDescentScenarioContext& C)
		{
			UDescentTerrainSubsystem* T = UDescentTerrainSubsystem::Get(C.World);
			if (!T) { C.Fail(TEXT("no terrain subsystem")); return true; }
			if (C.FramesInStep() > 3 && T->IsStreamIdle()) { return true; }
			if (C.SecondsInStep() > MaxSeconds)
			{
				C.Fail(FString::Printf(TEXT("the terrain stream did not go idle in %.0f s (pending jobs %d)"), MaxSeconds, T->GetStats().PendingJobs));
				return true;
			}
			return false;
		});
	}

	/** Reads a number from the state dump: Section.Field. */
	inline double SnapNumber(const FDescentScenarioContext& C, const TCHAR* Section, const TCHAR* Field)
	{
		const TSharedRef<FJsonObject> Snap = C.Snapshot();
		const TSharedPtr<FJsonObject>* Sec = nullptr;
		double V = -1.0;
		if (Snap->TryGetObjectField(Section, Sec) && Sec) { (*Sec)->TryGetNumberField(Field, V); }
		return V;
	}

	/**
	 * A screenshot like S.Shot but it does NOT fail on a black frame: the look tests of a dark scene (lamp off, deep) are
	 * supposed to be nearly black. Writes Saved/Shots/<scenario>_<Label>.png and .json and sets C.LastShotStats.
	 */
	inline void ShotAllowDark(FDescentScenarioBuilder& S, const FString& Label, int32 WarmupFrames = 10, float WarmupSeconds = 0.75f)
	{
		struct FSt { int32 Phase = 0; int64 QuietFrame = -1; double QuietTime = 0.0; bool bDone = false; FDescentShotResult R; };
		TSharedRef<FSt> St = MakeShared<FSt>();
		S.Until(FString::Printf(TEXT("ShotAllowDark(%s)"), *Label), [St, Label, WarmupFrames, WarmupSeconds](FDescentScenarioContext& C)
		{
			if (St->Phase == 0)
			{
				const bool bBusy = FAssetCompilingManager::Get().GetNumRemainingAssets() > 0 || (GShaderCompilingManager && GShaderCompilingManager->IsCompiling());
				if (bBusy) { St->QuietFrame = -1; return false; }
				if (St->QuietFrame < 0) { St->QuietFrame = static_cast<int64>(GFrameCounter); St->QuietTime = FPlatformTime::Seconds(); }
				if (static_cast<int64>(GFrameCounter) - St->QuietFrame < WarmupFrames || FPlatformTime::Seconds() - St->QuietTime < WarmupSeconds) { return false; }
				const FString Stem = C.ScenarioName + TEXT("_") + Label;
				TSharedRef<FSt> Cap = St;
				if (!C.Debug || !C.Debug->RequestShot(Stem, [Cap](const FDescentShotResult& R) { Cap->R = R; Cap->bDone = true; }))
				{
					if (!St->bDone) { C.Fail(TEXT("screenshot request was refused")); return true; }
				}
				St->Phase = 1;
				return false;
			}
			if (!St->bDone) { return false; }
			if (!St->R.bOk) { C.Fail(FString::Printf(TEXT("Shot(%s) failed: %s"), *Label, *St->R.Error)); return true; }
			C.LastShotStats = St->R.Stats;
			UE_LOG(LogDescent, Display, TEXT("Shot(%s): mean luma %.4f centre %.4f p99 %.4f non-black %.1f%%"), *Label, St->R.Stats.MeanLuma, St->R.Stats.CentreLuma, St->R.Stats.P99Luma, St->R.Stats.NonBlack * 100.0);
			return true;
		});
	}

	/** A flat lit square (Plane, SizeM on a side) facing +Normal at Centre; BaseColor is the linear albedo. Used by the calibration. */
	inline AStaticMeshActor* SpawnTestSquare(UWorld* World, const FVector& CentreM, const FRotator& Rot, double SizeM, const FLinearColor& BaseColor, double EmissiveStrength = 0.0, double AmbientMix = 0.0)
	{
		FActorSpawnParameters P;
		P.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
		AStaticMeshActor* A = World->SpawnActor<AStaticMeshActor>(Descent::MetresToUU(CentreM), Rot, P);
		if (!A) { return nullptr; }
		UStaticMeshComponent* M = A->GetStaticMeshComponent();
		M->SetMobility(EComponentMobility::Movable);
		M->SetStaticMesh(LoadObject<UStaticMesh>(nullptr, TEXT("/Engine/BasicShapes/Plane.Plane")));
		M->SetCollisionEnabled(ECollisionEnabled::NoCollision);
		M->SetWorldScale3D(FVector(SizeM, SizeM, 1.0));   // the basic plane is 1 m on a side
		M->SetCastShadow(false);
		if (UMaterialInterface* Parent = LoadObject<UMaterialInterface>(nullptr, TEXT("/Game/Materials/M_DescentSurface.M_DescentSurface")))
		{
			UMaterialInstanceDynamic* MID = UMaterialInstanceDynamic::Create(Parent, A);
			MID->SetVectorParameterValue(TEXT("BaseColor"), BaseColor);
			MID->SetScalarParameterValue(TEXT("Roughness"), 1.0f);
			MID->SetScalarParameterValue(TEXT("Metallic"), 0.0f);
			MID->SetScalarParameterValue(TEXT("AmbientMix"), static_cast<float>(AmbientMix));
			MID->SetVectorParameterValue(TEXT("EmissiveColor"), FLinearColor::White);
			MID->SetScalarParameterValue(TEXT("EmissiveStrength"), static_cast<float>(EmissiveStrength));
			M->SetMaterial(0, MID);
		}
		return A;
	}

	/**
	 * Measures the real cost of the frame for N frames (wall clock; the fixed time step does not hide it) and logs one PERF line:
	 * frame ms, game-thread ms, render-thread ms, draw calls, triangles drawn (RHI), terrain chunks and triangles.
	 */
	inline void MeasureFrames(FDescentScenarioBuilder& S, const FString& Label, int32 Frames = 90)
	{
		struct FSt { double T0 = 0.0; double Game = 0.0; double Render = 0.0; int32 N = 0; bool bStarted = false; };
		TSharedRef<FSt> St = MakeShared<FSt>();
		S.Until(FString::Printf(TEXT("measure %s"), *Label), [St, Label, Frames](FDescentScenarioContext& C)
		{
			if (!St->bStarted) { St->bStarted = true; St->T0 = FPlatformTime::Seconds(); return false; }
			St->Game += FPlatformTime::ToMilliseconds(GGameThreadTime);
			St->Render += FPlatformTime::ToMilliseconds(GRenderThreadTime);
			if (++St->N < Frames) { return false; }
			const double FrameMs = (FPlatformTime::Seconds() - St->T0) * 1000.0 / St->N;
			const UDescentTerrainSubsystem::FStats TS = UDescentTerrainSubsystem::Get(C.World)->GetStats();
			UE_LOG(LogDescent, Display, TEXT("PERF %s: frame %.2f ms, game thread %.2f ms, render thread %.2f ms, draw calls %d, RHI triangles %d, chunks meshed %d, terrain triangles %d, components %d"),
				*Label, FrameMs, St->Game / St->N, St->Render / St->N, GNumDrawCallsRHI[0], GNumPrimitivesDrawnRHI[0], TS.ChunksMeshed, TS.Triangles, TS.ComponentsActive);
			return true;
		});
	}
}