Add TrackedRequest implementation in DTFluxCoreSubsystem and various Modifications and bugfixes.

Fixing Various Bugs On Delegates
implement Pursuit Sequence Logic
2025-07-11 23:45:23 +02:00 · 2025-07-11 19:04:37 +02:00 · 2025-07-11 13:09:18 +02:00 · 2025-07-10 20:35:06 +02:00 · 2025-07-09 03:27:23 +02:00
29 changed files with 3482 additions and 1382 deletions
--- a/DTFluxAPI.uplugin
+++ b/DTFluxAPI.uplugin
@ -49,11 +49,6 @@
 			"Name": "DTFluxAPIStatus",
 			"Type": "Editor",
 			"LoadingPhase": "Default"
-		},
-		{
-			"Name": "DTFluxPursuitSystem",
-			"Type": "Runtime",
-			"LoadingPhase": "Default"
 		}
 	],
 	"Plugins": [
--- a/Source/DTFluxAPIStatus/DTFluxAPIStatus.Build.cs
+++ b/Source/DTFluxAPIStatus/DTFluxAPIStatus.Build.cs
@ -31,6 +31,7 @@ public class DTFluxAPIStatus : ModuleRules
 				"DTFluxCoreSubsystem",
 				"InputCore",
 				"OutputLog",
+				"ToolMenus",
 			}
 		);
 	}
--- a/Source/DTFluxAPIStatus/Private/DTFluxAPIStatusModule.cpp
+++ b/Source/DTFluxAPIStatus/Private/DTFluxAPIStatusModule.cpp
@ -14,9 +14,9 @@ FText DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::StatusTabDisplayName = FText::

 void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::StartupModule()
 {
+	FDTFluxStatusStyle::RegisterStyle();
 	InitMenuExtension();
 	RegisterStatusTab();
-	FDTFluxStatusStyle::RegisterStyle();
 }


@ -25,45 +25,109 @@ void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::StartupModule()

 void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::InitMenuExtension()
 {
-	FLevelEditorModule& LevelEditorModule =
-		FModuleManager::LoadModuleChecked<FLevelEditorModule>(TEXT("LevelEditor"));
-	// FDTFluxAPIModule& DTFluxApi =
-	// 	FModuleManager::LoadModuleChecked<FDTFluxAPIModule>(TEXT("DTFluxAPI"));
-	const TSharedPtr<FExtender> MenuExtender = MakeShareable(new FExtender());
+	// FLevelEditorModule& LevelEditorModule =
+	// 	FModuleManager::LoadModuleChecked<FLevelEditorModule>(TEXT("LevelEditor"));
+	// // FDTFluxAPIModule& DTFluxApi =
+	// // 	FModuleManager::LoadModuleChecked<FDTFluxAPIModule>(TEXT("DTFluxAPI"));
+	// const TSharedPtr<FExtender> MenuExtender = MakeShareable(new FExtender());
+	//
+	// MenuExtender->AddMenuBarExtension(
+	// 	"Help",
+	// 	EExtensionHook::Before,
+	// 	nullptr,
+	// 	FMenuBarExtensionDelegate::CreateRaw(this, &FDTFluxAPIStatusModule::AddMenu)
+	// 	);
+	// LevelEditorModule.GetMenuExtensibilityManager()->AddExtender(MenuExtender);
 	
-	MenuExtender->AddMenuBarExtension(
-		"Help",
-		EExtensionHook::Before,
-		nullptr,
-		FMenuBarExtensionDelegate::CreateRaw(this, &FDTFluxAPIStatusModule::AddMenu)
+	UToolMenus::RegisterStartupCallback(
+		FSimpleMulticastDelegate::FDelegate::CreateRaw(this, &FDTFluxAPIStatusModule::RegisterMenus)
 	);
-	LevelEditorModule.GetMenuExtensibilityManager()->AddExtender(MenuExtender);
-

 }

-void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::AddMenu(FMenuBarBuilder& MenuBarBuilder)
+void FDTFluxAPIStatusModule::RegisterMenus()
 {
-	MenuBarBuilder.AddPullDownMenu(
+	UE_LOG(logDTFluxStatus, Warning, TEXT("Creating DTFlux menu"));
+    
+	// 1. Enregistrer le menu DTFlux
+	UToolMenu* DTFluxMenu = UToolMenus::Get()->RegisterMenu("DTFlux.MainMenu");
+	if (DTFluxMenu)
+	{
+		CreateSubmenu(DTFluxMenu);
+	}
+    
+	// 2. Ajouter ce menu à la barre principale
+	if (UToolMenu* MainMenu = UToolMenus::Get()->ExtendMenu("MainFrame.MainMenu"))
+	{
+		FToolMenuSection& DTFluxMenuSection = MainMenu->FindOrAddSection("DTFlux");
+		DTFluxMenuSection.Label = FText::FromString("DTFlux");
+        
+		DTFluxMenuSection.AddSubMenu(
+			"DTFluxSubmenu",
 			FText::FromString("DTFlux"),
 			FText::FromString("DTFlux API Tools"),
-		FNewMenuDelegate::CreateRaw(this, &FDTFluxAPIStatusModule::FillMenu)
+			FNewToolMenuDelegate::CreateLambda([](UToolMenu* Menu)
+			{
+				// Référencer le menu enregistré
+				if (UToolMenu* RegisteredMenu = UToolMenus::Get()->FindMenu("DTFlux.MainMenu"))
+				{
+					// Copier la structure du menu enregistré
+					for (const FToolMenuSection& Section : RegisteredMenu->Sections)
+					{
+						Menu->Sections.Add(Section);
+					}
+				}
+			}),
+			false,
+			FSlateIcon(FAppStyle::GetAppStyleSetName(), "LevelEditor.Tab.Icon")
 		);
+	}
+
 }

-void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::FillMenu(FMenuBuilder& MenuBuilder)
+void FDTFluxAPIStatusModule::CreateSubmenu(UToolMenu* Menu)
 {
-	MenuBuilder.BeginSection(NAME_None, FText::FromString("DTFlux API"));
-	MenuBuilder.AddMenuEntry(
-	FText::FromString("Status"),
-	FText::FromString("Launch DTFlux Status"),
-	FSlateIcon(FDTFluxStatusStyle::GetStyleSetName(), "LevelEditor.Tab.Icon"),
-	FExecuteAction::CreateRaw(this, &FDTFluxAPIStatusModule::OnButtonClicked)
-	);
-	MenuBuilder.EndSection();
+	FToolMenuSection& DTFluxAPISection = Menu->FindOrAddSection("DTFluxAPI");
+	DTFluxAPISection.Label = FText::FromString("DTFlux API");
+	// Cette section est vide pour le moment, prête pour de futurs boutons

+	
+	// Section 2 : Tools
+	FToolMenuSection& ToolsSection = Menu->FindOrAddSection("Tools");
+	ToolsSection.Label = FText::FromString("Tools");
+
+    
+	// Ajouter le bouton Status dans la section Tools
+	DTFluxAPISection.AddMenuEntry(
+		"DTFluxStatus",
+		FText::FromString("DTFlux Status"),
+		FText::FromString("Launch DTFlux Status Control Panel"),
+		FSlateIcon(FDTFluxStatusStyle::GetStyleSetName(), "LevelEditor.Tab.Icon"),
+		FUIAction(FExecuteAction::CreateRaw(this, &FDTFluxAPIStatusModule::OnButtonClicked))
+	);
 }

+// void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::AddMenu(FMenuBarBuilder& MenuBarBuilder)
+// {
+// 	MenuBarBuilder.AddPullDownMenu(
+// 		FText::FromString("DTFlux"),
+// 		FText::FromString("DTFlux API Tools"),
+// 		FNewMenuDelegate::CreateRaw(this, &FDTFluxAPIStatusModule::FillMenu)
+// 		);
+// }
+
+// void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::FillMenu(FMenuBuilder& MenuBuilder)
+// {
+// 	MenuBuilder.BeginSection(NAME_None, FText::FromString("DTFlux API"));
+// 	MenuBuilder.AddMenuEntry(
+// 	FText::FromString("Status"),
+// 	FText::FromString("Launch DTFlux Status"),
+// 	FSlateIcon(FDTFluxStatusStyle::GetStyleSetName(), "LevelEditor.Tab.Icon"),
+// 	FExecuteAction::CreateRaw(this, &FDTFluxAPIStatusModule::OnButtonClicked)
+// 	);
+// 	MenuBuilder.EndSection();
+// }
+
 void DTFLUXAPISTATUS_API FDTFluxAPIStatusModule::OnButtonClicked()
 {
 	FGlobalTabmanager::Get()->TryInvokeTab(StatusTabId);
--- a/Source/DTFluxAPIStatus/Private/widgets/DTFluxStatusWidget.cpp
+++ b/Source/DTFluxAPIStatus/Private/widgets/DTFluxStatusWidget.cpp
@ -416,7 +416,7 @@ FSlateColor SDTFluxStatusWidget::GetComboItemRankingColor(const TSharedPtr<FComb

 FReply SDTFluxStatusWidget::OnRankingButtonClicked() const
 {
-	if (DTFluxNetwork)
+	if (DTFluxCore)
 	{
 		// Exemple d'envoi de requête basée sur la sélection
 		int ForContest = SelectedContestComboBoxItem.IsValid() ? SelectedContestComboBoxItem->ContestId : -1;
@ -432,13 +432,19 @@ FReply SDTFluxStatusWidget::OnRankingButtonClicked() const
 		if (ForStage == -1)
 		{
 			UE_LOG(logDTFluxStatus, Warning, TEXT("Stage not selected !!!! Requesting contest Ranking"));
-			RequestType = EDTFluxApiDataType::ContestRanking;
-			DTFluxNetwork->SendRequest(RequestType, ForContest);
+			DTFluxCore->TrackedRequestContestRankings({ForContest});
 			return FReply::Handled();
 		}
-		RequestType = ForSplit == -1 ? EDTFluxApiDataType::StageRanking : EDTFluxApiDataType::SplitRanking;
+		if (ForSplit == -1)
+		{
+			UE_LOG(logDTFluxStatus, Warning, TEXT("Split not selected !!!! Requesting stage Ranking"));
+			FDTFluxStageKey StageKey = {ForContest, ForStage};
+			DTFluxCore->TrackedRequestStageRankings({StageKey});
+			return FReply::Handled();
+		}
+		FDTFluxSplitKey SplitKey = {ForContest, ForStage, ForSplit};
+		DTFluxCore->TrackedRequestSplitRankings({SplitKey});
 		UE_LOG(logDTFluxStatus, Warning, TEXT("Requesting %s Ranking"), *UEnum::GetValueAsString(RequestType));
-		DTFluxNetwork->SendRequest(RequestType, ForContest, ForStage, ForSplit);
 	}

 	return FReply::Handled();
--- a/Source/DTFluxAPIStatus/Private/widgets/styles/DTFluxStatusStyle.cpp
+++ b/Source/DTFluxAPIStatus/Private/widgets/styles/DTFluxStatusStyle.cpp
@ -13,7 +13,7 @@ TSharedPtr<ISlateStyle> FDTFluxStatusStyle::StyleSet = nullptr;

 void FDTFluxStatusStyle::RegisterStyle()
 {
-	if(StyleSet.IsValid()) return;
+	if (StyleSet.IsValid()) return;

 	StyleSet = Create();
 	FSlateStyleRegistry::RegisterSlateStyle(*StyleSet);
@ -21,14 +21,12 @@ void FDTFluxStatusStyle::RegisterStyle()

 void FDTFluxStatusStyle::UnregisterStyle()
 {
-	if(StyleSet.IsValid())
+	if (StyleSet.IsValid())
 	{
 		FSlateStyleRegistry::UnRegisterSlateStyle(*StyleSet);
 		ensure(StyleSet.IsUnique());
 		StyleSet.Reset();
 	}
-
-	
 }

 void FDTFluxStatusStyle::ReloadTextures()
@ -38,9 +36,8 @@ void FDTFluxStatusStyle::ReloadTextures()
 TSharedPtr<ISlateStyle> FDTFluxStatusStyle::Create()
 {
 	TSharedPtr<FSlateStyleSet> Style = MakeShareable(new FSlateStyleSet("DTFluxAPIStatusStyle"));
-	Style->SetContentRoot(IPluginManager::Get().FindPlugin("DTFluxAPI")->GetBaseDir()/TEXT("Resources"));
+	Style->SetContentRoot(IPluginManager::Get().FindPlugin("DTFluxAPI")->GetBaseDir() / TEXT("Resources"));

-	Style->Set("LevelEditor.Tab.Icon", new IMAGE_BRUSH_SVG("DTFluxServerStatusWhite", FVector2d(16)) );
+	Style->Set("LevelEditor.Tab.Icon", new IMAGE_BRUSH_SVG("DTFluxServerStatusWhite", FVector2d(16)));
 	return Style;
 }
-
--- a/Source/DTFluxAPIStatus/Public/DTFluxAPIStatusModule.h
+++ b/Source/DTFluxAPIStatus/Public/DTFluxAPIStatusModule.h
@ -13,10 +13,11 @@ public:

 #pragma region MenuExtention
    void InitMenuExtension();
-    void AddMenu(FMenuBarBuilder& MenuBarBuilder);
-    void FillMenu(FMenuBuilder& MenuBuilder);
+    void RegisterMenus();
+    void CreateSubmenu(UToolMenu* Menu);
+    // void AddMenu(FMenuBarBuilder& MenuBarBuilder);
+    // void FillMenu(FMenuBuilder& MenuBuilder);
    void OnButtonClicked();
-    // void OnWsEvent(TEnumAsByte<EDTFluxWsStatus> WsResponseEvent) const;
 #pragma endregion

 #pragma region EditorTab
@ -25,7 +26,6 @@ public:
 private:
    static FName StatusTabId;
    static FText StatusTabDisplayName;
-
    TSharedPtr<class SDTFluxStatusWidget> StatusWidget;
 #pragma endregion
 };
--- a/Source/DTFluxAssetsEditor/Private/DTFluxModelAssetDetailCustomization.cpp
+++ b/Source/DTFluxAssetsEditor/Private/DTFluxModelAssetDetailCustomization.cpp
@ -36,6 +36,11 @@ EActiveTimerReturnType SDTFluxAssetModelDetailsWidget::ForceInitialLayout(double
 }

 void FDTFluxModelAssetCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailBuilder)
+{
+	CustomizeDetailsWithRawDataAccess(DetailBuilder);
+}
+
+void FDTFluxModelAssetCustomization::CustomizeDetailsWithoutRawDataAsset(IDetailLayoutBuilder& DetailBuilder)
 {
 	// Edit object
 	TArray<TWeakObjectPtr<UObject>> ObjectsBeingCustomized;
--- a/Source/DTFluxAssetsEditor/Public/DTFluxModelAssetDetailCustomization.h
+++ b/Source/DTFluxAssetsEditor/Public/DTFluxModelAssetDetailCustomization.h
@ -11,6 +11,7 @@ public:
 	// IDetailCustomization interface
 	virtual void CustomizeDetails(IDetailLayoutBuilder& DetailBuilder) override;

+	void CustomizeDetailsWithoutRawDataAsset(IDetailLayoutBuilder& DetailBuilder);
 	void CustomizeDetailsWithRawDataAccess(IDetailLayoutBuilder& DetailBuilder);

 	// Crée une instance de cette customization
--- a/Source/DTFluxCore/Private/Types/Struct/DTFluxRankingStructs.cpp
+++ b/Source/DTFluxCore/Private/Types/Struct/DTFluxRankingStructs.cpp
@ -7,23 +7,5 @@ void FDTFluxContestRanking::Dump() const
 {
 	UE_LOG(logDTFluxCore, Log,
 	       TEXT("FDTFluxContestRanking ->> \n \"rank\" : %d, Participant with Bib %d \"Gap\" : %s, \"Time\" : %s "),
-		Rank, Bib, *Gap, *Time );
+	       Rank, Bib, *Gap, *Time);
 };
-
-// void FDTFluxStageRanking::Dump() const
-// {	
-// 	UE_LOG(logDTFluxCore, Log, TEXT("RANKING : %02d. Participant bib %d %s %s %s %s %s"),
-// 		Rank, Bib, *Gap, *TimeSwim,
-// 		*TimeTransition, *TimeRun, *StartTime.ToString());
-// }
-//
-
-
-
-// void FDTFluxSplitRanking::Dump() const
-// {
-// 	UE_LOG(logDTFluxCore, Log, TEXT("SplitGapItem"))
-// 	// Participant.Dump();
-// 	UE_LOG(logDTFluxCore, Log, TEXT("Bib %02d Rank %02d Gap %s Time %s"), Bib, Rank, *Gap, *Time);
-// }
-
--- a/Source/DTFluxCore/Private/Types/Struct/DTFluxTeamListStruct.cpp
+++ b/Source/DTFluxCore/Private/Types/Struct/DTFluxTeamListStruct.cpp
@ -3,6 +3,8 @@

 #include "Types/Struct/DTFluxTeamListStruct.h"

+#include "DTFluxCoreModule.h"
+

 void FDTFluxParticipant::AddTeammate(const FDTFluxPerson& Person)
 {
@ -15,11 +17,12 @@ void FDTFluxParticipant::AddTeammate(const FString LastName, const FString First

 FString FDTFluxParticipant::GetFormattedName(const int MaxChar, const FString OverflowChars) const
 {
-	// Vérifie les cas limites
+	{
 		if (MaxChar <= 0)
 		{
 			return "";
 		}
+
 		FString FirstName;
 		FString LastName;
 		if (IsTeam())
@ -31,62 +34,50 @@ FString FDTFluxParticipant::GetFormattedName(const int MaxChar, const FString Ov
 			FirstName = Teammate[0].FirstName;
 			LastName = Teammate[0].LastName;
 		}
-	// Récupère la première lettre du prénom en majuscule
 		FString Initial;
 		if (!FirstName.IsEmpty())
 		{
 			Initial = FirstName.Left(1).ToUpper() + " ";
 		}

-	// Nom complet en majuscules
 		FString FormattedLastName = LastName.ToUpper();

-	// Construction du nom final
 		FString FullName = Initial + FormattedLastName;
 		UE_LOG(logDTFluxCore, Error, TEXT("FullName for Bib %i is %s"), Bib, *FullName);

-	// Tronque si nécessaire
-	if (FullName.Len() > MaxChar)
+		if (FullName.Len() <= MaxChar)
 		{
-		// On essaie de garder autant de caractères que possible
-		const int32 AvailableLength = MaxChar - Initial.Len();
-		if (AvailableLength <= 0)
-		{
-			return Initial;
+			return FullName;
 		}

-		// Coupe le nom pour qu’il rentre dans la limite
-		const int32 TruncateLength = FMath::Min(AvailableLength, FormattedLastName.Len());
-		FullName = Initial + FormattedLastName.Left(TruncateLength);
-
-		// Si on a coupé trop court, on ajoute le suffixe
-		if (FormattedLastName.Len() > TruncateLength)
-		{
-			// On vérifie qu'il reste de la place pour le suffixe
-			const int32 CurrentLength = FullName.Len();
 		const int32 OverflowLength = OverflowChars.Len();

-			if (CurrentLength + OverflowLength <= MaxChar)
+		if (OverflowLength > MaxChar)
 		{
-				FullName += OverflowChars;
-			}
-			else
-			{
-				// Il faut tronquer davantage pour faire de la place au suffixe
-				const int32 RemainingSpace = MaxChar - CurrentLength;
-				if (RemainingSpace > 0)
-				{
-					FullName = FullName.Left(MaxChar - OverflowLength) + OverflowChars;
-				}
-				else
-				{
-					FullName = FullName.Left(MaxChar);
-				}
-			}
-		}
+			return FullName.Left(MaxChar);
 		}

-	return FullName;
+		if (Initial.Len() + OverflowLength > MaxChar)
+		{
+			return FullName.Left(MaxChar);
+		}
+
+		const int32 AvailableForLastName = MaxChar - Initial.Len() - OverflowLength;
+
+		if (AvailableForLastName <= 0)
+		{
+			return FullName.Left(MaxChar);
+		}
+
+		FString TruncatedName = Initial + FormattedLastName.Left(AvailableForLastName) + OverflowChars;
+
+		if (TruncatedName.Len() > MaxChar)
+		{
+			return TruncatedName.Left(MaxChar);
+		}
+
+		return TruncatedName;
+	}
 }

 FString FDTFluxParticipant::GetConcatFormattedName(const int MaxChar, const FString OverflowChar) const
--- a/Source/DTFluxCore/Public/Types/Struct/DTFluxRankingStructs.h
+++ b/Source/DTFluxCore/Public/Types/Struct/DTFluxRankingStructs.h
@ -85,11 +85,11 @@ public:
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Model", VisibleAnywhere)
 	FDateTime StartTime;
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Model", VisibleAnywhere)
-	float SpeedRunning;
+	FString SpeedRunning;
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Model", VisibleAnywhere)
-	float SpeedTotal;
+	FString SpeedTotal;
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Model", VisibleAnywhere)
-	float SpeedSwim;
+	FString SpeedSwim;
 	void Dump() const;
 };

@ -103,6 +103,7 @@ public:
 	int ContestId = -1;
 	UPROPERTY(BlueprintReadWrite, Category="DTFlux|Model|Ranking", VisibleAnywhere)
 	int StageId = -1;
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Model|Ranking", VisibleAnywhere)
 	TArray<FDTFluxDetailedRankingItem> Rankings;
 };

--- a/Source/DTFluxCore/Public/Types/Struct/FDTFluxPursuitInfo.h
+++ b/Source/DTFluxCore/Public/Types/Struct/FDTFluxPursuitInfo.h
@ -32,4 +32,7 @@ struct FDTFluxPursuitInfo
 	//TODO : Set this property to BlueprintReadOnly
 	UPROPERTY(BlueprintReadWrite, EditAnywhere)
 	FDateTime StartTime;
+
+	UPROPERTY()
+	int ContestId = -1;
 };
--- a/Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
+++ b/Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
@ -6,9 +6,11 @@

 #include "DTFluxCoreSubsystemModule.h"
 #include "DTFluxGeneralSettings.h"
+#include "DTFluxPursuitManager.h"
 #include "FileHelpers.h"
 #include "Assets/DTFluxModelAsset.h"
 #include "Subsystems/DTFluxNetworkSubsystem.h"
+#include "Struct/DTFluxServerResponseStruct.h"
 #include "UObject/SavePackage.h"

 void UDTFluxCoreSubsystem::Initialize(FSubsystemCollectionBase& Collection)
@ -31,6 +33,7 @@ void UDTFluxCoreSubsystem::Initialize(FSubsystemCollectionBase& Collection)
 	{
 		RegisterDelegates();
 	}
+	PursuitManager = NewObject<UDTFluxPursuitManager>(this);
 }

 void UDTFluxCoreSubsystem::Deinitialize()
@ -50,6 +53,84 @@ void UDTFluxCoreSubsystem::SaveDataStorage()
 	}
 }

+void UDTFluxCoreSubsystem::ProcessTrackedResponse(FDTFluxServerResponse& InResponse)
+{
+	switch (InResponse.GetResponseType())
+	{
+	case EDTFluxApiDataType::ContestRanking:
+		{
+			FDTFluxContestRankings Rankings;
+			if (InResponse.ParseContestRanking(Rankings))
+			{
+				ProcessContestRanking(Rankings);
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking added for Contest %s"),
+				       *Rankings.ContestName);
+			}
+			else
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse ContestRanking"));
+			}
+			break;
+		}
+	case EDTFluxApiDataType::StageRanking:
+		{
+			FDTFluxStageRankings Rankings;
+			if (InResponse.ParseStageRanking(Rankings))
+			{
+				ProcessStageRanking(Rankings);
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking added for Stage %i of Contest %i"),
+				       Rankings.StageId, Rankings.ContestId);
+			}
+			else
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse StageRanking"));
+			}
+			break;
+		}
+	case EDTFluxApiDataType::SplitRanking:
+		{
+			FDTFluxSplitRankings Rankings;
+			if (InResponse.ParseSplitRanking(Rankings))
+			{
+				ProcessSplitRanking(Rankings);
+				UE_LOG(logDTFluxCoreSubsystem, Warning,
+				       TEXT("ContestRanking added for Split %i of Stage %i of Contest %i"),
+				       Rankings.SplitId, Rankings.StageId, Rankings.ContestId);
+			}
+			else
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse SplitRanking"));
+			}
+			break;
+		}
+	case EDTFluxApiDataType::RaceData:
+		{
+			FDTFluxRaceData RaceData;
+			if (InResponse.ParseRaceData(RaceData))
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("RaceDataDefinition added for Contest %s"),
+				       *RaceData.Datas[0].Name);
+				ProcessRaceData(RaceData);
+			}
+			break;
+		}
+	case EDTFluxApiDataType::TeamList:
+		{
+			FDTFluxTeamListDefinition TeamList;
+			if (InResponse.ParseTeamList(TeamList))
+			{
+				ProcessTeamList(TeamList);
+				UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("Process TeamList"))
+			}
+			break;
+		}
+	default:
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Unknown DataType %s"),
+		       *UEnum::GetValueAsString(InResponse.GetResponseType()));
+		break;
+	}
+}
+
 void UDTFluxCoreSubsystem::RegisterDelegates()
 {
 	if (NetworkSubsystem)
@ -82,9 +163,6 @@ void UDTFluxCoreSubsystem::RegisterDelegates()
 			&UDTFluxCoreSubsystem::ProcessSplitRanking
 		);

-		// ⚠️ ATTENTION : Vous avez un doublon ici !
-		// NetworkSubsystem->OnReceivedTeamUpdate().BindUFunction(this, "ProcessTeamList");
-
 		NetworkSubsystem->OnReceivedTeamStatusUpdate().BindUObject(
 			this,
 			&UDTFluxCoreSubsystem::ProcessTeamStatusUpdate
@ -149,21 +227,24 @@ void UDTFluxCoreSubsystem::ProcessContestRanking(const FDTFluxContestRankings& C
 	DataStorage->AddContestRanking(NewContestRankings);
 	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRankings added for Contest %s"),
 	       *NewContestRankings.ContestName);
+	if (bShouldKeepRankings)
+	{
 		SaveDataStorage();
+	}
 }

 void UDTFluxCoreSubsystem::ProcessStageRanking(const FDTFluxStageRankings& StageRankings)
 {
 	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Received StageRankings with %i Items"), StageRankings.Rankings.Num());
 	DataStorage->UpdateOrCreateStageRanking(StageRankings);
-	SaveDataStorage();
+	if (bShouldKeepRankings) { SaveDataStorage(); }
 }

 void UDTFluxCoreSubsystem::ProcessSplitRanking(const FDTFluxSplitRankings& SplitRankings)
 {
 	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Received SplitRanking with %i Items"), SplitRankings.Rankings.Num());
 	DataStorage->UpdateOrCreateSplitRanking(SplitRankings);
-	SaveDataStorage();
+	if (bShouldKeepRankings) { SaveDataStorage(); }
 }

 void UDTFluxCoreSubsystem::ProcessTeamStatusUpdate(const FDTFluxTeamStatusUpdate& NewParticipantStatus)
@ -203,64 +284,182 @@ void UDTFluxCoreSubsystem::SendRequest(const FString& Message)
 	}
 }

-void UDTFluxCoreSubsystem::SendTeamListRequest()
+bool UDTFluxCoreSubsystem::GetContestRankings(const int ContestId,
+                                              FDTFluxContestRankings& OutContestRankings)
+{
+	if (DataStorage->ContestRankings.Contains(ContestId))
+	{
+		OutContestRankings = DataStorage->ContestRankings[ContestId];
+		return true;
+	}
+	if (NetworkSubsystem)
+	{
+		TArray<int> TackedContestIds = {ContestId};
+		TrackedRequestContestRankings(TackedContestIds);
+		return false;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"));
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetStageRankings(const int ContestId, const int StageId,
+                                            FDTFluxStageRankings& OutStageRankings)
+{
+	return GetStageRankingsWithKey(FDTFluxStageKey(ContestId, StageId), OutStageRankings);
+}
+
+bool UDTFluxCoreSubsystem::GetSplitRankings(const int ContestId, const int StageId, const int SplitId,
+                                            FDTFluxSplitRankings& OutSplitRankings)
+{
+	return GetSplitRankingsWithKey(FDTFluxSplitKey(ContestId, StageId, SplitId), OutSplitRankings);
+}
+
+bool UDTFluxCoreSubsystem::GetStageRankingsWithKey(const FDTFluxStageKey StageKey,
+                                                   FDTFluxStageRankings& OutStageRankings, const bool bShouldUseCached)
+{
+	//We Have the data
+	if (DataStorage->StageRankings.Contains(StageKey) && bShouldUseCached)
+	{
+		OutStageRankings = DataStorage->StageRankings[StageKey];
+		return true;
+	}
+	else
+	{
+		if (NetworkSubsystem)
+		{
+			TArray<FDTFluxStageKey> TackedStageKeys = {StageKey};
+			TrackedRequestStageRankings(TackedStageKeys);
+			OutStageRankings = FDTFluxStageRankings();
+			return false;
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
+	}
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey,
+                                                   FDTFluxSplitRankings& OutSplitRankings, const bool bShouldUseCached)
+{
+	//We Have the data
+	if (DataStorage->SplitRankings.Contains(SplitKey) && bShouldUseCached)
+	{
+		OutSplitRankings = DataStorage->SplitRankings[SplitKey];
+		return true;
+	}
+	else
+	{
+		if (NetworkSubsystem)
+		{
+			TArray<FDTFluxSplitKey> TackedSplitKey = {SplitKey};
+			TrackedRequestSplitRankings(TackedSplitKey);
+			OutSplitRankings = FDTFluxSplitRankings();
+			return false;
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
+		return false;
+	}
+}
+
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<int> ForContests)
 {
 	if (NetworkSubsystem)
 	{
-		NetworkSubsystem->SendRequest(EDTFluxRequestType::TeamList);
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("ContestRanking Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+				if (Request.ParsedResponse.IsSet())
+				{
+					ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
 				}
+			});
+
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("ContestRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto ContestId : ForContests)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::ContestRanking,
+				ContestId, -1, -1, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
 }

-void UDTFluxCoreSubsystem::SendRaceDataRequest()
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages)
 {
 	if (NetworkSubsystem)
 	{
-		NetworkSubsystem->SendRequest(EDTFluxRequestType::RaceData);
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+				if (Request.ParsedResponse.IsSet())
+				{
+					ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
 				}
+			});
+
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto StageKey : ForStages)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::StageRanking,
+				StageKey.ContestId, StageKey.StageId, -1, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
 }

-void UDTFluxCoreSubsystem::SendContestRankingRequest(int InContestId)
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits)
 {
 	if (NetworkSubsystem)
 	{
-		NetworkSubsystem->SendRequest(EDTFluxRequestType::ContestRanking, InContestId);
-	}
-}
-
-void UDTFluxCoreSubsystem::SendStageRankingRequest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking)
-{
-	// TODO Implement this
-}
-
-void UDTFluxCoreSubsystem::RequestAllStageRankingOfContest(int InContestId, int InStageId,
-                                                           bool bShouldIncludeSplitRanking)
-{
-	// TODO Implement this
-}
-
-void UDTFluxCoreSubsystem::SendSplitRankingRequest(int InContestId, int InStageId, int InSplitId)
-{
-	// TODO Implement this
-}
-
-void UDTFluxCoreSubsystem::RequestAllSplitRankingOfContest(int InContestId, int InStageId)
-{
-	// TODO Implement this
-}
-
-FDTFluxStageRankings UDTFluxCoreSubsystem::GetStageRankings(FDTFluxStageKey StageKey)
-{
-	if (DataStorage->StageRankings.Contains(StageKey))
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
 			{
-		return DataStorage->StageRankings[StageKey];
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+				if (Request.ParsedResponse.IsSet())
+				{
+					ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
 				}
-	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Cannot find StageRankings for key [%s]"), *StageKey.GetDisplayName());
-	return FDTFluxStageRankings();
-}
+			});

-void UDTFluxCoreSubsystem::RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId)
-{
-	// TODO Implement this
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto SplitKey : ForSplits)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::SplitRanking,
+				SplitKey.ContestId, SplitKey.StageId, SplitKey.SplitId, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
 }

 const FDTFluxParticipant UDTFluxCoreSubsystem::GetParticipant(int InBib)
@ -272,11 +471,6 @@ const FDTFluxParticipant UDTFluxCoreSubsystem::GetParticipant(int InBib)
 	return FDTFluxParticipant();
 }

-void UDTFluxCoreSubsystem::RefreshStorage()
-{
-	// TODO Implement this
-}
-
 TArray<int> UDTFluxCoreSubsystem::GetCurrentContestsId()
 {
 	return GetContestsIdForTime(FDateTime::Now());
@ -287,7 +481,7 @@ TArray<FDTFluxContest> UDTFluxCoreSubsystem::GetCurrentContests()
 	return GetContestsForTime(FDateTime::Now());
 }

-TArray<int> UDTFluxCoreSubsystem::GetContestsIdForTime(const FDateTime Time)
+TArray<int> UDTFluxCoreSubsystem::GetContestsIdForTime(const FDateTime Time) const
 {
 	TArray<int> Contests;
 	for (const auto& Pair : DataStorage->Contests)
--- a/Source/DTFluxCoreSubsystem/Private/DTFluxPursuitManager.cpp
+++ b/Source/DTFluxCoreSubsystem/Private/DTFluxPursuitManager.cpp
@ -0,0 +1,232 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "DTFluxPursuitManager.h"
+
+#include <ImportExport.h>
+
+#include "DTFluxCoreSubsystem.h"
+#include "DTFluxCoreSubsystemModule.h"
+
+UDTFluxPursuitManager::UDTFluxPursuitManager(const FObjectInitializer& ObjectInitializer):
+	Super(ObjectInitializer)
+{
+}
+
+void UDTFluxPursuitManager::InitPursuit(const TArray<int> InContestIds, const int MaxSimultaneousPursuit)
+{
+	CoreSubsystem = Cast<UDTFluxCoreSubsystem>(GetOuter());
+	if (!CoreSubsystem)
+	{
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
+		return;
+	}
+	AllRankings.Reset();
+	for (const auto& ContestId : InContestIds)
+	{
+		FDTFluxContest Contest;
+		if (CoreSubsystem->GetContestForId(ContestId, Contest))
+		{
+			BindRankings();
+			FDTFluxStageKey StageKey = FDTFluxStageKey(ContestId, Contest.GetLastStageId());
+			FDTFluxStageRankings TempStageRankings;
+			//Obtenir les ranking Frais.
+			CoreSubsystem->GetStageRankingsWithKey(StageKey, TempStageRankings, false);
+			PendingStageRanking.Add(StageKey, false);
+		}
+	}
+}
+
+void UDTFluxPursuitManager::SetPursuitInfoIsMassStart(FDTFluxPursuitGroup NextFocusGroup)
+{
+	for (auto& Pursuit : NextFocusGroup.PursuitGroup)
+	{
+		Pursuit.bIsMassStart = Pursuit.StartTime >= MassStartTime;
+	}
+}
+
+void UDTFluxPursuitManager::GetPursuit(TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext,
+                                       TArray<FDTFluxPursuitInfo>& OutPursuitNext, bool& BIsFocusTruncate,
+                                       const int MaxSimultaneousPursuit)
+{
+	if (MaxSimultaneousPursuit <= 0)
+	{
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("MaxSimultaneousPursuit must be > 0"));
+		OutPursuitFocusNext = TArray<FDTFluxPursuitInfo>();
+		OutPursuitNext = TArray<FDTFluxPursuitInfo>();
+		BIsFocusTruncate = false;
+		return;
+	}
+	if (bIsSequenceDone && MaxSimultaneousPursuit <= 0)
+	{
+		OutPursuitFocusNext = TArray<FDTFluxPursuitInfo>();
+		OutPursuitNext = TArray<FDTFluxPursuitInfo>();
+		BIsFocusTruncate = false;
+		return;
+	}
+	OutPursuitFocusNext.Reset();
+	OutPursuitNext.Reset();
+	if (!GroupedPursuit.IsEmpty())
+	{
+		FDTFluxPursuitGroup NextFocusGroup = GroupedPursuit[0];
+		GroupedPursuit.RemoveAt(0);
+		SetPursuitInfoIsMassStart(NextFocusGroup);
+		OutPursuitFocusNext = NextFocusGroup.PursuitGroup;
+		bFocusIsTruncate = NextFocusGroup.PursuitGroup.Num() > 1;
+		for (int RemainingPursuitNum = MaxSimultaneousPursuit - 1; RemainingPursuitNum != 0;)
+		{
+			if (!GroupedPursuit.IsEmpty())
+			{
+				FDTFluxPursuitGroup NextGroup = GroupedPursuit[0];
+				SetPursuitInfoIsMassStart(NextGroup);
+				if (NextGroup.PursuitGroup.Num() >= RemainingPursuitNum)
+				{
+					// extract the number we need
+					for (int i = 0; i < RemainingPursuitNum; i++)
+					{
+						FDTFluxPursuitInfo Pursuit = NextGroup.PursuitGroup[0];
+						OutPursuitNext.Add(Pursuit);
+					}
+					break;
+				}
+				else
+				{
+					OutPursuitNext.Append(NextGroup.PursuitGroup);
+					RemainingPursuitNum -= NextGroup.PursuitGroup.Num();
+				}
+			}
+			else
+			{
+				break;
+			}
+		}
+	}
+}
+
+bool UDTFluxPursuitManager::InitSubSystems()
+{
+	if (NetworkSubsystem)
+	{
+		return true;
+	}
+	NetworkSubsystem = GEngine->GetEngineSubsystem<UDTFluxNetworkSubsystem>();
+	return NetworkSubsystem != nullptr;
+}
+
+bool UDTFluxPursuitManager::BindRankings()
+{
+	if (CoreSubsystem)
+	{
+		if (!bIsRankingBounded)
+		{
+			CoreSubsystem->OnRequestedStageRankings.AddDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
+			bIsRankingBounded = true;
+		}
+		return bIsRankingBounded;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
+	return bIsRankingBounded = false;
+}
+
+void UDTFluxPursuitManager::UnbindRankings()
+{
+	if (CoreSubsystem)
+	{
+		if (bIsRankingBounded)
+		{
+			CoreSubsystem->OnRequestedStageRankings.RemoveDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
+			bIsRankingBounded = false;
+			return;
+		}
+	}
+	bIsRankingBounded = false;
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
+}
+
+void UDTFluxPursuitManager::OnRankingsReceived(const FDTFluxStageKey NewStageKey,
+                                               const FDTFluxStageRankings NewStageRankings)
+{
+	if (PendingStageRanking.Contains(NewStageKey))
+	{
+		PendingStageRanking.Remove(NewStageKey);
+		AllRankings.Add(NewStageRankings);
+		if (PendingStageRanking.IsEmpty())
+		{
+			//everything is ready to go compute and start
+			UnbindRankings();
+			LaunchPursuitSequence();
+		}
+	}
+}
+
+bool UDTFluxPursuitManager::LaunchPursuitSequence()
+{
+	GroupedPursuit.Empty();
+	TArray<FDTFluxPursuitInfo> AllPursuits;
+	TMap<FDateTime, FDTFluxPursuitGroup> TempGroups;
+	bIsSequenceDone = false;
+	// Full the Array Of Rankings
+	for (auto& Ranking : AllRankings)
+	{
+		for (auto StageRanking : Ranking.Rankings)
+		{
+			int ContestId = Ranking.ContestId;
+			FDTFluxPursuitInfo PursuitInfo;
+			PursuitInfo.StartTime = StageRanking.StartTime;
+			PursuitInfo.Bib = StageRanking.Bib;
+			PursuitInfo.ContestId = ContestId;
+			AllPursuits.Add(PursuitInfo);
+		}
+	}
+	for (auto& Pursuit : AllPursuits)
+	{
+		if (TempGroups.Contains(Pursuit.StartTime))
+		{
+			TempGroups[Pursuit.StartTime].PursuitGroup.Add(Pursuit);
+		}
+		else
+		{
+			FDTFluxPursuitGroup Group;
+			Group.StartTimeGlobal = Pursuit.StartTime;
+			Group.PursuitGroup.Add(Pursuit);
+			TempGroups.Add(Pursuit.StartTime, Group);
+		}
+	}
+	TempGroups.KeySort([](const FDateTime& A, const FDateTime& B)
+	{
+		return A < B;
+	});
+	TMap<FDateTime, int> StartTimeFrequency;
+	int32 MaxFrequency = 0;
+	GroupedPursuit.Reserve(TempGroups.Num());
+	for (const auto& Pair : TempGroups)
+	{
+		if (Pair.Value.StartTimeGlobal != FDateTime::MinValue() && Pair.Value.StartTimeGlobal != FDateTime::MaxValue())
+		{
+			StartTimeFrequency.FindOrAdd(Pair.Value.StartTimeGlobal)++;
+			const FDateTime& PropertyValue = Pair.Value.StartTimeGlobal; // Votre propriété
+			int32& Count = StartTimeFrequency.FindOrAdd(PropertyValue, 0);
+			Count++;
+			if (Count > MaxFrequency)
+			{
+				MaxFrequency = Count;
+				MassStartTime = PropertyValue;
+			}
+		}
+		GroupedPursuit.Add(Pair.Value);
+	}
+
+	GroupedPursuit.Sort([](const FDTFluxPursuitGroup& A, const FDTFluxPursuitGroup& B)
+	{
+		return A.StartTimeGlobal < B.StartTimeGlobal;
+	});
+
+	TArray<FDTFluxPursuitInfo> FocusPursuits;
+	TArray<FDTFluxPursuitInfo> NextPursuits;
+	bool bIsFocusTruncate = false;
+
+	GetPursuit(FocusPursuits, NextPursuits, bIsFocusTruncate);
+	FPursuitStaterData PursuitData = FPursuitStaterData(FocusPursuits, NextPursuits, MassStartTime, bIsFocusTruncate);
+	CoreSubsystem->OnPursuitSequenceReady.Broadcast(PursuitData);
+	return true;
+}
--- a/Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h
+++ b/Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h
@ -1,9 +1,8 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#pragma once
+#pragma once

 #include "CoreMinimal.h"
 #include "Containers/Deque.h"
+#include "Types/Struct/FDTFluxPursuitInfo.h"
 #include "Subsystems/EngineSubsystem.h"
 #include "Types/Struct/DTFluxRaceDataStructs.h"
 #include "Types/Struct/DTFluxTeamListStruct.h"
@ -15,88 +14,120 @@
 class UDTFluxNetworkSubsystem;
 /** Forward Decl */
 class UDTFluxModelAsset;
+class UDTFluxPursuitManager;
+struct FDTFluxServerResponse;
+
+USTRUCT(BlueprintType)
+struct FPursuitStaterData
+{
+	GENERATED_BODY()
+
+public:
+	FPursuitStaterData() = default;
+
+	FPursuitStaterData(const TArray<FDTFluxPursuitInfo>& InPursuitFocusNext,
+	                   const TArray<FDTFluxPursuitInfo>& InPursuitNext, const FDateTime& InMassStartTime,
+	                   const bool InIsFocusTruncate)
+		: PursuitFocusNext(InPursuitFocusNext), PursuitNext(InPursuitNext), MassStartTime(InMassStartTime),
+		  bIsFocusTruncate(InIsFocusTruncate)
+	{
+	};
+
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
+	TArray<FDTFluxPursuitInfo> PursuitFocusNext = TArray<FDTFluxPursuitInfo>();
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
+	TArray<FDTFluxPursuitInfo> PursuitNext = TArray<FDTFluxPursuitInfo>();
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
+	FDateTime MassStartTime = FDateTime::MinValue();
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
+	bool bIsFocusTruncate = false;
+};
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPursuitSequenceReady, const FPursuitStaterData, PursuitInfoSequenceItem);

 /**
 * 
 */
-UCLASS()
+UCLASS(BlueprintType, meta=(DisplayName="DTFlux Core Subsystem"))
 class DTFLUXCORESUBSYSTEM_API UDTFluxCoreSubsystem : public UEngineSubsystem
 {
 	GENERATED_BODY()

 public:
-	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitRankings, FDTFluxSplitRankings&, SplitRankings);
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitRankings, FDTFluxSplitRankings, SplitRankings);

 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnSplitRankings OnSplitRankings;
-
-	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnStageRankings, FDTFluxStageRankings&, StageRankings);
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnStageRankings, FDTFluxStageRankings, StageRankings);

 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnStageRankings OnStageRankings;
-
-	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnContestRankings, FDTFluxContestRankings&, ContestRankings);
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnContestRankings, FDTFluxContestRankings, ContestRankings);

 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnContestRankings OnContestRankings;
-
 	DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnTeamList);

 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnTeamList OnTeamList;
-
 	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnTeamStatusUpdate, FDTFluxParticipant, TeamUpdated);

 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnTeamStatusUpdate OnTeamStatusUpdate;

-	DECLARE_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey&, const FDTFluxContestRankings&);
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey, StageKey,
+	                                             const FDTFluxStageRankings, StageRankings);
+
+	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnRequestedStageRankings OnRequestedStageRankings;
-	//
-	// DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnTeamUpdate, FDateTime, ReceivedAt, FDTFluxParticipant, TeamUpdatedList);
-	// UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
-	// FOnTeamUpdate OnTeamUpdate;

+	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
+	FOnPursuitSequenceReady OnPursuitSequenceReady;

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void SendTeamListRequest();
+	bool GetContestRankings(const int ContestId, FDTFluxContestRankings& OutContestRankings);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void SendRaceDataRequest();
+	bool GetStageRankings(const int ContestId, const int StageId, FDTFluxStageRankings& OutStageRankings);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void SendContestRankingRequest(int InContestId);
+	bool GetSplitRankings(const int ContestId, const int StageId, const int SplitId,
+	                      FDTFluxSplitRankings& OutSplitRankings);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void SendStageRankingRequest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);
+	bool GetStageRankingsWithKey(const FDTFluxStageKey StageKey, FDTFluxStageRankings& OutStageRankings,
+	                             const bool bShouldUseCached = true);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void RequestAllStageRankingOfContest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);
+	bool GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey, FDTFluxSplitRankings& OutSplitRankings,
+	                             const bool bShouldUseCached = true);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void SendSplitRankingRequest(int InContestId, int InStageId, int InSplitId);
+	TArray<FGuid> TrackedRequestContestRankings(const TArray<int> ForContests);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void RequestAllSplitRankingOfContest(int InContestId, int InStageId);
+	TArray<FGuid> TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages);

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	FDTFluxStageRankings GetStageRankings(FDTFluxStageKey StageKey);
+	TArray<FGuid> TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits);

-	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId);
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
+	UDTFluxPursuitManager* PursuitManager = nullptr;

 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
 	const FDTFluxParticipant GetParticipant(int InBib);

-	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	void RefreshStorage();
+	//TODO : this must be a ProjectSetting
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
+	bool bShouldKeepRankings = true;

 	UFUNCTION()
 	TArray<int> GetCurrentContestsId();
 	UFUNCTION()
 	TArray<FDTFluxContest> GetCurrentContests();
 	UFUNCTION()
-	TArray<int> GetContestsIdForTime(const FDateTime Time);
+	TArray<int> GetContestsIdForTime(const FDateTime Time) const;
 	UFUNCTION()
 	bool GetContestForId(const int Id, FDTFluxContest& OutContest);
 	UFUNCTION()
@ -112,13 +143,15 @@ protected:
 	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
 	virtual void Deinitialize() override;
 	// ~Subsystem Interface
-
-
 	UFUNCTION()
 	void SaveDataStorage();
+	UFUNCTION()
+	void ProcessTrackedResponse(FDTFluxServerResponse& InResponse);

 private:
 	UDTFluxNetworkSubsystem* NetworkSubsystem = nullptr;
+	UPROPERTY()
+	UDTFluxModelAsset* DataStorage = nullptr;

 	UFUNCTION()
 	void ProcessRaceData(const FDTFluxRaceData& RaceDataDefinition);
@ -140,8 +173,4 @@ private:
 	void SendRequest(const FString& Message);
 	UFUNCTION()
 	void RegisterDelegates();
-
-
-	UPROPERTY()
-	UDTFluxModelAsset* DataStorage = nullptr;
 };
--- a/Source/DTFluxCoreSubsystem/Public/DTFluxPursuitManager.h
+++ b/Source/DTFluxCoreSubsystem/Public/DTFluxPursuitManager.h
@ -0,0 +1,134 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Subsystems/DTFluxNetworkSubsystem.h"
+#include "Types/Struct/DTFluxRaceDataStructs.h"
+#include "Types/Struct/FDTFluxPursuitInfo.h"
+#include "UObject/Object.h"
+#include "DTFluxPursuitManager.generated.h"
+
+
+class UDTFluxCoreSubsystem;
+
+USTRUCT()
+struct FRequestData
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TArray<FGuid> RequestIds;
+	UPROPERTY()
+	TMap<FGuid, FDTFluxStageRankings> StageRankings;
+	UPROPERTY()
+	int ContestId;
+
+	UPROPERTY()
+	bool bIsReady = false;
+
+
+	FRequestData() = default;
+
+	FRequestData(const TArray<FGuid>& InRequestIds, const TMap<FGuid, FDTFluxStageRankings>& InStageRankings)
+		: RequestIds(InRequestIds), StageRankings(InStageRankings), ContestId(-1)
+	{
+	};
+
+	/**
+	 * 
+	 * @param RequestId 
+	 * @param InRankings 
+	 * @return True if all needed requests have responses
+	 */
+	bool IsWaitingFor(const FGuid& RequestId, const FDTFluxStageRankings& InRankings)
+	{
+		if (!StageRankings.Contains(RequestId))
+		{
+			StageRankings.Add(RequestId, InRankings);
+		}
+		bIsReady = StageRankings.Num() <= RequestIds.Num();
+		return bIsReady;
+	}
+};
+
+USTRUCT()
+struct FDTFluxPursuitGroup
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TArray<FDTFluxPursuitInfo> PursuitGroup = TArray<FDTFluxPursuitInfo>();
+	UPROPERTY()
+	FDateTime StartTimeGlobal = FDateTime::MinValue();
+	UPROPERTY()
+	bool bHasStarted = false;
+	UPROPERTY()
+	bool bIsFocus = false;
+};
+
+
+/**
+ * 
+ */
+UCLASS(BlueprintType)
+class DTFLUXCORESUBSYSTEM_API UDTFluxPursuitManager : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	UDTFluxPursuitManager(const FObjectInitializer& ObjectInitializer);
+
+
+	UPROPERTY(BlueprintReadOnly, VisibleAnywhere)
+	bool bFocusIsTruncate = false;
+
+	UPROPERTY()
+	int PursuitMaxSimultaneousPursuit = 7;
+
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="DTFlux|Pursuit",
+		meta=(ClampMin="1", ClampMax="60", UIMin="0", UIMax="60"))
+	int MassStartDelay = 10;
+
+	UPROPERTY()
+	FDateTime MassStartTime = FDateTime::MinValue();
+
+	UPROPERTY()
+	TArray<FDTFluxPursuitGroup> GroupedPursuit;
+
+	UPROPERTY()
+	int CurrentIndex = -1;
+
+
+	UFUNCTION(BlueprintCallable, Category="DTFlux|Pursuit", meta=(Keywords="pursuit, launch, poursuite"))
+	void InitPursuit(const TArray<int> InContestIds, const int MaxSimultaneousPursuit = 7);
+
+	UFUNCTION(BlueprintCallable, Category="DTFlux|Pursuit", meta=(Keywords="pursuit, launch, poursuite"))
+	void GetPursuit(TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext, TArray<FDTFluxPursuitInfo>& OutPursuitNext,
+	                bool& BIsFocusTruncate, const int MaxSimultaneousPursuit = 7);
+
+	UFUNCTION()
+	bool InitSubSystems();
+
+	UFUNCTION()
+	bool BindRankings();
+
+	UFUNCTION()
+	void UnbindRankings();
+
+	UFUNCTION()
+	void OnRankingsReceived(const FDTFluxStageKey NewStageKey, const FDTFluxStageRankings NewStageRankings);
+
+private:
+	TMap<FDTFluxStageKey, bool> PendingStageRanking;
+	TArray<FDTFluxStageRankings> AllRankings;
+	UDTFluxCoreSubsystem* CoreSubsystem = nullptr;
+	UDTFluxNetworkSubsystem* NetworkSubsystem = nullptr;
+
+	UPROPERTY()
+	bool bIsSequenceDone = true;
+	UPROPERTY()
+	bool bIsRankingBounded = false;
+	UFUNCTION()
+	void SetPursuitInfoIsMassStart(FDTFluxPursuitGroup NextFocusGroup);
+	UFUNCTION()
+	bool LaunchPursuitSequence();
+};
--- a/Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp
+++ b/Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp
@ -0,0 +1,318 @@
+#include "DTFluxAsyncParser.h"
+
+#include "DTFluxNetworkModule.h"
+#include "Struct/DTFluxServerResponseStruct.h"
+#include "Async/AsyncWork.h"
+
+// ================================================================================================
+// IMPLÉMENTATION DE LA TÂCHE DE PARSING
+// ================================================================================================
+
+DECLARE_STATS_GROUP(TEXT("DTFlux"), STATGROUP_DTFlux, STATCAT_Advanced);
+
+DECLARE_CYCLE_STAT(TEXT("DTFlux Parsing Task"), STAT_FDTFluxParsingTask, STATGROUP_DTFlux);
+DECLARE_CYCLE_STAT(TEXT("DTFlux Parsing Task DoWork"), STAT_FDTFluxParsingTask_DoWork, STATGROUP_DTFlux);
+
+FDTFluxParsingTask::FDTFluxParsingTask(
+	const FGuid& InRequestId,
+	const FString& InRawJsonData,
+	FOnParsingCompleted InOnCompleted,
+	FOnParsingFailed InOnFailed
+)
+	: RequestId(InRequestId)
+	  , RawJsonData(InRawJsonData)
+	  , OnCompleted(InOnCompleted)
+	  , OnFailed(InOnFailed)
+	  , StartTime(FPlatformTime::Seconds())
+{
+}
+
+void FDTFluxParsingTask::DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
+{
+	SCOPE_CYCLE_COUNTER(STAT_FDTFluxParsingTask_DoWork);
+
+	UE_LOG(logDTFluxNetwork, VeryVerbose, TEXT("Starting async parsing for request %s"), *RequestId.ToString());
+
+	TSharedPtr<FDTFluxServerResponse> ParsedResponse;
+	bool bParsingSuccess = false;
+	FString ErrorMessage;
+
+	try
+	{
+		// === PARSING SUR LE THREAD WORKER ===
+
+		EDTFluxResponseStatus Status;
+		ParsedResponse = MakeShared<FDTFluxServerResponse>(RawJsonData, Status, false); // Pas de logs sur worker thread
+
+		if (Status == EDTFluxResponseStatus::Success)
+		{
+			bParsingSuccess = true;
+			UE_LOG(logDTFluxNetwork, VeryVerbose, TEXT("Async parsing successful for request %s"),
+			       *RequestId.ToString());
+		}
+		else
+		{
+			ErrorMessage = FString::Printf(TEXT("Parsing failed with status: %s"),
+			                               *UEnum::GetValueAsString(Status));
+			UE_LOG(logDTFluxNetwork, Warning, TEXT("Async parsing failed for request %s: %s"),
+			       *RequestId.ToString(), *ErrorMessage);
+		}
+	}
+	catch (const std::exception& e)
+	{
+		ErrorMessage = FString::Printf(TEXT("Exception during parsing: %s"), ANSI_TO_TCHAR(e.what()));
+		UE_LOG(logDTFluxNetwork, Error, TEXT("Exception during async parsing for request %s: %s"),
+		       *RequestId.ToString(), *ErrorMessage);
+	}
+	catch (...)
+	{
+		ErrorMessage = TEXT("Unknown exception during parsing");
+		UE_LOG(logDTFluxNetwork, Error, TEXT("Unknown exception during async parsing for request %s"),
+		       *RequestId.ToString());
+	}
+
+	const float ParsingTime = (FPlatformTime::Seconds() - StartTime) * 1000.0f; // En millisecondes
+
+	// === PROGRAMMER LA CALLBACK SUR LE MAIN THREAD ===
+
+	FFunctionGraphTask::CreateAndDispatchWhenReady(
+		[this, ParsedResponse, bParsingSuccess, ErrorMessage, ParsingTime]()
+		{
+			// Cette lambda s'exécute sur le main thread
+			if (bParsingSuccess && ParsedResponse.IsValid())
+			{
+				OnCompleted.ExecuteIfBound(RequestId, ParsedResponse, true);
+			}
+			else
+			{
+				OnFailed.ExecuteIfBound(RequestId, ErrorMessage);
+			}
+		},
+		TStatId(),
+		nullptr,
+		ENamedThreads::GameThread // Forcer l'exécution sur le main thread
+	);
+}
+
+// ================================================================================================
+// IMPLÉMENTATION DU PARSER ASYNCHRONE
+// ================================================================================================
+
+FDTFluxAsyncParser::FDTFluxAsyncParser()
+{
+	UE_LOG(logDTFluxNetwork, Log, TEXT("AsyncParser initialized"));
+}
+
+FDTFluxAsyncParser::~FDTFluxAsyncParser()
+{
+	CancelAllParsing();
+	UE_LOG(logDTFluxNetwork, Log, TEXT("AsyncParser destroyed"));
+}
+
+void FDTFluxAsyncParser::ParseResponseAsync(
+	const FGuid& RequestId,
+	const FString& RawJsonData,
+	FOnParsingCompleted OnCompleted,
+	FOnParsingFailed OnFailed)
+{
+	if (RawJsonData.IsEmpty())
+	{
+		OnFailed.ExecuteIfBound(RequestId, TEXT("Empty JSON data"));
+		return;
+	}
+	UE_LOG(logDTFluxNetwork, Verbose, TEXT("Starting async parsing for request %s"), *RequestId.ToString());
+
+	// Créer la tâche de parsing
+	FGraphEventRef Task = FFunctionGraphTask::CreateAndDispatchWhenReady(
+		[RequestId, RawJsonData, OnCompleted, OnFailed]()
+		{
+			// Ce code s'exécute sur le worker thread
+			const double StartTime = FPlatformTime::Seconds();
+
+			TSharedPtr<FDTFluxServerResponse> ParsedResponse;
+			bool bParsingSuccess = false;
+			FString ErrorMessage;
+
+			try
+			{
+				EDTFluxResponseStatus Status;
+				ParsedResponse = MakeShared<FDTFluxServerResponse>(RawJsonData, Status, false);
+
+				if (Status == EDTFluxResponseStatus::Success)
+				{
+					bParsingSuccess = true;
+				}
+				else
+				{
+					ErrorMessage = FString::Printf(TEXT("Parsing failed with status: %s"),
+					                               *UEnum::GetValueAsString(Status));
+				}
+			}
+			catch (const std::exception& e)
+			{
+				ErrorMessage = FString::Printf(TEXT("Exception during parsing: %s"), ANSI_TO_TCHAR(e.what()));
+			}
+			catch (...)
+			{
+				ErrorMessage = TEXT("Unknown exception during parsing");
+			}
+
+			const float ParsingTime = (FPlatformTime::Seconds() - StartTime) * 1000.0f;
+			FFunctionGraphTask::CreateAndDispatchWhenReady(
+				[RequestId, ParsedResponse, bParsingSuccess, ErrorMessage, OnCompleted, OnFailed]()
+				{
+					// Cette lambda s'exécute sur le main thread
+					if (bParsingSuccess && ParsedResponse.IsValid())
+					{
+						OnCompleted.ExecuteIfBound(RequestId, ParsedResponse, true);
+					}
+					else
+					{
+						OnFailed.ExecuteIfBound(RequestId, ErrorMessage);
+					}
+				},
+				TStatId(),
+				nullptr,
+				ENamedThreads::GameThread // Forcer main thread
+			);
+		},
+		TStatId(),
+		nullptr,
+		ENamedThreads::AnyBackgroundThreadNormalTask
+	);
+
+	// Tracker la tâche
+	{
+		FScopeLock Lock(&TasksLock);
+		ActiveTasks.Add(Task);
+	}
+
+	UE_LOG(logDTFluxNetwork, Verbose, TEXT("Queued async parsing task for request %s"), *RequestId.ToString());
+}
+
+TSharedPtr<FDTFluxServerResponse> FDTFluxAsyncParser::ParseResponseSync(
+	const FString& RawJsonData,
+	float TimeoutSeconds)
+{
+	if (RawJsonData.IsEmpty())
+	{
+		return nullptr;
+	}
+
+	// Variables pour la synchronisation
+	TSharedPtr<FDTFluxServerResponse> Result;
+	std::atomic<bool> bCompleted{false};
+
+	// Lancer le parsing async avec callback sync
+	FOnParsingCompleted OnCompleted = FOnParsingCompleted::CreateLambda(
+		[&Result, &bCompleted](const FGuid& RequestId, TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess)
+		{
+			if (bSuccess)
+			{
+				Result = ParsedResponse;
+			}
+			bCompleted.store(true);
+		}
+	);
+
+	FOnParsingFailed OnFailed = FOnParsingFailed::CreateLambda(
+		[&bCompleted](const FGuid& RequestId, const FString& ErrorMessage)
+		{
+			UE_LOG(logDTFluxNetwork, Warning, TEXT("Sync parsing failed: %s"), *ErrorMessage);
+			bCompleted.store(true);
+		}
+	);
+
+	FGuid TempId = FGuid::NewGuid();
+	ParseResponseAsync(TempId, RawJsonData, OnCompleted, OnFailed);
+
+	// Attendre avec timeout
+	const double StartTime = FPlatformTime::Seconds();
+	while (!bCompleted.load() && (FPlatformTime::Seconds() - StartTime) < TimeoutSeconds)
+	{
+		FPlatformProcess::Sleep(0.001f); // 1ms
+	}
+
+	return Result;
+}
+
+void FDTFluxAsyncParser::CancelAllParsing()
+{
+	FScopeLock Lock(&TasksLock);
+
+	for (const FGraphEventRef& Task : ActiveTasks)
+	{
+		// Note: On ne peut pas vraiment "cancel" une tâche TaskGraph en cours,
+		// mais on peut marquer qu'on ne veut plus les résultats
+	}
+
+	ActiveTasks.Empty();
+	UE_LOG(logDTFluxNetwork, Log, TEXT("Cancelled all pending parsing tasks"));
+}
+
+FDTFluxAsyncParser::FParsingStats FDTFluxAsyncParser::GetStats() const
+{
+	FScopeLock StatsLock_Local(&StatsLock);
+	FScopeLock TasksLock_Local(&TasksLock);
+
+	FParsingStats Stats;
+	Stats.TasksInProgress = ActiveTasks.Num();
+	Stats.TasksCompleted = TasksCompletedCount;
+	Stats.TasksFailed = TasksFailedCount;
+
+	if (ParsingTimes.Num() > 0)
+	{
+		float Sum = 0.0f;
+		for (float Time : ParsingTimes)
+		{
+			Sum += Time;
+		}
+		Stats.AverageParsingTimeMs = Sum / ParsingTimes.Num();
+	}
+
+	return Stats;
+}
+
+void FDTFluxAsyncParser::ResetStats()
+{
+	FScopeLock Lock(&StatsLock);
+	TasksCompletedCount = 0;
+	TasksFailedCount = 0;
+	ParsingTimes.Empty();
+}
+
+void FDTFluxAsyncParser::OnTaskCompleted(bool bSuccess, float ParsingTimeMs)
+{
+	FScopeLock Lock(&StatsLock);
+
+	if (bSuccess)
+	{
+		TasksCompletedCount++;
+	}
+	else
+	{
+		TasksFailedCount++;
+	}
+
+	ParsingTimes.Add(ParsingTimeMs);
+
+	// Garder seulement les 100 derniers temps pour la moyenne
+	if (ParsingTimes.Num() > 100)
+	{
+		ParsingTimes.RemoveAt(0);
+	}
+}
+
+void FDTFluxAsyncParser::CleanupCompletedTasks()
+{
+	FScopeLock Lock(&TasksLock);
+
+	for (auto It = ActiveTasks.CreateIterator(); It; ++It)
+	{
+		const FGraphEventRef& Task = *It;
+		if (Task.IsValid() && Task->IsComplete())
+		{
+			It.RemoveCurrent(); // Supprime l'élément actuel de manière sécurisée
+		}
+	}
+}
--- a/Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp
+++ b/Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp
--- a/Source/DTFluxNetwork/Private/Struct/DTFluxServerResponseStruct.cpp
+++ b/Source/DTFluxNetwork/Private/Struct/DTFluxServerResponseStruct.cpp
@ -1,6 +1,7 @@
-#pragma  once
+#include "Struct/DTFluxServerResponseStruct.h"
+#include "DTFluxNetworkModule.h"
+#include "Types/Objects/UDTFluxParticipantFactory.h"

-#include "Struct/DTFluxServerResponseStruct.h"

 // === IMPLÉMENTATION DES CONSTRUCTEURS ===

@ -194,7 +195,7 @@ FString FDTFluxServerResponse::ToDebugString() const
 		*UEnum::GetValueAsString(ParsingStatus), *Type, Code, ContestID, StageID, SplitID, *ReceivedAt.ToString());
 }

-bool FDTFluxServerResponse::ParseTeamListResponse(FDTFluxTeamListDefinition& OutTeamList)
+bool FDTFluxServerResponse::ParseTeamList(FDTFluxTeamListDefinition& OutTeamList)
 {
 	ParsingStatus = EDTFluxResponseStatus::Unset;
 	if (!ValidateResponseType(TEXT("team-list")))
@ -256,9 +257,9 @@ bool FDTFluxServerResponse::ParseTeamListResponse(FDTFluxTeamListDefinition& Out
 	return false;
 }

-bool FDTFluxServerResponse::ParseTeamUpdateResponse(FDTFluxTeamListDefinition& OutTeamUpdate)
+bool FDTFluxServerResponse::ParseTeamUpdate(FDTFluxTeamListDefinition& OutTeamUpdate)
 {
-	return ParseTeamListResponse(OutTeamUpdate);
+	return ParseTeamList(OutTeamUpdate);
 }

 bool FDTFluxServerResponse::ParseRaceData(FDTFluxRaceData& OutRaceData)
@ -368,15 +369,15 @@ bool FDTFluxServerResponse::ParseContestRanking(FDTFluxContestRankings& OutConte
 	return true;
 }

-bool FDTFluxServerResponse::ParseStageRankingResponse(FDTFluxStageRankings& OutStageRankings)
+bool FDTFluxServerResponse::ParseStageRanking(FDTFluxStageRankings& OutStageRankings)
 {
+	// UE_LOG(logDTFluxNetwork, Log, TEXT("Response is stage-ranking type %s"), *RawMessage);
 	if (!ValidateResponseType(TEXT("stage-ranking")))
 	{
 		UE_LOG(logDTFluxNetwork, Error, TEXT("Response is not a stage-ranking type"));
 		ParsingStatus = EDTFluxResponseStatus::InvalidType;
 		return false;
 	}
-
 	FDTFluxStageRankingResponse RankingResponse;
 	if (!FJsonObjectConverter::JsonObjectStringToUStruct<FDTFluxStageRankingResponse>(RawMessage, &RankingResponse))
 	{
@ -384,6 +385,7 @@ bool FDTFluxServerResponse::ParseStageRankingResponse(FDTFluxStageRankings& OutS
 		ParsingStatus = EDTFluxResponseStatus::JsonParseError;
 		return false;
 	}
+	UE_LOG(logDTFluxNetwork, Log, TEXT("Reponse Update"));

 	OutStageRankings.ContestId = ContestID;
 	OutStageRankings.StageId = StageID;
@ -395,7 +397,7 @@ bool FDTFluxServerResponse::ParseStageRankingResponse(FDTFluxStageRankings& OutS
 	return true;
 }

-bool FDTFluxServerResponse::ParseSplitRankingResponse(FDTFluxSplitRankings& OutSplitRankings)
+bool FDTFluxServerResponse::ParseSplitRanking(FDTFluxSplitRankings& OutSplitRankings)
 {
 	if (!ValidateResponseType(TEXT("stage-ranking")) || SplitID == -1)
 	{
@ -426,7 +428,7 @@ bool FDTFluxServerResponse::ParseSplitRankingResponse(FDTFluxSplitRankings& OutS
 	return true;
 }

-bool FDTFluxServerResponse::ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& OutStatusUpdate)
+bool FDTFluxServerResponse::ParseStatusUpdate(FDTFluxTeamStatusUpdate& OutStatusUpdate)
 {
 	if (!ValidateResponseType(TEXT("status-update")))
 	{
@ -447,7 +449,7 @@ bool FDTFluxServerResponse::ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& O
 	return true;
 }

-bool FDTFluxServerResponse::ParseSplitSensorResponse(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos)
+bool FDTFluxServerResponse::ParseSplitSensor(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos)
 {
 	if (!ValidateResponseType(TEXT("split-sensor")))
 	{
--- a/Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp
+++ b/Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp
--- a/Source/DTFluxNetwork/Public/DTFluxAsyncParser.h
+++ b/Source/DTFluxNetwork/Public/DTFluxAsyncParser.h
@ -0,0 +1,171 @@
+// ================================================================================================
+// DTFluxAsyncParser.h - Async Response Parser
+// ================================================================================================
+#pragma once
+
+#include "CoreMinimal.h"
+#include "HAL/CriticalSection.h"
+#include "Async/TaskGraphInterfaces.h"
+#include "Struct/DTFluxServerResponseStruct.h"
+
+// Forward declarations
+
+// ================================================================================================
+// DELEGATES POUR LE PARSING ASYNCHRONE
+// ================================================================================================
+
+DECLARE_DELEGATE_ThreeParams(FOnParsingCompleted, const FGuid& /*RequestId*/,
+                             TSharedPtr<FDTFluxServerResponse> /*ParsedResponse*/, bool /*bSuccess*/);
+DECLARE_DELEGATE_TwoParams(FOnParsingFailed, const FGuid& /*RequestId*/, const FString& /*ErrorMessage*/);
+
+// ================================================================================================
+// ASYNC PARSER - Délégation du parsing avec TaskGraph
+// ================================================================================================
+
+/**
+ * Gestionnaire centralisé pour le parsing asynchrone des réponses JSON
+ * Utilise le TaskGraph d'Unreal Engine pour déléguer le parsing sur des worker threads
+ */
+class DTFLUXNETWORK_API FDTFluxAsyncParser
+{
+public:
+	FDTFluxAsyncParser();
+	~FDTFluxAsyncParser();
+
+	// === INTERFACE PUBLIQUE ===
+
+	/**
+	 * Lancer le parsing asynchrone d'une réponse JSON
+	 * @param RequestId - ID de la requête pour le suivi
+	 * @param RawJsonData - Données JSON brutes à parser
+	 * @param OnCompleted - Callback appelé en cas de succès (sur main thread)
+	 * @param OnFailed - Callback appelé en cas d'échec (sur main thread)
+	 */
+	void ParseResponseAsync(
+		const FGuid& RequestId,
+		const FString& RawJsonData,
+		FOnParsingCompleted OnCompleted,
+		FOnParsingFailed OnFailed = FOnParsingFailed()
+	);
+
+	/**
+	 * Parsing synchrone avec timeout (pour les cas urgents)
+	 * @param RawJsonData - Données JSON à parser
+	 * @param TimeoutSeconds - Timeout maximum pour le parsing
+	 * @return Réponse parsée ou nullptr en cas d'échec
+	 */
+	TSharedPtr<FDTFluxServerResponse> ParseResponseSync(
+		const FString& RawJsonData,
+		float TimeoutSeconds = 1.0f
+	);
+
+	/**
+	 * Annuler toutes les tâches de parsing en attente
+	 */
+	void CancelAllParsing();
+
+	// === STATISTIQUES ===
+
+	/**
+	 * Statistiques de performance du parsing
+	 */
+	struct FParsingStats
+	{
+		int32 TasksInProgress = 0; // Tâches actuellement en cours
+		int32 TasksCompleted = 0; // Tâches terminées avec succès
+		int32 TasksFailed = 0; // Tâches échouées
+		float AverageParsingTimeMs = 0.0f; // Temps moyen de parsing en ms
+	};
+
+	/**
+	 * Obtenir les statistiques de parsing
+	 */
+	FParsingStats GetStats() const;
+
+	/**
+	 * Réinitialiser les statistiques
+	 */
+	void ResetStats();
+
+private:
+	// === TRACKING DES TÂCHES ===
+	mutable FCriticalSection TasksLock;
+	TSet<FGraphEventRef> ActiveTasks;
+
+	// === STATISTIQUES ===
+	mutable FCriticalSection StatsLock;
+	mutable int32 TasksCompletedCount = 0;
+	mutable int32 TasksFailedCount = 0;
+	mutable TArray<float> ParsingTimes; // Historique des temps de parsing
+
+	// === MÉTHODES PRIVÉES ===
+
+	/**
+	 * Callback appelé quand une tâche se termine
+	 * @param bSuccess - Succès ou échec de la tâche
+	 * @param ParsingTimeMs - Temps de parsing en millisecondes
+	 */
+	void OnTaskCompleted(bool bSuccess, float ParsingTimeMs);
+
+	/**
+	 * Nettoyer les tâches terminées de la liste active
+	 */
+	void CleanupCompletedTasks();
+};
+
+// ================================================================================================
+// TÂCHE DE PARSING POUR LE TASKGRAPH
+// ================================================================================================
+
+/**
+ * Tâche de parsing JSON exécutée sur un thread worker
+ * Compatible avec le TaskGraph d'Unreal Engine
+ */
+class FDTFluxParsingTask
+{
+public:
+	FDTFluxParsingTask(
+		const FGuid& InRequestId,
+		const FString& InRawJsonData,
+		FOnParsingCompleted InOnCompleted,
+		FOnParsingFailed InOnFailed
+	);
+
+	// === INTERFACE TASK GRAPH ===
+
+	FORCEINLINE TStatId GetStatId() const
+	{
+		RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxParsingTask, STATGROUP_TaskGraphTasks);
+	}
+
+	static FORCEINLINE TStatId GetStatId_DoWork()
+	{
+		RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxParsingTask_DoWork, STATGROUP_TaskGraphTasks);
+	}
+
+	static FORCEINLINE ENamedThreads::Type GetDesiredThread()
+	{
+		// Exécuter sur un thread worker (pas le main thread)
+		return ENamedThreads::AnyBackgroundThreadNormalTask;
+	}
+
+	static FORCEINLINE ESubsequentsMode::Type GetSubsequentsMode()
+	{
+		return ESubsequentsMode::TrackSubsequents;
+	}
+
+	// === EXÉCUTION DE LA TÂCHE ===
+
+	/**
+	 * Méthode principale d'exécution de la tâche
+	 * Appelée automatiquement par le TaskGraph sur un worker thread
+	 */
+	void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent);
+
+private:
+	FGuid RequestId;
+	FString RawJsonData;
+	FOnParsingCompleted OnCompleted;
+	FOnParsingFailed OnFailed;
+	double StartTime;
+};
--- a/Source/DTFluxNetwork/Public/DTFluxQueuedManager.h
+++ b/Source/DTFluxNetwork/Public/DTFluxQueuedManager.h
@ -1,166 +1,444 @@
-// Fill out your copyright notice in the Description page of Project Settings.
+// ================================================================================================
+// DTFluxRequestManager.h - Gestionnaire C++ optimisé avec cache, timeout et retry
+// ================================================================================================

 #pragma once

 #include "CoreMinimal.h"
-#include "UObject/Object.h"
-#include "Containers/Queue.h"
 #include "Tickable.h"
-#include "Struct/DTFluxRequestStructs.h"
+#include "HAL/CriticalSection.h"
 #include "Struct/DTFluxServerResponseStruct.h"
 #include "Types/Enum/DTFluxCoreEnum.h"
 #include "DTFluxQueuedManager.generated.h"

-/**
- * @brief Structure représentant une requête en file d'attente avec ses métadonnées
- */
+class FDTFluxAsyncParser;
+
+
+// ================================================================================================
+// ENUMS ET STRUCTURES POUR LES REQUÊTES
+// ================================================================================================
+
+UENUM(BlueprintType)
+enum class EDTFluxRequestState : uint8
+{
+	Pending UMETA(DisplayName = "Pending"),
+	Sent UMETA(DisplayName = "Sent"),
+	Completed UMETA(DisplayName = "Completed"),
+	Failed UMETA(DisplayName = "Failed"),
+	TimedOut UMETA(DisplayName = "TimedOut"),
+	Cached UMETA(DisplayName = "Cached"),
+	Retrying UMETA(DisplayName = "Retrying")
+};
+
 USTRUCT(BlueprintType)
-struct FDTFluxQueuedRequest : public FDTFluxRequestBase
+struct DTFLUXNETWORK_API FDTFluxRequestConfig
 {
 	GENERATED_BODY()

-	/** L'identifiant unique de la requête */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
-	FGuid RequestId;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	float TimeoutSeconds = 5.0f;

-	/** L'heure à laquelle la requête a été envoyée */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
-	FDateTime CreatedAt;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	int32 MaxRetries = 3;

-	/** Le type de requête */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
-	EDTFluxApiDataType RequestType = EDTFluxRequestType::None;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	float RetryBackoffMultiplier = 1.5f;

-	/** Identifiant de la compétition (ContestId) */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	bool bEnableCache = true;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	float CacheValiditySeconds = 60.0f;
+};
+
+USTRUCT(BlueprintType)
+struct DTFLUXNETWORK_API FDTFluxTrackedRequest
+{
+	GENERATED_BODY()
+
+	// === IDENTIFICATION ===
+	UPROPERTY(BlueprintReadOnly)
+	FGuid RequestId = FGuid::NewGuid();
+
+	UPROPERTY(BlueprintReadOnly)
+	EDTFluxApiDataType RequestType = EDTFluxApiDataType::None;
+
+	UPROPERTY(BlueprintReadOnly)
 	int32 ContestId = -1;

-	/** Identifiant de l'étape (StageId) */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	UPROPERTY(BlueprintReadOnly)
 	int32 StageId = -1;

-	/** Identifiant du split (SplitId) */
-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	UPROPERTY(BlueprintReadOnly)
 	int32 SplitId = -1;

-	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
-	FString RawResponse = "";
+	// === ÉTAT ET TIMING ===
+	UPROPERTY(BlueprintReadOnly)
+	EDTFluxRequestState State = EDTFluxRequestState::Pending;

-	/** Délai maximum avant que la requête soit considérée comme expirée (en secondes) */
-	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
-	float TimeoutSeconds = 2.0f;
+	UPROPERTY(BlueprintReadOnly)
+	FDateTime CreatedAt = FDateTime::Now();

-	/** Determine si la requête peut être mise en cache */
-	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
-	bool bIsCacheable = false;
+	UPROPERTY(BlueprintReadOnly)
+	FDateTime SentAt = FDateTime::MinValue();

-	/** Validité du cache si bIsCacheable est mis à true après reception de la réponse (en secondes) */
-	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
-	float CachedValidity = 50.0f;
+	UPROPERTY(BlueprintReadOnly)
+	FDateTime CompletedAt = FDateTime::MinValue();

-	/** Indicateur si la requête a reçu une réponse */
-	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
-	bool bHasReceivedResponse = false;
+	UPROPERTY(BlueprintReadOnly)
+	FDateTime LastAttemptTime = FDateTime::Now();

-	/** Constructeur par défaut */
-	FDTFluxQueuedRequest()
-	{
-		RequestId = FGuid::NewGuid();
-		CreatedAt = FDateTime::Now();
-	}
+	// === CONFIGURATION ===
+	FDTFluxRequestConfig Config;

-	/** Constructeur avec paramètres */
-	FDTFluxQueuedRequest(EDTFluxRequestType InRequestType, int32 InContestId = -1, int32 InStageId = -1,
-	                     int32 InSplitId = -1)
-		: RequestType(InRequestType)
-		  , ContestId(InContestId)
-		  , StageId(InStageId)
-		  , SplitId(InSplitId)
-	{
-		RequestId = FGuid::NewGuid();
-		CreatedAt = FDateTime::Now();
-	}
+	// === RETRY LOGIC ===
+	UPROPERTY(BlueprintReadOnly)
+	int32 CurrentRetries = 0;

-	bool operator==(const FDTFluxQueuedRequest& Left) const
-	{
-		return RequestId == Left.RequestId;
-	}
+	// === DONNÉES DE RÉPONSE ===
+	UPROPERTY(BlueprintReadOnly)
+	FString RawResponseData;

-	bool operator!=(const FDTFluxQueuedRequest& Left) const
-	{
-		return RequestId != Left.RequestId;
-	}
+	// Réponse parsée (lazy loading)
+	mutable TOptional<TSharedPtr<FDTFluxServerResponse>> ParsedResponse;

+	UPROPERTY(BlueprintReadOnly)
+	bool bIsResponseParsed = false;

-	const FString Serialize() const;
+	UPROPERTY(BlueprintReadOnly)
+	FString LastErrorMessage;

-	/** Vérifie si la requête a expiré */
-	bool HasTimedOut() const
-	{
-		return (FDateTime::Now() - CreatedAt).GetTotalSeconds() > TimeoutSeconds;
-	}
+	// === MÉTHODES UTILITAIRES ===

-
-	/** Vérifie si cette requête correspond aux paramètres spécifiés */
-	bool Matches(EDTFluxRequestType InRequestType, int32 InContestId = -1, int32 InStageId = -1,
-	             int32 InSplitId = -1) const
-	{
-		return RequestType == InRequestType &&
-			(InContestId == -1 || ContestId == InContestId) &&
-			(InStageId == -1 || StageId == InStageId) &&
-			(InSplitId == -1 || SplitId == InSplitId);
-	}
+	bool HasTimedOut() const;
+	bool CanRetry() const;
+	bool IsCacheValid() const;
+	float GetRetryDelay() const;
+	bool Matches(EDTFluxApiDataType InType, int32 InContestId = -1, int32 InStageId = -1, int32 InSplitId = -1) const;
+	FString GetCacheKey() const;
+	void SetRawResponse(const FString& RawData);
+	FString Serialize() const;
 };

-DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRequestTimedOut, const FDTFluxQueuedRequest&, TimedOutRequest);
+// ================================================================================================
+// DELEGATES POUR LES CALLBACKS
+// ================================================================================================
+
+DECLARE_DELEGATE_OneParam(FOnDTFluxRequestSuccess, const FDTFluxTrackedRequest&);
+DECLARE_DELEGATE_TwoParams(FOnDTFluxRequestError, const FDTFluxTrackedRequest&, const FString& /*ErrorMessage*/);
+
+DECLARE_MULTICAST_DELEGATE_TwoParams(FOnRequestStateChangedNative, const FGuid& /*RequestId*/,
+                                     EDTFluxRequestState& /*NewState*/);
+DECLARE_MULTICAST_DELEGATE_OneParam(FOnRequestCompletedNative, const FDTFluxTrackedRequest& /*CompletedRequest*/);
+DECLARE_MULTICAST_DELEGATE_OneParam(FOnRequestFailedNative, const FDTFluxTrackedRequest& /*FailedRequest*/);
+
+// ================================================================================================
+// REQUEST MANAGER - Classe C++ principale avec SmartPointers
+// ================================================================================================

 /**
- * @brief Classe Tickable gérant les requêtes WebSockets qui ne sont pas traçables nativement par l'API.
- * Cette classe utilise TQueue pour gérer efficacement les requêtes en attente et vérifie leur état dans le tick.
+ * Gestionnaire de requêtes trackées avec cache, timeout, retry et parsing asynchrone
+ * Implémentation C++ pure avec SmartPointers pour des performances optimales
 */
-UCLASS()
-class DTFLUXNETWORK_API UDTFluxQueuedManager : public UObject, public FTickableGameObject
+class DTFLUXNETWORK_API FDTFluxQueuedRequestManager : public FTickableGameObject
 {
-	GENERATED_BODY()
-
 public:
-	/** Constructeur par défaut */
-	UDTFluxQueuedManager();
-	virtual ~UDTFluxQueuedManager() override;
-	void Initialize();
-	FGuid QueueRequest(EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1, int32 SplitId = -1,
-	                   const FString& RawMessage = "");
-	bool MarkRequestAsResponded(const FGuid& TargetRequestGuid);
-	bool MarkRequestAsResponded(const FDTFluxQueuedRequest& TargetRequest);
-	bool IsRequestPending(EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1, int32 SplitId = -1);
-	FDTFluxQueuedRequest* GetRequestPending(EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1,
-	                                        int32 SplitId = -1);
-	const FDTFluxQueuedRequest* GetRequest(const FGuid& SearchedGuid);
-	int32 GetPendingRequestCount();
-	int32 CleanupTimedOutRequests();
-	int32 CleanCashedRequests();
+	FDTFluxQueuedRequestManager();
+	virtual ~FDTFluxQueuedRequestManager();
+
+	// === LIFECYCLE ===
+
+	/**
+	 * Initialiser le gestionnaire de requêtes
+	 * @param DefaultConfig Configuration par défaut pour les nouvelles requêtes
+	 */
+	void Initialize(const FDTFluxRequestConfig& DefaultConfig = FDTFluxRequestConfig());
+
+	/**
+	 * Arrêter le gestionnaire et nettoyer toutes les ressources
+	 */
+	void Shutdown();
+
+	/**
+	 * Vérifier si le gestionnaire est initialisé
+	 */
+	bool IsInitialized() const { return bIsInitialized.load(); }
+
+	// === CRÉATION DE REQUÊTES ===
+
+	/**
+	 * Créer une nouvelle requête trackée
+	 * @param RequestType Type de requête (ContestRanking, StageRanking, etc.)
+	 * @param ContestId ID du contest (-1 si non applicable)
+	 * @param StageId ID du stage (-1 si non applicable)  
+	 * @param SplitId ID du split (-1 si non applicable)
+	 * @param CustomConfig Configuration spécifique pour cette requête
+	 * @return GUID de la requête créée
+	 */
+	FGuid CreateTrackedRequest(
+		EDTFluxApiDataType RequestType,
+		int32 ContestId = -1,
+		int32 StageId = -1,
+		int32 SplitId = -1,
+		const FDTFluxRequestConfig& CustomConfig = FDTFluxRequestConfig()
+	);
+
+	/**
+	 * Créer une requête trackée avec callbacks C++
+	 * @param RequestType Type de requête
+	 * @param ContestId ID du contest
+	 * @param StageId ID du stage
+	 * @param SplitId ID du split
+	 * @param OnSuccess Callback appelé en cas de succès
+	 * @param OnError Callback appelé en cas d'erreur
+	 * @param CustomConfig Configuration spécifique
+	 * @return GUID de la requête créée
+	 */
+	FGuid CreateTrackedRequestWithCallbacks(
+		EDTFluxApiDataType RequestType,
+		int32 ContestId,
+		int32 StageId,
+		int32 SplitId,
+		FOnDTFluxRequestSuccess OnSuccess,
+		FOnDTFluxRequestError OnError,
+		const FDTFluxRequestConfig& CustomConfig = FDTFluxRequestConfig()
+	);
+
+	// === GESTION DES REQUÊTES ===
+
+	/**
+	 * Marquer une requête comme envoyée
+	 */
+	bool MarkRequestAsSent(const FGuid& RequestId);
+
+	/**
+	 * Compléter une requête avec la réponse reçue
+	 * @param RequestId ID de la requête
+	 * @param RawResponseData Données JSON brutes de la réponse
+	 * @param bUseAsyncParsing Utiliser le parsing asynchrone (recommandé)
+	 */
+	bool CompleteRequest(const FGuid& RequestId, const FString& RawResponseData, bool bUseAsyncParsing = true);
+
+	/**
+	 * Marquer une requête comme échouée
+	 */
+	bool FailRequest(const FGuid& RequestId, const FString& ErrorMessage);
+
+	/**
+	 * Relancer une requête (si retry possible)
+	 */
+	bool RetryRequest(const FGuid& RequestId);
+
+	// === RECHERCHE ET CACHE ===
+
+	/**
+	 * Chercher une requête en attente correspondant aux critères
+	 */
+	bool FindPendingRequest(
+		FGuid& OutRequestId,
+		EDTFluxApiDataType RequestType,
+		int32 ContestId = -1,
+		int32 StageId = -1,
+		int32 SplitId = -1
+	) const;
+
+	/**
+	 * Récupérer une réponse depuis le cache (données brutes)
+	 */
+	bool GetFromCache(
+		EDTFluxApiDataType RequestType,
+		FString& OutRawResponse,
+		int32 ContestId = -1,
+		int32 StageId = -1,
+		int32 SplitId = -1
+	) const;
+
+	/**
+	 * Récupérer une réponse parsée depuis le cache
+	 */
+	bool GetParsedFromCache(
+		EDTFluxApiDataType RequestType,
+		TSharedPtr<FDTFluxServerResponse>& OutResponse,
+		int32 ContestId = -1,
+		int32 StageId = -1,
+		int32 SplitId = -1
+	) const;
+
+	// === ACCESSEURS ===
+
+	/**
+	 * Récupérer une requête par son ID
+	 */
+	bool GetRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const;
+
+	/**
+	 * Récupérer un pointeur vers une requête (plus efficace)
+	 */
+	const FDTFluxTrackedRequest* GetRequestPtr(const FGuid& RequestId) const;
+
+	/**
+	 * Récupérer toutes les requêtes dans un état donné
+	 */
+	TArray<FDTFluxTrackedRequest> GetRequestsByState(EDTFluxRequestState State) const;
+
+	/**
+	 * Compter les requêtes dans un état donné
+	 */
+	int32 GetRequestCount(EDTFluxRequestState State = EDTFluxRequestState::Pending) const;
+
+	// === STATISTIQUES ===
+
+	/**
+	 * Statistiques complètes du gestionnaire de requêtes
+	 */
+	struct FRequestStatistics
+	{
+		int32 Pending = 0;
+		int32 Cached = 0;
+		int32 Completed = 0;
+		int32 Failed = 0;
+		int32 TotalRequests = 0;
+		int32 CacheHits = 0;
+		int32 CacheMisses = 0;
+		float HitRate = 0.0f;
+	};
+
+	FRequestStatistics GetStatistics() const;
+
+	// === NETTOYAGE ===
+
+	/**
+	 * Nettoyer les entrées de cache expirées
+	 * @return Nombre d'entrées supprimées
+	 */
+	int32 CleanupExpiredCache();
+
+	/**
+	 * Nettoyer les requêtes terminées anciennes
+	 * @param OlderThanSeconds Supprimer les requêtes plus anciennes que ce délai
+	 * @return Nombre de requêtes supprimées
+	 */
+	int32 CleanupCompletedRequests(float OlderThanSeconds = 300.0f);
+
+	/**
+	 * Vider toutes les requêtes et le cache
+	 */
 	void ClearAllRequests();
-	// bool TryProcessResponse(const FDTFluxServerResponse& Response);

+	// === EVENTS ===
+
+	FOnRequestStateChangedNative OnRequestStateChanged;
+	FOnRequestCompletedNative OnRequestCompleted;
+	FOnRequestFailedNative OnRequestFailed;
+
+	// === INTERFACE TICKABLE ===

-	// Interface FTickableGameObject
 	virtual void Tick(float DeltaTime) override;
-	virtual bool IsTickable() const override;
-	virtual TStatId GetStatId() const override;
+	virtual bool IsTickable() const override { return true; };
+
+	virtual TStatId GetStatId() const override
+	{
+		RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxQueuedRequestManager, STATGROUP_Tickables);
+	};
 	virtual bool IsTickableWhenPaused() const override { return true; }
 	virtual bool IsTickableInEditor() const override { return true; }
-	// Interface ~FTickableGameObject

-
-	UPROPERTY(BlueprintAssignable, Category = "DTFlux|Network")
-	FOnRequestTimedOut OnRequestTimedOut;
+	// === ACCESSEUR POUR LE PARSER (debug/stats) ===
+	const FDTFluxAsyncParser* GetAsyncParser() const { return AsyncParser.Get(); }

 private:
-	TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> PendingRequestsQueue;
-	TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> CompletedRequestsQueue;
-	TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> TimedOutRequestsQueue;
+	// === CONFIGURATION ===
+	FDTFluxRequestConfig DefaultConfig;
+	std::atomic<bool> bIsInitialized{false};

-	bool bIsInitialized;
-	float CheckInterval;
-	float TimeSinceLastCheck;
+	// === TIMING POUR LE TICK ===
+	float TimeSinceLastTimeoutCheck = 0.0f;
+	float TimeSinceLastCacheCleanup = 0.0f;
+	float TimeSinceLastRetryCheck = 0.0f;
+
+	static constexpr float TimeoutCheckInterval = 1.0f;
+	static constexpr float CacheCleanupInterval = 30.0f;
+	static constexpr float RetryCheckInterval = 0.5f;
+
+	// === STOCKAGE THREAD-SAFE ===
+	mutable FCriticalSection RequestsLock;
+	TMap<FGuid, TSharedPtr<FDTFluxTrackedRequest>> AllRequests;
+	TMap<FString, FGuid> CacheKeyToRequestId;
+
+	// === CALLBACKS C++ ===
+	mutable FCriticalSection CallbacksLock;
+	TMap<FGuid, FOnDTFluxRequestSuccess> SuccessCallbacks;
+	TMap<FGuid, FOnDTFluxRequestError> ErrorCallbacks;
+
+	// === MÉTRIQUES ===
+	mutable FCriticalSection MetricsLock;
+	mutable int32 TotalRequests = 0;
+	mutable int32 CacheHits = 0;
+	mutable int32 CacheMisses = 0;
+
+
+	// === PARSER ASYNCHRONE ===
+	TUniquePtr<FDTFluxAsyncParser> AsyncParser;
+
+	// === MÉTHODES PRIVÉES ===
+
+	/**
+	 * Changer l'état d'une requête et notifier les observers
+	 */
+	void ChangeRequestState(TSharedPtr<FDTFluxTrackedRequest> Request, EDTFluxRequestState NewState);
+
+	/**
+	 * Traiter les requêtes en timeout (appelé périodiquement)
+	 */
+	void ProcessTimeouts();
+
+	/**
+	 * Traiter les requêtes à relancer (appelé périodiquement)
+	 */
+	void ProcessRetries();
+
+	/**
+	 * Nettoyer le cache périodiquement
+	 */
+	void ProcessCacheCleanup();
+
+	/**
+	 * Déclencher les callbacks pour une requête
+	 */
+	void TriggerCallbacks(const FDTFluxTrackedRequest& Request);
+
+	/**
+	 * Nettoyer les callbacks d'une requête
+	 */
+	void CleanupCallbacks(const FGuid& RequestId);
+
+	/**
+	 * Enregistrer un hit cache dans les métriques
+	 */
+	void RecordCacheHit() const;
+
+	/**
+	 * Enregistrer un miss cache dans les métriques
+	 */
+	void RecordCacheMiss() const;
+
+
+	// === CALLBACKS POUR LE PARSING ASYNCHRONE ===
+
+	/**
+	 * Callback appelé quand le parsing asynchrone réussit
+	 */
+	void OnParsingCompleted(const FGuid& RequestId, TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess);
+
+	/**
+	 * Callback appelé quand le parsing asynchrone échoue
+	 */
+	void OnParsingFailed(const FGuid& RequestId, const FString& ErrorMessage);
+
+	// === UTILITAIRES STATIQUES ===
+
+	/**
+	 * Générer une clé de cache unique pour une requête
+	 */
+	static FString GenerateCacheKey(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId, int32 SplitId);
 };
--- a/Source/DTFluxNetwork/Public/Struct/DTFluxRequestStructs.h
+++ b/Source/DTFluxNetwork/Public/Struct/DTFluxRequestStructs.h
@ -3,6 +3,7 @@
 #pragma once

 #include "CoreMinimal.h"
+#include "Types/Enum/DTFluxCoreEnum.h"
 #include "UObject/Object.h"
 #include "DTFluxRequestStructs.generated.h"

@ -139,3 +140,104 @@ public:
 		SplitID = InSplitId;
 	}
 };
+
+/**
+ * @brief Structure représentant une requête en file d'attente avec ses métadonnées
+ */
+USTRUCT(BlueprintType)
+struct FDTFluxQueuedRequest : public FDTFluxRequestBase
+{
+	GENERATED_BODY()
+
+	/** L'identifiant unique de la requête */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	FGuid RequestId;
+
+	/** L'heure à laquelle la requête a été envoyée */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	FDateTime CreatedAt;
+
+	/** Le type de requête */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	EDTFluxApiDataType RequestType = EDTFluxRequestType::None;
+
+	/** Identifiant de la compétition (ContestId) */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	int32 ContestId = -1;
+
+	/** Identifiant de l'étape (StageId) */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	int32 StageId = -1;
+
+	/** Identifiant du split (SplitId) */
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	int32 SplitId = -1;
+
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Request")
+	FString RawResponse = "";
+
+	/** Délai maximum avant que la requête soit considérée comme expirée (en secondes) */
+	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
+	float TimeoutSeconds = 2.0f;
+
+	/** Determine si la requête peut être mise en cache */
+	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
+	bool bIsCacheable = false;
+
+	/** Validité du cache si bIsCacheable est mis à true après reception de la réponse (en secondes) */
+	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
+	float CachedValidity = 50.0f;
+
+	/** Indicateur si la requête a reçu une réponse */
+	UPROPERTY(BlueprintReadWrite, Category = "DTFlux|Request")
+	bool bHasReceivedResponse = false;
+
+	/** Constructeur par défaut */
+	FDTFluxQueuedRequest()
+	{
+		RequestId = FGuid::NewGuid();
+		CreatedAt = FDateTime::Now();
+	}
+
+	/** Constructeur avec paramètres */
+	FDTFluxQueuedRequest(EDTFluxRequestType InRequestType, int32 InContestId = -1, int32 InStageId = -1,
+	                     int32 InSplitId = -1)
+		: RequestType(InRequestType)
+		  , ContestId(InContestId)
+		  , StageId(InStageId)
+		  , SplitId(InSplitId)
+	{
+		RequestId = FGuid::NewGuid();
+		CreatedAt = FDateTime::Now();
+	}
+
+	bool operator==(const FDTFluxQueuedRequest& Left) const
+	{
+		return RequestId == Left.RequestId;
+	}
+
+	bool operator!=(const FDTFluxQueuedRequest& Left) const
+	{
+		return RequestId != Left.RequestId;
+	}
+
+
+	const FString Serialize() const;
+
+	/** Vérifie si la requête a expiré */
+	bool HasTimedOut() const
+	{
+		return (FDateTime::Now() - CreatedAt).GetTotalSeconds() > TimeoutSeconds;
+	}
+
+
+	/** Vérifie si cette requête correspond aux paramètres spécifiés */
+	bool Matches(EDTFluxRequestType InRequestType, int32 InContestId = -1, int32 InStageId = -1,
+	             int32 InSplitId = -1) const
+	{
+		return RequestType == InRequestType &&
+			(InContestId == -1 || ContestId == InContestId) &&
+			(InStageId == -1 || StageId == InStageId) &&
+			(InSplitId == -1 || SplitId == InSplitId);
+	}
+};
--- a/Source/DTFluxNetwork/Public/Struct/DTFluxServerResponseStruct.h
+++ b/Source/DTFluxNetwork/Public/Struct/DTFluxServerResponseStruct.h
@ -4,13 +4,11 @@

 #include "CoreMinimal.h"
 #include "UObject/Object.h"
-#include "DTFluxNetworkModule.h"
 #include "DTFluxRaceDataServerResponse.h"
 #include "DTFluxRankingServerResponse.h"
 #include "DTFluxSplitSensorServerResponse.h"
 #include "JsonObjectConverter.h"
 #include "Types/Enum/DTFluxCoreEnum.h"
-#include "Types/Objects/UDTFluxParticipantFactory.h"
 #include "Types/Struct/DTFluxRaceDataStructs.h"
 #include "Types/Struct/DTFluxRankingStructs.h"
 #include "Types/Struct/DTFluxSplitSensor.h"
@ -85,14 +83,14 @@ public:

 	EDTFluxResponseStatus TryParse(bool bLogErrors = true);

-	bool ParseTeamListResponse(FDTFluxTeamListDefinition& OutTeamList);
-	bool ParseTeamUpdateResponse(FDTFluxTeamListDefinition& OutTeamUpdate);
+	bool ParseTeamList(FDTFluxTeamListDefinition& OutTeamList);
+	bool ParseTeamUpdate(FDTFluxTeamListDefinition& OutTeamUpdate);
 	bool ParseRaceData(FDTFluxRaceData& OutRaceData);
 	bool ParseContestRanking(FDTFluxContestRankings& OutContestRankings);
-	bool ParseStageRankingResponse(FDTFluxStageRankings& OutStageRankings);
-	bool ParseSplitRankingResponse(FDTFluxSplitRankings& OutSplitRankings);
-	bool ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& OutStatusUpdate);
-	bool ParseSplitSensorResponse(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);
+	bool ParseStageRanking(FDTFluxStageRankings& OutStageRankings);
+	bool ParseSplitRanking(FDTFluxSplitRankings& OutSplitRankings);
+	bool ParseStatusUpdate(FDTFluxTeamStatusUpdate& OutStatusUpdate);
+	bool ParseSplitSensor(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);


 	// === MÉTHODES UTILITAIRES ===
@ -117,4 +115,27 @@ private:
 	bool ParseJsonObject(TSharedPtr<FJsonObject>& OutJsonObject) const;
 	bool ValidateResponseType(const FString& ExpectedType) const;
 	EDTFluxResponseStatus InitializeFromJson(const FString& JsonMessage, bool bLogErrors);
+
+	static FString GetJsonType(const EJson Type)
+	{
+		switch (Type)
+		{
+		case EJson::None:
+			return TEXT("None");
+		case EJson::Null:
+			return TEXT("Null");
+		case EJson::String:
+			return TEXT("String");
+		case EJson::Number:
+			return TEXT("Number");
+		case EJson::Boolean:
+			return TEXT("Boolean");
+		case EJson::Array:
+			return TEXT("Array");
+		case EJson::Object:
+			return TEXT("Object");
+		default:
+			return TEXT("Unknown");
+		}
+	}
 };
--- a/Source/DTFluxNetwork/Public/Subsystems/DTFluxNetworkSubsystem.h
+++ b/Source/DTFluxNetwork/Public/Subsystems/DTFluxNetworkSubsystem.h
@ -1,40 +1,54 @@
-// Fill out your copyright notice in the Description page of Project Settings.
+// ================================================================================================
+// DTFluxNetworkSubsystem.h - Interface UObject avec compatibilité Blueprint
+// ================================================================================================

 #pragma once

 #include "CoreMinimal.h"
-#include "DTFluxQueuedManager.h"
-#include "Struct/DTFluxServerResponseStruct.h"
 #include "Subsystems/EngineSubsystem.h"
 #include "Types/DTFluxNetworkSettingsTypes.h"
 #include "Types/Enum/DTFluxCoreEnum.h"
-#include "Types/Struct/DTFluxRaceDataStructs.h"
-#include "Types/Struct/DTFluxRankingStructs.h"
-#include "Types/Struct/DTFluxSplitSensor.h"
-#include "Types/Struct/DTFluxTeamListStruct.h"
+#include "DTFluxQueuedManager.h"
 #include "DTFluxNetworkSubsystem.generated.h"

-
+// Forward declarations
 class FDTFluxWebSocketClient;
-class UDTFluxQueuedManager;
+class FDTFluxQueuedRequestManager;
+
 typedef TSharedPtr<FDTFluxWebSocketClient> FDTFluxWebSocketClientSP;
-class FDTFluxHttpClient;
-typedef TSharedPtr<FDTFluxHttpClient> FDTFluxHttpClientSP;

+// ================================================================================================
+// DELEGATES BLUEPRINT POUR LES REQUÊTES TRACKÉES
+// ================================================================================================

-// Delegates pour les requêtes avec callback
-DECLARE_DELEGATE_TwoParams(FOnDTFluxRequestResponse, const FGuid&, const FString&);
-DECLARE_DELEGATE_TwoParams(FOnDTFluxRequestTimeout, const FGuid&, const FString&);
-// Delegates Blueprint pour les requêtes avec tracking
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnDTFluxTrackedRequestCompleted, const FGuid&, RequestId,
                                               EDTFluxApiDataType, RequestType, const FString&, ResponseData);

 DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnDTFluxTrackedRequestFailed, const FGuid&, RequestId,
                                               EDTFluxApiDataType, RequestType, const FString&, ErrorMessage);

+// ================================================================================================
+// DELEGATES LEGACY POUR LA COMPATIBILITÉ
+// ================================================================================================
+
+DECLARE_DELEGATE_OneParam(FOnRaceDataReceived, const FDTFluxRaceData& /*RaceDataDefinition*/);
+DECLARE_DELEGATE_OneParam(FOnTeamListReceived, const FDTFluxTeamListDefinition& /*TeamListDefinition*/);
+DECLARE_DELEGATE_OneParam(FOnStageRankingReceived, const FDTFluxStageRankings& /*StageRankings*/);
+DECLARE_DELEGATE_OneParam(FOnSplitRankingReceived, const FDTFluxSplitRankings& /*SplitRankings*/);
+DECLARE_DELEGATE_OneParam(FOnContestRankingReceived, const FDTFluxContestRankings& /*ContestRankings*/);
+DECLARE_DELEGATE_OneParam(FOnSplitSensorReceived, const FDTFluxSplitSensorInfo& /*SplitSensorInfo*/);
+DECLARE_DELEGATE_OneParam(FOnTeamUpdateReceived, const FDTFluxTeamListDefinition& /*ParticipantToUpdate*/);
+DECLARE_DELEGATE_OneParam(FOnTeamStatusUpdateReceived, const FDTFluxTeamStatusUpdate& /*TeamToUpdate*/);
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWebSocketConnected);
+
+// ================================================================================================
+// NETWORK SUBSYSTEM - Interface UObject avec compatibilité Blueprint
+// ================================================================================================

 /**
- * 
+ * Subsystem réseau DTFlux avec support complet des requêtes trackées et compatibilité legacy
+ * Combine l'efficacité du RequestManager C++ avec l'interface Blueprint UObject
 */
 UCLASS(Blueprintable)
 class DTFLUXNETWORK_API UDTFluxNetworkSubsystem : public UEngineSubsystem
@ -42,174 +56,236 @@ class DTFLUXNETWORK_API UDTFluxNetworkSubsystem : public UEngineSubsystem
 	GENERATED_BODY()

 public:
-	UPROPERTY()
+	// === ÉTAT DE CONNEXION ===
+	UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Network")
 	EDTFluxConnectionStatus WsStatus = EDTFluxConnectionStatus::Unset;

-	DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWebSocketConnected);
+	// === CONNEXION WEBSOCKET (Legacy) ===

-	UPROPERTY(BlueprintAssignable, Category="DTFlux|Network")
-	FOnWebSocketConnected OnWebSocketConnected;
-
-	DECLARE_DELEGATE_OneParam(FOnRaceDataReceived, const FDTFluxRaceData& /*RaceDataDefinition*/);
-	FOnRaceDataReceived OnRaceDataReceived;
-
-	FOnRaceDataReceived& OnReceivedRaceData()
-	{
-		return OnRaceDataReceived;
-	};
-
-	// === DELEGATES POUR LES DONNÉES REÇUES (PUSH) ===
-	DECLARE_DELEGATE_OneParam(FOnTeamListReceived, const FDTFluxTeamListDefinition& /*TeamListDefinition*/);
-	FOnTeamListReceived OnTeamListReceived;
-
-	FOnTeamListReceived& OnReceivedTeamList()
-	{
-		return OnTeamListReceived;
-	};
-
-	DECLARE_DELEGATE_OneParam(FOnStageRankingReceived, const FDTFluxStageRankings& /*StageRankings*/);
-	FOnStageRankingReceived OnStageRankingReceived;
-
-	FOnStageRankingReceived& OnReceivedStageRanking()
-	{
-		return OnStageRankingReceived;
-	}
-
-	DECLARE_DELEGATE_OneParam(FOnSplitRankingReceived, const FDTFluxSplitRankings& /*SplitRankings*/);
-	FOnSplitRankingReceived OnSplitRankingReceived;
-
-	FOnSplitRankingReceived& OnReceivedSplitRanking()
-	{
-		return OnSplitRankingReceived;
-	}
-
-	DECLARE_DELEGATE_OneParam(FOnContestRankingReceived, const FDTFluxContestRankings& /*ContestRankings*/);
-	FOnContestRankingReceived OnContestRankingReceived;
-
-	FOnContestRankingReceived& OnReceivedContestRanking()
-	{
-		return OnContestRankingReceived;
-	};
-
-	// === DELEGATES POUR LES DONNÉES REÇUES (PULL) ===
-	DECLARE_DELEGATE_OneParam(FOnSplitSensorReceived, const FDTFluxSplitSensorInfo& /*ContestRankings*/);
-	FOnSplitSensorReceived OnSplitSensorReceived;
-
-	FOnSplitSensorReceived& OnReceivedSplitSensor()
-	{
-		return OnSplitSensorReceived;
-	};
-
-	DECLARE_DELEGATE_OneParam(FOnTeamUpdateReceived, const FDTFluxTeamListDefinition& /*ParticipantToUpdate*/);
-	FOnTeamUpdateReceived OnTeamUpdateReceived;
-
-	FOnTeamUpdateReceived& OnReceivedTeamUpdate()
-	{
-		return OnTeamUpdateReceived;
-	};
-
-	DECLARE_DELEGATE_OneParam(FOnTeamStatusUpdateReceived, const FDTFluxTeamStatusUpdate& /*TeamToUpdate*/);
-	FOnTeamStatusUpdateReceived OnTeamStatusUpdateReceived;
-
-	FOnTeamStatusUpdateReceived& OnReceivedTeamStatusUpdate()
-	{
-		return OnTeamStatusUpdateReceived;
-	};
-
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
+	/**
+	 * Se connecter au serveur WebSocket
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
 	void Connect();
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
+
+	/**
+	 * Se déconnecter du serveur WebSocket
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
 	void Disconnect();
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
+
+	/**
+	 * Reconnecter au serveur WebSocket
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
 	void Reconnect();

+	// === REQUÊTES TRACKÉES (Nouveau système optimisé) ===

-	// === REQUÊTES AVEC QUEUE ET TRACKING ===
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
-	FGuid SendTrackedRequest(EDTFluxApiDataType RequestType, int32 ContestId = -1, int32 StageId = -1,
-	                         int32 SplitId = -1, float TimeoutSeconds = 30.0f);
-	FGuid SendTrackedRequestWithCallback(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId, int32 SplitId,
-	                                     FOnDTFluxRequestResponse OnCompleted, FOnDTFluxRequestTimeout OnTimeout,
-	                                     float TimeoutSeconds = 30.0f);
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
-	bool GetTrackedRequest(const FGuid& RequestId, FDTFluxQueuedRequest& OutRequest) const;
-	const FDTFluxQueuedRequest* GetTrackedRequestPtr(const FGuid& RequestId) const;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests", CallInEditor)
+	/**
+	 * Envoyer une requête trackée avec cache, timeout et retry
+	 * @param RequestType Type de requête (ContestRanking, StageRanking, etc.)
+	 * @param ContestId ID du contest (-1 si non applicable)
+	 * @param StageId ID du stage (-1 si non applicable)
+	 * @param SplitId ID du split (-1 si non applicable)
+	 * @param TimeoutSeconds Timeout en secondes
+	 * @param MaxRetries Nombre maximum de tentatives
+	 * @param bEnableCache Activer le cache pour cette requête
+	 * @return GUID de la requête pour le suivi
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
+	FGuid SendTrackedRequest(
+		EDTFluxApiDataType RequestType,
+		int32 ContestId = -1,
+		int32 StageId = -1,
+		int32 SplitId = -1,
+		float TimeoutSeconds = 5.0f,
+		int32 MaxRetries = 3,
+		bool bEnableCache = true
+	);
+
+	/**
+	 * Envoyer une requête trackée avec callbacks C++ (non Blueprint)
+	 * @param RequestType Type de requête
+	 * @param ContestId ID du contest
+	 * @param StageId ID du stage
+	 * @param SplitId ID du split
+	 * @param OnSuccess Callback appelé en cas de succès
+	 * @param OnError Callback appelé en cas d'erreur
+	 * @param TimeoutSeconds Timeout en secondes
+	 * @param MaxRetries Nombre maximum de tentatives
+	 * @param bEnableCache Activer le cache
+	 * @return GUID de la requête
+	 */
+	FGuid SendTrackedRequestWithCallbacks(
+		EDTFluxApiDataType RequestType,
+		int32 ContestId,
+		int32 StageId,
+		int32 SplitId,
+		FOnDTFluxRequestSuccess& OnSuccess,
+		FOnDTFluxRequestError& OnError,
+		float TimeoutSeconds = 5.0f,
+		int32 MaxRetries = 3,
+		bool bEnableCache = true
+	);
+
+	// === ACCESSEURS BLUEPRINT POUR LES REQUÊTES TRACKÉES ===
+
+	/**
+	 * Récupérer une requête trackée par son ID
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
+	bool GetTrackedRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const;
+
+	/**
+	 * Vérifier si une requête a reçu une réponse
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
 	bool HasRequestReceivedResponse(const FGuid& RequestId) const;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
+
+	/**
+	 * Récupérer les données de réponse d'une requête
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
 	FString GetRequestResponseData(const FGuid& RequestId) const;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
+
+	/**
+	 * Vérifier si une requête similaire est en attente
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
 	bool IsRequestPending(EDTFluxApiDataType RequestType, int32 ContestId = -1, int32 StageId = -1,
 	                      int32 SplitId = -1) const;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
+
+	/**
+	 * Compter le nombre de requêtes en attente
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
 	int32 GetPendingRequestCount() const;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
-	UDTFluxQueuedManager* GetQueueManager() const;

-	// === EVENTS BLUEPRINT POUR LE TRACKING ===
-	UPROPERTY(BlueprintAssignable, Category="DTFlux|Tracked Requests")
-	FOnDTFluxTrackedRequestCompleted OnTrackedRequestCompleted;
-	UPROPERTY(BlueprintAssignable, Category="DTFlux|Tracked Requests")
-	FOnDTFluxTrackedRequestFailed OnTrackedRequestFailed;
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
+	/**
+	 * Récupérer les statistiques du gestionnaire de requêtes
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
+	void GetRequestStatistics(int32& OutPending, int32& OutCached, int32& OutCompleted, int32& OutFailed,
+	                          float& OutHitRate) const;

-	// === REQUÊTES DIRECTES (LEGACY) ===
+	// === REQUÊTES LEGACY (Compatibilité totale) ===
+
+	/**
+	 * Envoyer une requête en mode legacy (pour compatibilité)
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Legacy")
 	void SendRequest(const EDTFluxApiDataType RequestType, int InContestId = -1, int InStageId = -1,
 	                 int InSplitId = -1);
-	UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
+
+	/**
+	 * Envoyer un message brut via WebSocket
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
 	void SendMessage(const FString& Message);

+	// === EVENTS BLUEPRINT ===
+
+	/**
+	 * Event déclenché lors de la connexion WebSocket
+	 */
+	UPROPERTY(BlueprintAssignable, Category = "DTFlux|Network")
+	FOnWebSocketConnected OnWebSocketConnected;
+
+	/**
+	 * Event déclenché quand une requête trackée se termine avec succès
+	 */
+	UPROPERTY(BlueprintAssignable, Category = "DTFlux|Tracked Requests")
+	FOnDTFluxTrackedRequestCompleted OnTrackedRequestCompleted;
+
+	/**
+	 * Event déclenché quand une requête trackée échoue
+	 */
+	UPROPERTY(BlueprintAssignable, Category = "DTFlux|Tracked Requests")
+	FOnDTFluxTrackedRequestFailed OnTrackedRequestFailed;
+
+	// === DELEGATES LEGACY (Compatibilité totale) ===
+
+	FOnRaceDataReceived OnRaceDataReceived;
+	FOnTeamListReceived OnTeamListReceived;
+	FOnStageRankingReceived OnStageRankingReceived;
+	FOnSplitRankingReceived OnSplitRankingReceived;
+	FOnContestRankingReceived OnContestRankingReceived;
+	FOnSplitSensorReceived OnSplitSensorReceived;
+	FOnTeamUpdateReceived OnTeamUpdateReceived;
+	FOnTeamStatusUpdateReceived OnTeamStatusUpdateReceived;
+
+	// Accesseurs pour la compatibilité legacy
+	FOnRaceDataReceived& OnReceivedRaceData() { return OnRaceDataReceived; }
+	FOnTeamListReceived& OnReceivedTeamList() { return OnTeamListReceived; }
+	FOnStageRankingReceived& OnReceivedStageRanking() { return OnStageRankingReceived; }
+	FOnSplitRankingReceived& OnReceivedSplitRanking() { return OnSplitRankingReceived; }
+	FOnContestRankingReceived& OnReceivedContestRanking() { return OnContestRankingReceived; }
+	FOnSplitSensorReceived& OnReceivedSplitSensor() { return OnSplitSensorReceived; }
+	FOnTeamUpdateReceived& OnReceivedTeamUpdate() { return OnTeamUpdateReceived; }
+	FOnTeamStatusUpdateReceived& OnReceivedTeamStatusUpdate() { return OnTeamStatusUpdateReceived; }
+
+	// === ACCESSEUR PUBLIC POUR LE REQUEST MANAGER ===
+
+	/**
+	 * Accéder au gestionnaire de requêtes (pour usage avancé)
+	 */
+	TSharedPtr<FDTFluxQueuedRequestManager> GetRequestManager() const { return RequestManager; }
+
 protected:
-	// ~Subsystem Interface
+	// === LIFECYCLE DU SUBSYSTEM ===
 	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
 	virtual void Deinitialize() override;
-	// ~Subsystem Interface
-

 private:
 	// === CONFIGURATION ===
 	FDTFluxWsSettings WsSettings;
-	FDTFluxHttpSettings HttpSettings;
-
-	UPROPERTY()
-	UDTFluxQueuedManager* QueueManager;
-
-	// === MAPPING DES CALLBACKS C++ ===
-	TMap<FGuid, FOnDTFluxRequestResponse> PendingCallbacks;
-	TMap<FGuid, FOnDTFluxRequestTimeout> PendingTimeoutCallbacks;

 	// === CLIENTS RÉSEAU ===
 	FDTFluxWebSocketClientSP WsClient = nullptr;
-	FDTFluxHttpClientSP HttpClient = nullptr;

-	// === MÉTHODES DE CONFIGURATION ===
-	UFUNCTION()
-	void WsSettingsChanged(const FDTFluxWsSettings& NewWsSettings);
-	UFUNCTION()
-	void HttpSettingsChanged(const FDTFluxHttpSettings& NewHttpSettings);
-	void ReconnectWs(const FName WsClientId);
-	void ReconnectHttp(const FName WsClientId);
+	// === REQUEST MANAGER C++ ===
+	TSharedPtr<FDTFluxQueuedRequestManager> RequestManager;

 	// === GESTION DES ÉVÉNEMENTS WEBSOCKET ===
 	void RegisterWebSocketEvents();
 	void UnregisterWebSocketEvents();
-
 	void OnWebSocketConnected_Subsystem();
 	void OnWebSocketConnectionError_Subsystem(const FString& Error);
 	void OnWebSocketClosedEvent_Subsystem(int32 StatusCode, const FString& Reason, bool bWasClean);
+	void OnWebSocketMessageEvent_Subsystem(const FString& MessageString);
+	void OnWebSocketMessageSentEvent_Subsystem(const FString& MessageSent);

+	// Handles pour les événements WebSocket
 	FDelegateHandle OnWsConnectedEventDelegateHandle;
 	FDelegateHandle OnWsConnectionErrorEventDelegateHandle;
 	FDelegateHandle OnWsClosedEventDelegateHandle;
 	FDelegateHandle OnWsMessageEventDelegateHandle;
 	FDelegateHandle OnWsMessageSentEventDelegateHandle;

-	// === GESTION DES ÉVÉNEMENTS HTTP ===
-	void RegisterHttpEvents();
-	void UnregisterHttpEvents();
+	// === PARSING ET TRAITEMENT DES RÉPONSES ===

-	// === PARSING DES RÉPONSES ===
-	void ParseTeamListResponse(FDTFluxServerResponse& ServerResponse);
+	/**
+	 * Essayer de matcher une réponse à une requête trackée
+	 * @param MessageString Message JSON reçu
+	 * @return true si la réponse correspond à une requête trackée
+	 */
+	bool TryMatchResponseToQueuedRequest(const FString& MessageString);
+
+	/**
+	 * Traiter une réponse en mode legacy
+	 * @param MessageString Message JSON à traiter
+	 */
+	void ProcessLegacyResponse(const FString& MessageString);
+
+	/**
+	 * Traiter une réponse déjà parsée
+	 * @param ParsedResponse Réponse parsée à traiter
+	 */
+	void ProcessParsedResponse(TSharedPtr<FDTFluxServerResponse> ParsedResponse);
+
+	// === MÉTHODES DE PARSING LEGACY (pour compatibilité) ===
+	void ParseTeamListResponse(FDTFluxServerResponse& Response);
 	void ParseRaceData(FDTFluxServerResponse& Response);
 	void ParseContestRanking(FDTFluxServerResponse& Response);
 	void ParseStageRankingResponse(FDTFluxServerResponse& Response);
@ -218,18 +294,45 @@ private:
 	void ParseSplitSensorResponse(FDTFluxServerResponse& Response);
 	EDTFluxResponseStatus ProcessPushMessage(FDTFluxServerResponse& Response);

-	void Parse(FDTFluxServerResponse& Response);
-	void OnWebSocketMessageEvent_Subsystem(const FString& MessageString);
-	void OnWebSocketMessageSentEvent_Subsystem(const FString& MessageSent);
+	// === CALLBACKS POUR LE REQUEST MANAGER ===

-	// === GESTION DES REQUÊTES TRACKÉES ===
+	/**
+	 * Callback appelé quand une requête trackée se termine
+	 */
+	void OnRequestCompleted_Internal(const FDTFluxTrackedRequest& CompletedRequest);
+
+	/**
+	 * Callback appelé quand une requête trackée échoue
+	 */
+	void OnRequestFailed_Internal(const FDTFluxTrackedRequest& FailedRequest);
+
+	// === CONFIGURATION DYNAMIQUE ===
+
+	/**
+	 * Callback appelé quand les paramètres WebSocket changent
+	 */
 	UFUNCTION()
-	void OnRequestTimedOut_Internal(const FDTFluxQueuedRequest& TimedOutRequest);
-	bool TryMatchResponseToQueuedRequest(const FDTFluxServerResponse& Response);
-	void CompleteTrackedRequest(const FGuid& RequestId, const FString& ResponseData, EDTFluxRequestType RequestType);
-	void FailTrackedRequest(const FGuid& RequestId, const FString& ErrorMessage, EDTFluxRequestType RequestType);
-	void SendQueuedRequest(const FDTFluxQueuedRequest& QueuedRequest);
+	void WsSettingsChanged(const FDTFluxWsSettings& NewWsSettings);
+
+	/**
+	 * Reconnecter le client WebSocket
+	 */
+	void ReconnectWs(const FName WsClientId);

 	// === UTILITAIRES ===
+
+	/**
+	 * Construire une adresse WebSocket complète
+	 */
 	static FString ConstructWsAddress(const FString& Address, const FString& Path, const int& Port);
+
+	/**
+	 * Envoyer une requête trackée via le réseau
+	 */
+	void SendQueuedRequest(const FDTFluxTrackedRequest& QueuedRequest);
+
+	/**
+	 * Déterminer si on doit utiliser le parsing asynchrone
+	 */
+	bool ShouldUseAsyncParsing(const FString& JsonData) const;
 };
--- a/Source/DTFluxPursuitSystem/DTFluxPursuitSystem.Build.cs
+++ b/Source/DTFluxPursuitSystem/DTFluxPursuitSystem.Build.cs
@ -1,28 +0,0 @@
-using UnrealBuildTool;
-
-public class DTFluxPursuitSystem : ModuleRules
-{
-	public DTFluxPursuitSystem(ReadOnlyTargetRules Target) : base(Target)
-	{
-		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
-
-		PublicDependencyModuleNames.AddRange(
-			new string[]
-			{
-				"Core"
-			}
-		);
-
-		PrivateDependencyModuleNames.AddRange(
-			new string[]
-			{
-				"CoreUObject",
-				"Engine",
-				"Slate",
-				"SlateCore",
-				"DTFluxCore",
-				"DTFluxCoreSubsystem"
-			}
-		);
-	}
-}
--- a/Source/DTFluxPursuitSystem/Private/DTFluxPursuitSystemModule.cpp
+++ b/Source/DTFluxPursuitSystem/Private/DTFluxPursuitSystemModule.cpp
@ -1,19 +0,0 @@
-#include "DTFluxPursuitSystemModule.h"
-
-#define LOCTEXT_NAMESPACE "FDTFluxPursuitSystemModule"
-
-DEFINE_LOG_CATEGORY(logDTFluxPursuitSystem);
-
-void FDTFluxPursuitSystem::StartupModule()
-{
-    
-}
-
-void FDTFluxPursuitSystem::ShutdownModule()
-{
-    
-}
-
-#undef LOCTEXT_NAMESPACE
-    
-IMPLEMENT_MODULE(FDTFluxPursuitSystem, DTFluxPursuitSystem)
--- a/Source/DTFluxPursuitSystem/Public/DTFluxPursuitSystemModule.h
+++ b/Source/DTFluxPursuitSystem/Public/DTFluxPursuitSystemModule.h
@ -1,13 +0,0 @@
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Modules/ModuleManager.h"
-
-DECLARE_LOG_CATEGORY_EXTERN(logDTFluxPursuitSystem, All, All)
-
-class DTFLUXPURSUITSYSTEM_API FDTFluxPursuitSystem : public IModuleInterface
-{
-public:
-    virtual void StartupModule() override;
-    virtual void ShutdownModule() override;
-};
--- a/Source/DTFluxUtilities/DTFluxUtilities.Build.cs
+++ b/Source/DTFluxUtilities/DTFluxUtilities.Build.cs
@ -20,7 +20,8 @@ public class DTFluxUtilities : ModuleRules
 				"Engine",
 				"Slate",
 				"SlateCore",
-				"DTFluxCore"
+				"DTFluxCore",
+				"DTFluxCoreSubsystem",
 			}
 		);
 	}
Author	SHA1	Message	Date
Ange-Marie MAURIN	d92ca63ea4	Add TrackedRequest implementation in DTFluxCoreSubsystem and various Modifications and bugfixes.	2025-07-11 23:45:23 +02:00
Ange-Marie MAURIN	f1f300a351	Fixing Various Bugs On Delegates	2025-07-11 19:04:37 +02:00
Ange-Marie MAURIN	73413e44b4	implement Pursuit Sequence Logic	2025-07-11 13:09:18 +02:00
Ange-Marie MAURIN	bc6a928312	Switching DTFluxApi Tab Implementation to use the more modern UToolMenus approach API	2025-07-10 20:35:06 +02:00
Ange-Marie MAURIN	03eb1132ef	Added Pursuit functionality (Untested and not fully implemented) + Global TrackedRequestSending check	2025-07-09 03:27:23 +02:00