// Lot U7 (U7-T7) - voir LPModGuard.h
//
// API moteur lues dans UE 5.8.3 (Engine/Source) : montage des plugins PluginManager.cpp:1965-1979 et :2015-2018 ;
// UnmountExplicitlyLoadedPlugin (reserve aux plugins ExplicitlyLoaded) :3650-3739 ; FPackageName::UnRegisterMountPoint
// PackageName.h:347, PackageName.cpp:426-462 ; purge du registre AssetRegistry.cpp:9241-9327 ; FPakPlatformFile::Unmount
// IPlatformFilePak.cpp:6288-6356, delegue OnUnmountPak CoreDelegates.h:128, IPlatformFilePak.cpp:5808.

#include "LPModGuard.h"

#include "AssetRegistry/AssetData.h"
#include "AssetRegistry/IAssetRegistry.h"
#include "CoreGlobals.h"
#include "HAL/Event.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformFileManager.h"
#include "HAL/PlatformProperties.h"
#include "Interfaces/IPluginManager.h"
#include "IO/IoChunkId.h"
#include "IO/IoContainerHeader.h"
#include "IO/IoContainerId.h"
#include "IO/IoDispatcher.h"
#include "LifePlay.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/CoreDelegates.h"
#include "Misc/EngineVersion.h"
#include "Misc/FileHelper.h"
#include "Misc/PackageName.h"
#include "Misc/Paths.h"

// A relever au prochain changement de moteur (premiere version du jeu cuite par ce moteur).
const TCHAR* const FLPModGuard::MinGameVersion = TEXT("2026.10.2.0");

namespace LPModGuardImpl
{
	constexpr int32 NumChecks = static_cast<int32>(ELPModCheck::Num);
	const TCHAR* const SettingsSection = TEXT("/Script/LifePlay.LPModInfoSubsystem");
	const TCHAR* const CheckKeys[NumChecks] = { TEXT("bCheckModEngine"), TEXT("bCheckModMinVersion"), TEXT("bCheckModMaxVersion") };
	const TCHAR* const CheckNames[NumChecks] = { TEXT("moteur"), TEXT("version min"), TEXT("version max") };

	bool GRan = false;
	bool GActive[NumChecks] = { true, true, true };
	FString GGameVersion;
	TArray<FLPModVerdict> GVerdicts;

	struct FFailure
	{
		ELPModCheck Check = ELPModCheck::Engine;
		FString En;
		FString Fr;
	};

	/** "2026.10.2.0" -> {2026, 10, 2, 0} ; faux si une composante n'est pas un entier (comparaison numerique, pas lexicale).
	 *  Lot REL-ALPHA (decision de l'utilisateur "Lettre acceptee", 2026-10-14) : la derniere composante peut finir par des
	 *  lettres ASCII a-z / A-Z, retirees avant les controles et ignorees a la comparaison : "2026.10.2.1a" -> {2026, 10, 2, 1}. */
	bool ParseVersion(const FString& Text, TArray<int64>& Out)
	{
		Out.Reset();
		TArray<FString> Parts;
		Text.TrimStartAndEnd().ParseIntoArray(Parts, TEXT("."), false);
		// Lettres de fin de la derniere composante seulement, par plages explicites (aucune lettre non ASCII retiree).
		if (Parts.Num() > 0)
		{
			FString& LastPart = Parts.Last();
			int32 Keep = LastPart.Len();
			while (Keep > 0)
			{
				const TCHAR C = LastPart[Keep - 1];
				if (!((C >= TEXT('a') && C <= TEXT('z')) || (C >= TEXT('A') && C <= TEXT('Z'))))
				{
					break;
				}
				--Keep;
			}
			LastPart.LeftInline(Keep);
		}
		for (const FString& Part : Parts)
		{
			if (Part.IsEmpty() || Part.Len() > 9)
			{
				return false;
			}
			for (const TCHAR C : Part)
			{
				if (!FChar::IsDigit(C))
				{
					return false;
				}
			}
			Out.Add(FCString::Atoi64(*Part));
		}
		return Out.Num() > 0;
	}

	/** <0, 0, >0 ; une composante absente vaut 0 (2026.10.4 == 2026.10.4.0). */
	int32 CompareVersions(const TArray<int64>& A, const TArray<int64>& B)
	{
		const int32 Count = FMath::Max(A.Num(), B.Num());
		for (int32 Index = 0; Index < Count; ++Index)
		{
			const int64 Left = A.IsValidIndex(Index) ? A[Index] : 0;
			const int64 Right = B.IsValidIndex(Index) ? B[Index] : 0;
			if (Left != Right)
			{
				return Left < Right ? -1 : 1;
			}
		}
		return 0;
	}

	bool ReadCheck(int32 Index)
	{
		bool bValue = true;
		if (GConfig)
		{
			GConfig->GetBool(SettingsSection, CheckKeys[Index], bValue, GGameUserSettingsIni);
		}
		return bValue;
	}

	/** Paks du plugin : meme recherche que FPluginManager au montage (PluginManager.cpp:1965-1979), donc les memes
	 *  chaines que celles passees a FCoreDelegates::MountPak (FPakPlatformFile::Unmount compare le nom exact). */
	TArray<FString> FindPluginPaks(const IPlugin& Plugin)
	{
		TArray<FString> Paks;
		const FString Dir = Plugin.GetContentDir() / TEXT("Paks") / FString(FPlatformProperties::PlatformName());
		FPlatformFileManager::Get().GetPlatformFile().IterateDirectoryRecursively(*Dir, [&Paks](const TCHAR* Name, bool bIsDirectory)
		{
			const FString File(Name);
			if (!bIsDirectory && File.MatchesWildcard(TEXT("*.pak")))
			{
				Paks.AddUnique(File);
			}
			return true;
		});
		return Paks;
	}

	/** Bloc ContainerHeader du conteneur IoStore d'un pak : identifiant = FromName(nom de base du .utoc) (U7-T6 section 3,
	 *  verifie sur 6 conteneurs ; Id du journal T4). */
	FIoChunkId HeaderChunkOf(const FString& PakPath)
	{
		return CreateContainerHeaderChunkId(FIoContainerId::FromName(FName(*FPaths::GetBaseFilename(PakPath))));
	}

	/** Version de l'en-tete de conteneur (Signature puis Version, IoContainerHeader.cpp:51-58) ; -1 si illisible. */
	int32 ReadContainerHeaderVersion(const FString& PakPath)
	{
		if (!FIoDispatcher::IsInitialized() || !IFileManager::Get().FileExists(*FPaths::ChangeExtension(PakPath, TEXT("utoc"))))
		{
			return -1;
		}
		const FIoChunkId Chunk = HeaderChunkOf(PakPath);
		FIoDispatcher& Dispatcher = FIoDispatcher::Get();
		if (!Dispatcher.DoesChunkExist(Chunk))
		{
			return -1;
		}
		FIoBatch Batch = Dispatcher.NewBatch();
		FIoRequest Request = Batch.Read(Chunk, FIoReadOptions(0, 8), IoDispatcherPriority_High);
		FEventRef Done;
		Batch.IssueAndTriggerEvent(Done.Get());
		Done->Wait();
		// Nul en cas d'echec (IoDispatcher.cpp:1443-1461) : pas de GetResultOrDie, qui arreterait le jeu.
		const FIoBuffer* Buffer = Request.GetResult();
		if (!Buffer || Buffer->DataSize() < 8)
		{
			return -1;
		}
		uint32 Words[2] = { 0, 0 };
		FMemory::Memcpy(Words, Buffer->Data(), sizeof(Words));
		return Words[0] == static_cast<uint32>(FIoContainerHeader::Signature) ? static_cast<int32>(Words[1]) : -1;
	}

	/** Version de Mods/<id>/AssetRegistry.bin (dans le pak du mod, meme fichier que le registre d'assets du moteur,
	 *  AssetRegistry.cpp:642) ; -1 si illisible. */
	int32 ReadAssetRegistryVersion(const IPlugin& Plugin)
	{
		TUniquePtr<FArchive> Reader(IFileManager::Get().CreateFileReader(*(Plugin.GetBaseDir() / TEXT("AssetRegistry.bin")), FILEREAD_Silent));
		if (!Reader)
		{
			return -1;
		}
		FAssetRegistryVersion::Type Version = FAssetRegistryVersion::PreVersioning;
		if (!FAssetRegistryVersion::SerializeVersion(*Reader, Version) || Reader->IsError())
		{
			return -1;
		}
		return static_cast<int32>(Version);
	}

	/** Retire le point de montage /<id>/ puis demonte les paks du plugin ; vrai si rien du mod n'est plus accessible. */
	bool UnloadPlugin(const IPlugin& Plugin, const TArray<FString>& Paks)
	{
		const FString Root = Plugin.GetMountedAssetPath();
		// Etape de contenu de FPluginManager::UnmountExplicitlyLoadedPlugin (PluginManager.cpp:3716), fonction refusee ici
		// car le plugin n'est pas ExplicitlyLoaded (:3660-3667) ; memes arguments qu'au montage (:2015-2018). Le registre
		// d'assets retire alors tous les assets du point de montage (AssetRegistry.cpp:9241-9327 ; chemin non persistant :
		// UpdatePersistentMountPoints ne voit que le registre principal, :623, avant ceux des plugins, :633-656).
		FPackageName::UnRegisterMountPoint(Root, Plugin.GetContentDir());
		// Pak, entrees du magasin de paquets et conteneur IoStore (FPakPlatformFile::Unmount, IPlatformFilePak.cpp:6288-6356).
		int32 Unmounted = 0;
		for (const FString& Pak : Paks)
		{
			if (FCoreDelegates::OnUnmountPak.IsBound() && FCoreDelegates::OnUnmountPak.Execute(Pak))
			{
				++Unmounted;
			}
		}

		// Controle relu apres coup.
		const bool bRootGone = !FPackageName::MountPointExists(Root);
		const IAssetRegistry* Registry = IAssetRegistry::Get();
		const bool bRegistryEmpty = !Registry || !Registry->HasAssets(FName(*Root.LeftChop(1)), true);
		bool bContainersGone = true;
		for (const FString& Pak : Paks)
		{
			if (FIoDispatcher::IsInitialized() && FIoDispatcher::Get().DoesChunkExist(HeaderChunkOf(Pak)))
			{
				bContainersGone = false;
			}
		}
		const FString Report = FString::Printf(TEXT("%d pak(s) demonte(s) sur %d, point de montage %s %s, registre %s, conteneur(s) %s"),
			Unmounted, Paks.Num(), *Root, bRootGone ? TEXT("retire") : TEXT("ENCORE PRESENT"),
			bRegistryEmpty ? TEXT("vide") : TEXT("NON VIDE"), bContainersGone ? TEXT("absent(s)") : TEXT("ENCORE PRESENT(S)"));
		const bool bOk = Unmounted == Paks.Num() && bRootGone && bRegistryEmpty && bContainersGone;
		if (bOk)
		{
			UE_LOG(LogLifePlay, Display, TEXT("Modules : %s non charge : %s"), *Plugin.GetName(), *Report);
		}
		else
		{
			UE_LOG(LogLifePlay, Error, TEXT("Modules : %s demontage incomplet : %s ; ses assets ne sont ecartes que par LPModDailies et LPHairstyleSubsystem"),
				*Plugin.GetName(), *Report);
		}
		return bOk;
	}

	bool HasFailure(const TArray<FFailure>& Failures, ELPModCheck Check)
	{
		return Failures.ContainsByPredicate([Check](const FFailure& Failure) { return Failure.Check == Check; });
	}
}

void FLPModGuard::Run()
{
	using namespace LPModGuardImpl;
	if (GRan)
	{
		return;
	}
	GRan = true;
	// Cuisson, resave, outils : aucun mod de joueur a controler.
	if (IsRunningCommandlet() || !GConfig)
	{
		return;
	}
	// Meme valeur que UGeneralProjectSettings::ProjectVersion, lue sans dependre de l'objet par defaut (demarrage du module).
	GConfig->GetString(TEXT("/Script/EngineSettings.GeneralProjectSettings"), TEXT("ProjectVersion"), GGameVersion, GGameIni);
	for (int32 Index = 0; Index < NumChecks; ++Index)
	{
		GActive[Index] = ReadCheck(Index);
	}

	TArray<TSharedRef<IPlugin>> Mods;
	for (const TSharedRef<IPlugin>& Plugin : IPluginManager::Get().GetEnabledPluginsWithContent())
	{
		if (Plugin->GetType() == EPluginType::Mod)
		{
			Mods.Add(Plugin);
		}
	}
	const bool bCooked = FPlatformProperties::RequiresCookedData();
	const int32 GameContainer = static_cast<int32>(EIoContainerHeaderVersion::Latest);
	const int32 GameRegistry = static_cast<int32>(FAssetRegistryVersion::LatestVersion);
	const FEngineVersion& CurrentEngine = FEngineVersion::Current();
	const int32 EngineMajor = static_cast<int32>(CurrentEngine.GetMajor());
	const int32 EngineMinor = static_cast<int32>(CurrentEngine.GetMinor());
	UE_LOG(LogLifePlay, Display, TEXT("Modules : garde des mods d'assets, %d plugin(s) de type Mod, jeu %s (version min des mods %s), moteur %s (conteneur %d, registre %d)%s"),
		Mods.Num(), *GGameVersion, MinGameVersion, *CurrentEngine.ToString(), GameContainer, GameRegistry,
		bCooked ? TEXT("") : TEXT(", jeu non cuit : controle binaire sans objet, rien n'est demonte"));
	for (int32 Index = 0; Index < NumChecks; ++Index)
	{
		if (!GActive[Index])
		{
			UE_LOG(LogLifePlay, Warning, TEXT("Modules : controle %s des mods leve (Settings > Misc, %s)"), CheckNames[Index], *GGameUserSettingsIni);
		}
	}

	TArray<int64> GameParts;
	TArray<int64> MinParts;
	const bool bGameParsed = ParseVersion(GGameVersion, GameParts);
	ParseVersion(MinGameVersion, MinParts);
	if (!bGameParsed && Mods.Num() > 0)
	{
		UE_LOG(LogLifePlay, Error, TEXT("Modules : ProjectVersion '%s' illisible, controle version max sans objet"), *GGameVersion);
	}

	TArray<TArray<FString>> ModPaks;
	for (const TSharedRef<IPlugin>& Plugin : Mods)
	{
		FLPModVerdict Verdict;
		Verdict.Module = Plugin->GetName();
		TMap<FString, FString> Keys;
		FString Text;
		if (FFileHelper::LoadFileToString(Text, *(FPaths::ProjectContentDir() / TEXT("Modules") / Verdict.Module / Verdict.Module + TEXT(".lpmod"))))
		{
			ParseLpmod(Text, Keys);
		}
		const FString* Name = Keys.Find(TEXT("MODULE_NAME"));
		Verdict.DisplayName = Name && !Name->IsEmpty() ? *Name : Plugin->GetFriendlyName();
		if (Verdict.DisplayName.IsEmpty())
		{
			Verdict.DisplayName = Verdict.Module;
		}
		Verdict.BuiltFor = Keys.FindRef(TEXT("MODULE_GAME_VERSION"));
		TArray<FFailure> Failures;

		// 1. Moteur : format binaire (jeu cuit), puis EngineVersion du .uplugin.
		TArray<FString> Paks = bCooked ? FindPluginPaks(*Plugin) : TArray<FString>();
		FString Formats = bCooked ? TEXT("aucun pak") : TEXT("format non lu");
		if (Paks.Num() > 0)
		{
			const int32 RegistryVersion = ReadAssetRegistryVersion(*Plugin);
			int32 ContainerVersion = GameContainer;
			FString Unreadable = RegistryVersion < 0 ? TEXT("AssetRegistry.bin") : TEXT("");
			for (const FString& Pak : Paks)
			{
				const int32 PakContainerVersion = ReadContainerHeaderVersion(Pak);
				if (PakContainerVersion < 0)
				{
					Unreadable += (Unreadable.IsEmpty() ? TEXT("") : TEXT(", ")) + FPaths::GetBaseFilename(Pak) + TEXT(".utoc");
				}
				else if (PakContainerVersion != GameContainer)
				{
					ContainerVersion = PakContainerVersion;
				}
			}
			Formats = FString::Printf(TEXT("conteneur %d, registre %d"), ContainerVersion, RegistryVersion);
			if (!Unreadable.IsEmpty())
			{
				Failures.Add(FFailure{ ELPModCheck::Engine, TEXT("mod files unreadable"),
					FString::Printf(TEXT("moteur : fichiers illisibles (%s)"), *Unreadable) });
			}
			else if (ContainerVersion != GameContainer || RegistryVersion != GameRegistry)
			{
				const bool bByContainer = ContainerVersion != GameContainer;
				const int32 ModFormat = bByContainer ? ContainerVersion : RegistryVersion;
				const int32 GameFormat = bByContainer ? GameContainer : GameRegistry;
				Failures.Add(FFailure{ ELPModCheck::Engine,
					FString::Printf(TEXT("built with %s engine (%sformat %d, game %d): rebuild the mod for LifePlay %s"),
						ModFormat < GameFormat ? TEXT("an older") : TEXT("a newer"), bByContainer ? TEXT("") : TEXT("asset registry "),
						ModFormat, GameFormat, *GGameVersion),
					FString::Printf(TEXT("moteur : conteneur %d (jeu %d), registre %d (jeu %d)"), ContainerVersion, GameContainer,
						RegistryVersion, GameRegistry) });
			}
		}
		const FString& Declared = Plugin->GetDescriptor().EngineVersion;
		if (!Declared.IsEmpty() && !HasFailure(Failures, ELPModCheck::Engine))
		{
			FEngineVersion Parsed;
			if (!FEngineVersion::Parse(Declared, Parsed))
			{
				Failures.Add(FFailure{ ELPModCheck::Engine, TEXT("mod files unreadable"),
					FString::Printf(TEXT("moteur : EngineVersion '%s' illisible dans le .uplugin"), *Declared) });
			}
			else if (static_cast<int32>(Parsed.GetMajor()) != EngineMajor || static_cast<int32>(Parsed.GetMinor()) != EngineMinor)
			{
				const bool bOlder = static_cast<int32>(Parsed.GetMajor()) < EngineMajor
					|| (static_cast<int32>(Parsed.GetMajor()) == EngineMajor && static_cast<int32>(Parsed.GetMinor()) < EngineMinor);
				Failures.Add(FFailure{ ELPModCheck::Engine,
					FString::Printf(TEXT("built with %s engine (Unreal Engine %s, game %d.%d): rebuild the mod for LifePlay %s"),
						bOlder ? TEXT("an older") : TEXT("a newer"), *Declared, EngineMajor, EngineMinor, *GGameVersion),
					FString::Printf(TEXT("moteur : EngineVersion %s (moteur %d.%d)"), *Declared, EngineMajor, EngineMinor) });
			}
		}

		// 2 et 3. Versions min et max du jeu visees par le mod.
		if (Verdict.BuiltFor.IsEmpty())
		{
			UE_LOG(LogLifePlay, Warning, TEXT("Modules : %s sans MODULE_GAME_VERSION, controles de version min et max sans objet"), *Verdict.Module);
		}
		else
		{
			TArray<int64> BuiltParts;
			if (!ParseVersion(Verdict.BuiltFor, BuiltParts))
			{
				Failures.Add(FFailure{ ELPModCheck::MinVersion,
					FString::Printf(TEXT("unreadable game version '%s' in its .lpmod"), *Verdict.BuiltFor),
					FString::Printf(TEXT("version min : MODULE_GAME_VERSION '%s' illisible"), *Verdict.BuiltFor) });
			}
			else
			{
				if (CompareVersions(BuiltParts, MinParts) < 0)
				{
					Failures.Add(FFailure{ ELPModCheck::MinVersion,
						FString::Printf(TEXT("built for LifePlay %s, minimum is %s"), *Verdict.BuiltFor, MinGameVersion),
						FString::Printf(TEXT("version min : construit pour LifePlay %s < %s"), *Verdict.BuiltFor, MinGameVersion) });
				}
				if (bGameParsed && CompareVersions(BuiltParts, GameParts) > 0)
				{
					Failures.Add(FFailure{ ELPModCheck::MaxVersion,
						FString::Printf(TEXT("built for LifePlay %s, this game is %s: update the game"), *Verdict.BuiltFor, *GGameVersion),
						FString::Printf(TEXT("version max : construit pour LifePlay %s > %s"), *Verdict.BuiltFor, *GGameVersion) });
				}
			}
		}

		// Echec Moteur actif : les echecs min/max restent au journal seulement (secondaires). La numerotation 5.5 n'est pas
		// monotone (mods 2026.10.4 > 2026.10.2.0) : la fenetre dirait a tort "update the game".
		const bool bEngineRefused = GActive[static_cast<int32>(ELPModCheck::Engine)] && HasFailure(Failures, ELPModCheck::Engine);
		TArray<FString> Lifted;
		for (const FFailure& Failure : Failures)
		{
			if (GActive[static_cast<int32>(Failure.Check)])
			{
				Verdict.bRefused = true;
				if (bEngineRefused && Failure.Check != ELPModCheck::Engine)
				{
					Verdict.LogReasons.Add(Failure.Fr + TEXT(" (secondaire)"));
				}
				else
				{
					Verdict.Reasons.Add(Failure.En);
					Verdict.LogReasons.Add(Failure.Fr);
				}
			}
			else
			{
				Lifted.Add(Failure.Fr);
			}
		}
		const FString Summary = FString::Printf(TEXT("%s, EngineVersion %s, construit pour LifePlay %s"), *Formats,
			Declared.IsEmpty() ? TEXT("absent") : *Declared, Verdict.BuiltFor.IsEmpty() ? TEXT("?") : *Verdict.BuiltFor);
		const FString LiftedNote = Lifted.Num() > 0 ? TEXT(" ; controle leve : ") + FString::Join(Lifted, TEXT(" ; ")) : FString();
		if (Verdict.bRefused)
		{
			// Une ligne Warning par mod refuse.
			UE_LOG(LogLifePlay, Warning, TEXT("Modules : %s refuse : %s%s"), *Verdict.Module, *FString::Join(Verdict.LogReasons, TEXT(" ; ")),
				*LiftedNote);
		}
		else if (Lifted.Num() > 0)
		{
			UE_LOG(LogLifePlay, Warning, TEXT("Modules : %s charge malgre : %s (controle leve dans Settings > Misc)"), *Verdict.Module,
				*FString::Join(Lifted, TEXT(" ; ")));
		}
		else
		{
			UE_LOG(LogLifePlay, Display, TEXT("Modules : %s accepte (%s)"), *Verdict.Module, *Summary);
		}
		GVerdicts.Add(MoveTemp(Verdict));
		ModPaks.Add(MoveTemp(Paks));
	}

	// Jeu cuit : un mod refuse n'est pas charge. L'editeur ne demonte rien (contenu non cuit, pas de pak).
	if (!bCooked)
	{
		return;
	}
	bool bWaited = false;
	for (int32 Index = 0; Index < GVerdicts.Num(); ++Index)
	{
		if (!GVerdicts[Index].bRefused)
		{
			continue;
		}
		if (!bWaited)
		{
			// Le registre des plugins peut se charger en tache de fond (AssetRegistry.cpp:377-428) : il doit etre complet
			// avant le retrait du point de montage, sinon celui du mod serait ajoute apres la purge.
			if (IAssetRegistry* Registry = IAssetRegistry::Get())
			{
				Registry->WaitForPremadeAssetRegistry();
			}
			bWaited = true;
		}
		GVerdicts[Index].bUnloaded = UnloadPlugin(*Mods[Index], ModPaks[Index]);
	}
}

const TArray<FLPModVerdict>& FLPModGuard::GetVerdicts()
{
	Run();
	return LPModGuardImpl::GVerdicts;
}

bool FLPModGuard::IsRefused(const FString& Module)
{
	for (const FLPModVerdict& Verdict : GetVerdicts())
	{
		if (Verdict.bRefused && Verdict.Module.Equals(Module, ESearchCase::IgnoreCase))
		{
			return true;
		}
	}
	return false;
}

bool FLPModGuard::IsCheckActive(ELPModCheck Check)
{
	Run();
	const int32 Index = static_cast<int32>(Check);
	return Index >= 0 && Index < LPModGuardImpl::NumChecks ? LPModGuardImpl::GActive[Index] : true;
}

bool FLPModGuard::GetSavedCheck(ELPModCheck Check)
{
	const int32 Index = static_cast<int32>(Check);
	return Index >= 0 && Index < LPModGuardImpl::NumChecks ? LPModGuardImpl::ReadCheck(Index) : true;
}

void FLPModGuard::SaveCheck(ELPModCheck Check, bool bEnabled)
{
	using namespace LPModGuardImpl;
	const int32 Index = static_cast<int32>(Check);
	if (Index < 0 || Index >= NumChecks || !GConfig)
	{
		return;
	}
	GConfig->SetBool(SettingsSection, CheckKeys[Index], bEnabled, GGameUserSettingsIni);
	GConfig->Flush(false, GGameUserSettingsIni);
	UE_LOG(LogLifePlay, Display, TEXT("Modules : controle %s des mods %s dans %s, effet au prochain lancement"), CheckNames[Index],
		bEnabled ? TEXT("active") : TEXT("leve"), *GGameUserSettingsIni);
}

const FString& FLPModGuard::GetGameVersion()
{
	Run();
	return LPModGuardImpl::GGameVersion;
}

void FLPModGuard::ParseLpmod(const FString& Text, TMap<FString, FString>& OutKeys)
{
	TArray<FString> Lines;
	Text.ParseIntoArrayLines(Lines, true);
	for (const FString& Line : Lines)
	{
		FString Key, Value;
		if (!Line.TrimStart().StartsWith(TEXT("//")) && Line.Split(TEXT(":"), &Key, &Value))
		{
			OutKeys.Add(Key.TrimStartAndEnd().ToUpper(), Value.TrimStartAndEnd());
		}
	}
}