#pragma once

#include "CoreMinimal.h"
#include "Containers/Ticker.h"
#include "Dom/JsonObject.h"
#include "Debug/DescentImageStats.h"

class AActor;
class UWorld;
class UDescentDebugSubsystem;
class UDescentSimSubsystem;

/**
 * Scenarios: scripted, unattended runs of the game. `UnrealEditor.exe ... -game -DescentScenario=<name>`
 * (see Tools/run_scenario.ps1) finds the scenario registered under <name>, walks its steps one frame at a
 * time, and exits the process when it is done.
 *
 * Adding one takes a few lines, in any .cpp of the module:
 *
 *   DESCENT_SCENARIO(my_scenario, "What this checks, in a sentence.")
 *   {
 *       S.TimeLimit(60.f);
 *       S.Do(TEXT("spawn"), [](FDescentScenarioContext& C) { C.World->SpawnActor<AMyThing>(); });
 *       S.LookAt(FVector(8, 6, 3), FVector(0, 0, 0.5f));      // camera position and target, in metres
 *       S.Shot(TEXT("overview"));                              // Saved/Shots/my_scenario_overview.png
 *       S.DumpState(TEXT("end"));                              // Saved/State/my_scenario_end.json
 *       S.Quit();
 *   }
 *
 * Time: WaitSeconds is wall-clock; WaitSim waits on the SIM clock (UDescentSimSubsystem::SimTime), which
 * run_scenario.ps1 makes independent of the machine by running the game at a fixed 30 FPS step. FastForward runs
 * the sim without rendering. Expect / ExpectNear assert, and name the label and the numbers in the log when they fail.
 *
 * A scenario that runs past its time limit, hits a failing step (Ctx.Fail), or takes a black frame logs an
 * error and ends the process with a non-zero exit code. A scenario that reaches Quit() ends with 0.
 * Either way the log gets one line starting with DESCENT_SCENARIO_RESULT, which the scripts look for.
 */

/** What a step sees. Steps are called once per frame until they return true. */
class THEDESCENT_API FDescentScenarioContext
{
public:
	UWorld* World = nullptr;
	UDescentDebugSubsystem* Debug = nullptr;
	FString ScenarioName;
	FIntPoint RequestedResolution = FIntPoint(1280, 720);

	/** Frames and seconds since the current step was first called. */
	int64 FramesInStep() const { return static_cast<int64>(GFrameCounter) - StepEnterFrame; }
	double SecondsInStep() const { return FPlatformTime::Seconds() - StepEnterTime; }
	double SecondsInScenario() const { return FPlatformTime::Seconds() - ScenarioStartTime; }

	/** Actors a scenario wants to find again in a later step. */
	void SetNamed(FName Key, AActor* Actor);
	AActor* GetNamed(FName Key) const;

	/** Fails the scenario: logs the reason as an error and ends the run with a non-zero exit code. */
	void Fail(const FString& Reason);
	bool HasFailed() const { return bFailed; }

	/** Statistics of the most recent Shot() of this scenario (all zeros before the first), for Expect on brightness. */
	FDescentLumaStats LastShotStats;

	/** The world's sim (null before the world exists). */
	UDescentSimSubsystem* Sim() const;

	/** The state dump as an object right now (what Descent.DumpState would write), for asserting on `Snapshot()->GetObjectField("sim")`. */
	TSharedRef<FJsonObject> Snapshot() const;

	/** Asks the runner to end the process after this step. 0 is a pass. */
	void RequestQuit(int32 ExitCode) { bQuitRequested = true; QuitCode = ExitCode; }

	// Bookkeeping owned by the runner.
	int64 StepEnterFrame = 0;
	double StepEnterTime = 0.0;
	double ScenarioStartTime = 0.0;

private:
	friend class FDescentScenarioRunner;
	TMap<FName, TWeakObjectPtr<AActor>> Named;
	bool bFailed = false;
	FString FailReason;
	bool bQuitRequested = false;
	int32 QuitCode = 0;
};

/** Returns true when the step is finished. Called every frame until it does. */
using FDescentStepFn = TFunction<bool(FDescentScenarioContext&)>;

struct FDescentScenarioStep
{
	FString Label;
	FDescentStepFn Run;
};

/** Collects steps. The methods chain. All positions are metres, all angles degrees. */
class THEDESCENT_API FDescentScenarioBuilder
{
public:
	/** Wall-clock limit for the whole scenario, counted from its first step. Default 180 s. */
	FDescentScenarioBuilder& TimeLimit(float Seconds);

	/** Runs a function once, then moves on to the next step. */
	FDescentScenarioBuilder& Do(const FString& Label, TFunction<void(FDescentScenarioContext&)> Fn);

	/** Runs a function every frame until it returns true. */
	FDescentScenarioBuilder& Until(const FString& Label, FDescentStepFn Fn);

	FDescentScenarioBuilder& WaitFrames(int32 Frames);
	/** Wall-clock seconds. */
	FDescentScenarioBuilder& WaitSeconds(float Seconds);
	/** Sim seconds: waits until UDescentSimSubsystem::SimTime() has advanced by Seconds since this step began. */
	FDescentScenarioBuilder& WaitSim(double Seconds);

	/** Runs the sim for Seconds in one frame (UDescentSimSubsystem::FastForward): no rendering, no character movement. */
	FDescentScenarioBuilder& FastForward(double Seconds, double Dt = 1.0 / 30.0);

	/** Fails the scenario, naming Label, when the function returns false. */
	FDescentScenarioBuilder& Expect(const FString& Label, TFunction<bool(FDescentScenarioContext&)> Fn);

	/** Fails the scenario, naming Label and the numbers, unless |value - expected| <= tolerance. */
	FDescentScenarioBuilder& ExpectNear(const FString& Label, TFunction<double(FDescentScenarioContext&)> ValueFn, double Expected, double Tolerance);
	FDescentScenarioBuilder& ExpectNear(const FString& Label, double Value, double Expected, double Tolerance);

	/** Runs a console command (anything typed into the ~ console). */
	FDescentScenarioBuilder& Exec(const FString& Command);

	/** Puts the scenario camera at a position/rotation and makes it the view. */
	FDescentScenarioBuilder& Camera(const FVector& LocationM, const FRotator& Rotation, float FovDeg = 60.f);

	/** Same, but aimed at a target point. */
	FDescentScenarioBuilder& LookAt(const FVector& LocationM, const FVector& TargetM, float FovDeg = 60.f);

	/**
	 * Waits until shaders and async assets have finished compiling, then at least WarmupFrames frames and
	 * WarmupSeconds seconds, then captures the viewport to Saved/Shots/<scenario>_<Label>.png at the
	 * requested resolution. Fails the scenario if the PNG has the wrong size or is entirely black.
	 */
	FDescentScenarioBuilder& Shot(const FString& Label, int32 WarmupFrames = 10, float WarmupSeconds = 0.75f);

	/** Writes Saved/State/<scenario>_<Label>.json from every registered state provider. */
	FDescentScenarioBuilder& DumpState(const FString& Label);

	/** Ends the process. ExitCode 0 is a pass. */
	FDescentScenarioBuilder& Quit(int32 ExitCode = 0);

	TArray<FDescentScenarioStep> Steps;
	float TimeLimitSeconds = 180.f;
};

/** Registered by DESCENT_SCENARIO. */
class THEDESCENT_API FDescentScenarioRegistry
{
public:
	using FBuildFn = void (*)(FDescentScenarioBuilder&);
	struct FEntry
	{
		FString Name;
		FString Description;
		FBuildFn Build = nullptr;
	};

	static FDescentScenarioRegistry& Get();
	void Register(const TCHAR* Name, const TCHAR* Description, FBuildFn Build);
	const FEntry* Find(const FString& Name) const;
	TArray<FString> GetNames() const;

private:
	TMap<FString, FEntry> Entries;
};

struct THEDESCENT_API FDescentScenarioRegistrar
{
	FDescentScenarioRegistrar(const TCHAR* Name, const TCHAR* Description, FDescentScenarioRegistry::FBuildFn Build)
	{
		FDescentScenarioRegistry::Get().Register(Name, Description, Build);
	}
};

#define DESCENT_SCENARIO(Name, Description) \
	static void DescentScenarioBuild_##Name(FDescentScenarioBuilder& S); \
	static FDescentScenarioRegistrar DescentScenarioRegistrar_##Name(TEXT(#Name), TEXT(Description), &DescentScenarioBuild_##Name); \
	static void DescentScenarioBuild_##Name(FDescentScenarioBuilder& S)

/** Drives one scenario from a core ticker. Owned by UDescentDebugSubsystem. */
class THEDESCENT_API FDescentScenarioRunner
{
public:
	FDescentScenarioRunner(UDescentDebugSubsystem* InOwner, const FString& InName, FDescentScenarioBuilder&& InBuilder);
	~FDescentScenarioRunner();

	void Start();
	bool IsFinished() const { return bFinished; }

	/** Fails the running scenario from outside a step (a console command that failed, for instance). The run ends at the next frame. */
	void FailRun(const FString& Reason);

private:
	bool Tick(float DeltaTime);
	void Finish(int32 ExitCode, const FString& Reason);

	UDescentDebugSubsystem* Owner;
	FString Name;
	FDescentScenarioBuilder Builder;
	FDescentScenarioContext Context;
	FTSTicker::FDelegateHandle TickHandle;
	int32 StepIndex = 0;
	bool bStepEntered = false;
	bool bStarted = false;
	bool bFinished = false;
	double WaitStartTime = 0.0;
};