// Lot AP6 - voir LPAnimCatalogCommandlet.h

#include "LPAnimCatalogCommandlet.h"

#include "Animation/AnimData/IAnimationDataModel.h"
#include "Animation/AnimSequence.h"
#include "Dom/JsonObject.h"
#include "LPPoseMeasure.h"
#include "Misc/FileHelper.h"
#include "Misc/Paths.h"
#include "Serialization/JsonReader.h"
#include "Serialization/JsonSerializer.h"
#include "Serialization/JsonWriter.h"

DEFINE_LOG_CATEGORY_STATIC(LogLPAnimCatalog, Log, All);

namespace LPAnimCatalogImpl
{
	// Seuils de classement (definitions : voir l'en-tete).
	constexpr float LyingTilt = 60.f;       // degres
	constexpr float KneelHeight = 12.f;     // cm
	constexpr float LowHips = 0.72f;        // fraction de la hauteur de hanche debout (gardes de combat : debout)
	constexpr float SeatBehind = 20.f;      // cm
	constexpr float Majority = 0.6f;
	constexpr float FootContact = 3.f;      // cm
	constexpr float HandRest = 15.f;        // cm/s
	constexpr float HandRaised = 0.3f;

	int32 BoneOf(const FLPPose& Pose, const TCHAR* Role, int32 Index = 0)
	{
		const FName Name = LPPoseMeasure::RoleBone(Pose, Role, Index);
		return Name.IsNone() ? INDEX_NONE : Pose.Names.IndexOfByKey(Name);
	}

	FVector At(const FLPPose& Pose, int32 Bone)
	{
		return Pose.Component.IsValidIndex(Bone) ? Pose.Component[Bone].GetLocation() : FVector::ZeroVector;
	}

	FVector RestAt(const FLPPose& Pose, int32 Bone)
	{
		return Pose.Rest.IsValidIndex(Bone) ? Pose.Rest[Bone].GetLocation() : FVector::ZeroVector;
	}

	FVector Flat(FVector V)
	{
		V.Z = 0.f;
		return V;
	}

	struct FBones
	{
		int32 Hips, Head, ThighL, ThighR, CalfL, CalfR, FootL, FootR, ToeL, ToeR, HandL, HandR;
		bool Bind(const FLPPose& P)
		{
			Hips = BoneOf(P, TEXT("hips")); Head = BoneOf(P, TEXT("head"));
			ThighL = BoneOf(P, TEXT("thigh_l")); ThighR = BoneOf(P, TEXT("thigh_r"));
			CalfL = BoneOf(P, TEXT("calf_l")); CalfR = BoneOf(P, TEXT("calf_r"));
			FootL = BoneOf(P, TEXT("foot_l")); FootR = BoneOf(P, TEXT("foot_r"));
			ToeL = BoneOf(P, TEXT("toe_l")); ToeR = BoneOf(P, TEXT("toe_r"));
			HandL = BoneOf(P, TEXT("hand_l")); HandR = BoneOf(P, TEXT("hand_r"));
			const int32 All[] = { Hips, Head, ThighL, ThighR, CalfL, CalfR, FootL, FootR, ToeL, ToeR, HandL, HandR };
			for (const int32 B : All)
			{
				if (B == INDEX_NONE)
				{
					return false;
				}
			}
			return true;
		}
	};

	FVector ForwardOf(const FLPPose& P, const FBones& B)
	{
		// Haut x gauche = avant (verifie sur Roll, qui avance, et Sitting_Enter, dont le bassin recule).
		const FVector Side = Flat(At(P, B.ThighL) - At(P, B.ThighR));
		return FVector::CrossProduct(FVector::UpVector, Side.GetSafeNormal()).GetSafeNormal();
	}

	const TCHAR* PostureOf(const FLPPose& P, const FBones& B, float StandingHips, float Floor)
	{
		const FVector Trunk = At(P, B.Head) - At(P, B.Hips);
		const float Tilt = static_cast<float>(FMath::RadiansToDegrees(FMath::Acos(FMath::Clamp(Trunk.GetSafeNormal().Z, -1.0, 1.0))));
		if (Tilt > LyingTilt)
		{
			return TEXT("allonge");
		}
		const float Hips = static_cast<float>(At(P, B.Hips).Z) - Floor;
		if (Hips >= LowHips * StandingHips)
		{
			return TEXT("debout");
		}
		const float Knee = static_cast<float>(FMath::Min(At(P, B.CalfL).Z, At(P, B.CalfR).Z)) - Floor;
		if (Knee < KneelHeight)
		{
			return TEXT("a genoux");
		}
		const FVector Ankles = (At(P, B.FootL) + At(P, B.FootR)) * 0.5;
		const float Behind = static_cast<float>(FVector::DotProduct(Flat(Ankles - At(P, B.Hips)), ForwardOf(P, B)));
		return Behind > SeatBehind ? TEXT("assis") : TEXT("accroupi");
	}

	bool ReadJson(const FString& Path, TSharedPtr<FJsonValue>& Out)
	{
		FString Text;
		if (!FFileHelper::LoadFileToString(Text, *Path))
		{
			return false;
		}
		const TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Text);
		return FJsonSerializer::Deserialize(Reader, Out) && Out.IsValid();
	}

	struct FClipInfo
	{
		int32 Frames = 0;
		double Rate = 0.0;
		float Duration = 0.f;
	};

	bool ClipInfo(const FString& Path, FClipInfo& Out)
	{
		const UAnimSequence* Anim = LoadObject<UAnimSequence>(nullptr, *Path);
		const IAnimationDataModel* Model = Anim ? Anim->GetDataModel() : nullptr;
		if (!Model)
		{
			return false;
		}
		Out.Frames = Model->GetNumberOfKeys();
		Out.Rate = Model->GetFrameRate().AsDecimal();
		Out.Duration = static_cast<float>(Model->GetPlayLength());
		return Out.Frames > 0;
	}

	TSharedRef<FJsonObject> Measure(const FString& Path, const FClipInfo& Info, FString& Error)
	{
		TSharedRef<FJsonObject> Card = MakeShared<FJsonObject>();
		TArray<FLPPose> Poses;
		Poses.SetNum(Info.Frames);
		for (int32 Key = 0; Key < Info.Frames; ++Key)
		{
			const float Time = FMath::Min(static_cast<float>(Key / Info.Rate), Info.Duration);
			if (!LPPoseMeasure::Sample(Path, Time, Poses[Key]))
			{
				Error = FString::Printf(TEXT("echantillon impossible a %.3f s"), Time);
				return Card;
			}
		}
		FBones B;
		if (!B.Bind(Poses[0]))
		{
			Error = FString::Printf(TEXT("roles d'os manquants (profil %s)"), *Poses[0].Profile);
			return Card;
		}
		const FLPPose& First = Poses[0];
		const FLPPose& Last = Poses.Last();
		const float Floor = static_cast<float>(FMath::Min(RestAt(First, B.FootL).Z, RestAt(First, B.FootR).Z));
		const float StandingHips = static_cast<float>(RestAt(First, B.Hips).Z) - Floor;
		const float Height = FMath::Max(1.f, static_cast<float>(RestAt(First, B.Head).Z) - Floor);

		Card->SetNumberField(TEXT("images"), Info.Frames);
		Card->SetNumberField(TEXT("cadence"), FMath::RoundToFloat(static_cast<float>(Info.Rate) * 100.f) / 100.f);
		Card->SetNumberField(TEXT("duree_s"), FMath::RoundToFloat(Info.Duration * 100.f) / 100.f);

		// Boucle : extremites relatives a la hanche, premiere et derniere image.
		const int32 Ends[] = { B.HandL, B.HandR, B.FootL, B.FootR, B.Head };
		float LoopGap = 0.f;
		for (const int32 E : Ends)
		{
			const FVector A = At(First, E) - At(First, B.Hips);
			const FVector Z = At(Last, E) - At(Last, B.Hips);
			LoopGap = FMath::Max(LoopGap, static_cast<float>((A - Z).Size()));
		}
		const float LoopPct = 100.f * LoopGap / Height;
		Card->SetNumberField(TEXT("boucle_ecart_pct"), FMath::RoundToFloat(LoopPct * 100.f) / 100.f);

		// Deplacement horizontal de la hanche.
		const FVector Travel = Flat(At(Last, B.Hips) - At(First, B.Hips));
		const float Distance = static_cast<float>(Travel.Size());
		Card->SetNumberField(TEXT("deplacement_cm"), FMath::RoundToFloat(Distance));
		Card->SetNumberField(TEXT("vitesse_cm_s"), Info.Duration > 0.f ? FMath::RoundToFloat(Distance / Info.Duration) : 0.f);
		const float Ahead = Distance > 0.f ? static_cast<float>(FVector::DotProduct(Travel / Distance, ForwardOf(First, B))) : 0.f;
		Card->SetStringField(TEXT("deplacement_sens"), Ahead > 0.7f ? TEXT("avant") : Ahead < -0.7f ? TEXT("arriere") : TEXT("cote"));

		// Posture image par image.
		TMap<FString, int32> Count;
		TArray<float> SeatHeights;
		int32 FeetDown[2] = { 0, 0 };
		int32 Raised[2] = { 0, 0 };
		float HandPath[2] = { 0.f, 0.f };
		const float RestFoot[2] = { static_cast<float>(RestAt(First, B.FootL).Z), static_cast<float>(RestAt(First, B.FootR).Z) };
		const float RestToe[2] = { static_cast<float>(RestAt(First, B.ToeL).Z), static_cast<float>(RestAt(First, B.ToeR).Z) };
		for (int32 Key = 0; Key < Info.Frames; ++Key)
		{
			const FLPPose& P = Poses[Key];
			const FString Posture = PostureOf(P, B, StandingHips, Floor);
			++Count.FindOrAdd(Posture);
			if (Posture == TEXT("assis"))
			{
				SeatHeights.Add(static_cast<float>((At(P, B.ThighL).Z + At(P, B.ThighR).Z) * 0.5) - Floor);
			}
			const int32 Feet[2] = { B.FootL, B.FootR };
			const int32 Toes[2] = { B.ToeL, B.ToeR };
			const int32 Hands[2] = { B.HandL, B.HandR };
			for (int32 Side = 0; Side < 2; ++Side)
			{
				const float Lift = FMath::Min(static_cast<float>(At(P, Feet[Side]).Z) - RestFoot[Side],
					static_cast<float>(At(P, Toes[Side]).Z) - RestToe[Side]);
				FeetDown[Side] += Lift < FootContact ? 1 : 0;
				Raised[Side] += At(P, Hands[Side]).Z > At(P, B.Head).Z ? 1 : 0;
				if (Key > 0)
				{
					const FLPPose& Q = Poses[Key - 1];
					HandPath[Side] += static_cast<float>(((At(P, Hands[Side]) - At(P, B.Hips)) - (At(Q, Hands[Side]) - At(Q, B.Hips))).Size());
				}
			}
		}
		FString Main = TEXT("variable");
		for (const TPair<FString, int32>& It : Count)
		{
			if (It.Value >= Majority * Info.Frames)
			{
				Main = It.Key;
			}
		}
		Card->SetStringField(TEXT("posture"), Main);
		Card->SetStringField(TEXT("posture_debut"), PostureOf(First, B, StandingHips, Floor));
		Card->SetStringField(TEXT("posture_fin"), PostureOf(Last, B, StandingHips, Floor));
		TSharedRef<FJsonObject> Split = MakeShared<FJsonObject>();
		for (const TPair<FString, int32>& It : Count)
		{
			Split->SetNumberField(It.Key, FMath::RoundToFloat(100.f * It.Value / Info.Frames));
		}
		Card->SetObjectField(TEXT("posture_pct"), Split);
		if (SeatHeights.Num() > 0)
		{
			SeatHeights.Sort();
			Card->SetNumberField(TEXT("hauteur_assise_cm"), FMath::RoundToFloat(SeatHeights[SeatHeights.Num() / 2]));
		}
		else
		{
			Card->SetField(TEXT("hauteur_assise_cm"), MakeShared<FJsonValueNull>());
		}
		const TCHAR* SideNames[2] = { TEXT("gauche"), TEXT("droite") };
		TSharedRef<FJsonObject> Feet = MakeShared<FJsonObject>();
		TSharedRef<FJsonObject> Hands = MakeShared<FJsonObject>();
		for (int32 Side = 0; Side < 2; ++Side)
		{
			Feet->SetNumberField(SideNames[Side], FMath::RoundToFloat(100.f * FeetDown[Side] / Info.Frames));
			const float Speed = Info.Duration > 0.f ? HandPath[Side] / Info.Duration : 0.f;
			const TCHAR* State = Raised[Side] >= HandRaised * Info.Frames ? TEXT("levee") : Speed < HandRest ? TEXT("repos") : TEXT("mouvement");
			Hands->SetStringField(SideNames[Side], State);
		}
		Card->SetObjectField(TEXT("pieds_au_sol_pct"), Feet);
		Card->SetObjectField(TEXT("mains"), Hands);
		return Card;
	}
}

ULPAnimCatalogCommandlet::ULPAnimCatalogCommandlet()
{
	IsClient = false;
	IsServer = false;
	IsEditor = true;
	LogToConsole = true;
}

int32 ULPAnimCatalogCommandlet::Main(const FString& Params)
{
	using namespace LPAnimCatalogImpl;
	FString Livraison = FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("AnimPipeline/quaternius/livraison.json"));
	FParse::Value(*Params, TEXT("Livraison="), Livraison, false);
	FString Out = FPaths::GetPath(Livraison);
	FParse::Value(*Params, TEXT("Out="), Out, false);
	float SeuilBoucle = 1.f;
	float SeuilSurPlace = 5.f;
	FParse::Value(*Params, TEXT("SeuilBoucle="), SeuilBoucle);
	FParse::Value(*Params, TEXT("SeuilSurPlace="), SeuilSurPlace);

	TSharedPtr<FJsonValue> Root;
	if (!ReadJson(Livraison, Root) || Root->Type != EJson::Array)
	{
		UE_LOG(LogLPAnimCatalog, Error, TEXT("livraison.json illisible : %s"), *Livraison);
		return 1;
	}

	TSharedRef<FJsonObject> Cards = MakeShared<FJsonObject>();
	TArray<FString> Failures;
	for (const TSharedPtr<FJsonValue>& Entry : Root->AsArray())
	{
		const TSharedPtr<FJsonObject> Item = Entry->AsObject();
		const FString Key = Item->GetStringField(TEXT("cle"));
		const FString PathF = Item->GetStringField(TEXT("source_F"));
		const FString PathM = Item->GetStringField(TEXT("source_M"));
		FClipInfo F, M;
		if (!ClipInfo(PathF, F) || !ClipInfo(PathM, M))
		{
			Failures.Add(FString::Printf(TEXT("%s : clip absent ou vide"), *Key));
			continue;
		}
		if (F.Frames != M.Frames || !FMath::IsNearlyEqual(F.Duration, M.Duration, 0.001f))
		{
			Failures.Add(FString::Printf(TEXT("%s : F %d images %.3f s, M %d images %.3f s"), *Key, F.Frames, F.Duration, M.Frames, M.Duration));
		}
		FString Error;
		TSharedRef<FJsonObject> Card = Measure(PathF, F, Error);
		if (!Error.IsEmpty())
		{
			Failures.Add(FString::Printf(TEXT("%s : %s"), *Key, *Error));
			continue;
		}
		Card->SetBoolField(TEXT("boucle"), Card->GetNumberField(TEXT("boucle_ecart_pct")) <= SeuilBoucle);
		if (Card->GetNumberField(TEXT("deplacement_cm")) < SeuilSurPlace)
		{
			Card->SetStringField(TEXT("deplacement_sens"), TEXT("sur place"));
		}
		UE_LOG(LogLPAnimCatalog, Display, TEXT("%-28s %5.2f s %3d img  boucle %5.2f %%  depl %4.0f cm %-9s posture %-9s (%s -> %s)"),
			*Key, F.Duration, F.Frames, Card->GetNumberField(TEXT("boucle_ecart_pct")), Card->GetNumberField(TEXT("deplacement_cm")),
			*Card->GetStringField(TEXT("deplacement_sens")), *Card->GetStringField(TEXT("posture")),
			*Card->GetStringField(TEXT("posture_debut")), *Card->GetStringField(TEXT("posture_fin")));
		Cards->SetObjectField(Key, Card);
	}

	TSharedRef<FJsonObject> Report = MakeShared<FJsonObject>();
	Report->SetStringField(TEXT("livraison"), Livraison);
	Report->SetNumberField(TEXT("seuil_boucle_pct"), SeuilBoucle);
	Report->SetNumberField(TEXT("seuil_sur_place_cm"), SeuilSurPlace);
	Report->SetObjectField(TEXT("fiches"), Cards);
	TArray<TSharedPtr<FJsonValue>> Errors;
	for (const FString& Failure : Failures)
	{
		Errors.Add(MakeShared<FJsonValueString>(Failure));
		UE_LOG(LogLPAnimCatalog, Error, TEXT("%s"), *Failure);
	}
	Report->SetArrayField(TEXT("echecs"), Errors);
	const FString OutPath = FPaths::Combine(Out, TEXT("fiches_calculees.json"));
	FString Text;
	const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&Text);
	FJsonSerializer::Serialize(Report, Writer);
	if (!FFileHelper::SaveStringToFile(Text, *OutPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
	{
		UE_LOG(LogLPAnimCatalog, Error, TEXT("ecriture impossible : %s"), *OutPath);
		return 1;
	}
	UE_LOG(LogLPAnimCatalog, Warning, TEXT("CATALOGUE fiches %d echecs %d -> %s"), Cards->Values.Num(), Failures.Num(), *OutPath);
	return Failures.Num() > 0 ? 1 : 0;
}