Removed CachedRequest functionality + Fixed(Tested) PursuitSequence bug

Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp

@@ -364,7 +364,7 @@ bool UDTFluxCoreSubsystem::GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKe
 	}
 }
 
-TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<int> ForContests)
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<int> ForContests, bool bEnableCache)
 {
 	if (NetworkSubsystem)
 	{
@@ -390,7 +390,7 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<i
 		for (auto ContestId : ForContests)
 		{
 			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::ContestRanking,
-				ContestId, -1, -1, OnSuccess, OnError);
+				ContestId, -1, -1, OnSuccess, OnError, bEnableCache);
 			RequestIds.Add(ContestRequest);
 		}
 		return RequestIds;
@@ -398,7 +398,8 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<i
 	return TArray<FGuid>();
 }
 
-TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages)
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages,
+                                                                bool bEnableCache)
 {
 	if (NetworkSubsystem)
 	{
@@ -424,7 +425,7 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDT
 		for (auto StageKey : ForStages)
 		{
 			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::StageRanking,
-				StageKey.ContestId, StageKey.StageId, -1, OnSuccess, OnError);
+				StageKey.ContestId, StageKey.StageId, -1, OnSuccess, OnError, bEnableCache);
 			RequestIds.Add(ContestRequest);
 		}
 		return RequestIds;
@@ -432,7 +433,8 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDT
 	return TArray<FGuid>();
 }
 
-TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits)
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits,
+                                                                bool bEnableCache)
 {
 	if (NetworkSubsystem)
 	{
@@ -458,7 +460,7 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDT
 		for (auto SplitKey : ForSplits)
 		{
 			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::SplitRanking,
-				SplitKey.ContestId, SplitKey.StageId, SplitKey.SplitId, OnSuccess, OnError);
+				SplitKey.ContestId, SplitKey.StageId, SplitKey.SplitId, OnSuccess, OnError, bEnableCache);
 			RequestIds.Add(ContestRequest);
 		}
 		return RequestIds;

Source/DTFluxCoreSubsystem/Private/DTFluxPursuitManager.cpp

@@ -45,61 +45,136 @@ void UDTFluxPursuitManager::SetPursuitInfoIsMassStart(FDTFluxPursuitGroup NextFo
 	}
 }
 
+void UDTFluxPursuitManager::DebugFocusNext(const TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext)
+{
+	FString FocusBibs;
+	for (const auto& Pursuit : OutPursuitFocusNext)
+	{
+		FocusBibs += FString::Printf(TEXT("%d "), Pursuit.Bib);
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Focus Bibs: %s"), *FocusBibs);
+}
+
+void UDTFluxPursuitManager::DebugOutPoursuitNext(const TArray<FDTFluxPursuitInfo>& OutPursuitNext)
+{
+	FString NextBibs;
+	for (int32 i = 0; i < OutPursuitNext.Num(); i++)
+	{
+		NextBibs += FString::Printf(TEXT("%d "), OutPursuitNext[i].Bib);
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Next Bibs: %s"), *NextBibs);
+}
+
 void UDTFluxPursuitManager::GetPursuit(TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext,
                                        TArray<FDTFluxPursuitInfo>& OutPursuitNext, bool& BIsFocusTruncate,
                                        const int MaxSimultaneousPursuit)
 {
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("=== GetPursuit CALLED ==="));
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("MaxSimultaneousPursuit: %d"), MaxSimultaneousPursuit);
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Available groups: %d"), GroupedPursuit.Num());
+
+	// Validation
 	if (MaxSimultaneousPursuit <= 0)
 	{
-		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("MaxSimultaneousPursuit must be > 0"));
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Invalid MaxSimultaneousPursuit: %d"), MaxSimultaneousPursuit);
-		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())
+		BIsFocusTruncate = false;
-	{
+		return;
-		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;
+
-				}
+	if (bIsSequenceDone || GroupedPursuit.IsEmpty())
-				else
 	{
-					OutPursuitNext.Append(NextGroup.PursuitGroup);
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("No groups available or sequence completed"));
-					RemainingPursuitNum -= NextGroup.PursuitGroup.Num();
+		OutPursuitFocusNext.Reset();
+		OutPursuitNext.Reset();
+		BIsFocusTruncate = false;
+		return;
+	}
+
+	OutPursuitFocusNext.Reset();
+	OutPursuitNext.Reset();
+
+	// === ÉTAPE 1: FOCUS = PREMIER GROUPE (et le supprimer) ===
+	FDTFluxPursuitGroup FocusGroup = GroupedPursuit[0]; // Copie du premier groupe
+	GroupedPursuit.RemoveAt(0); // ✅ SUPPRIMER le premier groupe
+
+	SetPursuitInfoIsMassStart(FocusGroup);
+	OutPursuitFocusNext = FocusGroup.PursuitGroup;
+	BIsFocusTruncate = FocusGroup.PursuitGroup.Num() > 1;
+
+	UE_LOG(logDTFluxCoreSubsystem, Warning,
+	       TEXT("Focus Group: StartTime=%s, Participants=%d"),
+	       *FocusGroup.StartTimeGlobal.ToString(),
+	       FocusGroup.PursuitGroup.Num());
+
+	// === ÉTAPE 2: NEXT = GROUPES SUIVANTS (SANS les supprimer) ===
+	int32 TargetNextCount = MaxSimultaneousPursuit - 1; // -1 pour le focus
+	int32 AddedNextCount = 0;
+
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Target Next Count: %d"), TargetNextCount);
+
+	// ✅ PARCOURIR les groupes restants SANS les modifier
+	for (int32 GroupIndex = 0;
+	     GroupIndex < GroupedPursuit.Num() && AddedNextCount < TargetNextCount;
+	     GroupIndex++)
+	{
+		FDTFluxPursuitGroup& NextGroup = GroupedPursuit[GroupIndex]; // Référence (pour SetPursuitInfoIsMassStart)
+
+		if (NextGroup.PursuitGroup.Num() == 0)
+		{
+			continue; // Groupe vide
+		}
+
+		int32 AvailableInGroup = NextGroup.PursuitGroup.Num();
+		int32 NeededFromGroup = FMath::Min(TargetNextCount - AddedNextCount, AvailableInGroup);
+
+		UE_LOG(logDTFluxCoreSubsystem, Warning,
+		       TEXT("Processing Next Group %d: StartTime=%s, Available=%d, Taking=%d"),
+		       GroupIndex,
+		       *NextGroup.StartTimeGlobal.ToString(),
+		       AvailableInGroup,
+		       NeededFromGroup);
+
+		// ✅ COPIER les participants nécessaires (SANS les supprimer du groupe)
+		for (int32 ParticipantIndex = 0; ParticipantIndex < NeededFromGroup; ParticipantIndex++)
+		{
+			FDTFluxPursuitInfo NextParticipant = NextGroup.PursuitGroup[ParticipantIndex]; // Copie
+
+			// Appliquer MassStart
+			NextParticipant.bIsMassStart = NextParticipant.StartTime >= MassStartTime;
+
+			OutPursuitNext.Add(NextParticipant);
+			AddedNextCount++;
+
+			UE_LOG(logDTFluxCoreSubsystem, VeryVerbose,
+			       TEXT("Added to Next: Bib %d from Group %d"),
+			       NextParticipant.Bib, GroupIndex);
 		}
 	}
-			else
+
+	// === LOGS DE RÉSUMÉ ===
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("=== PURSUIT RESULTS ==="));
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Focus: %d participants"), OutPursuitFocusNext.Num());
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Next: %d participants"), OutPursuitNext.Num());
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Remaining groups for future: %d"), GroupedPursuit.Num());
+
+	if (OutPursuitFocusNext.Num() > 0)
 	{
-				break;
+		DebugFocusNext(OutPursuitFocusNext);
 	}
+
+	// Log détaillé des Next (limité pour éviter spam)
+	if (OutPursuitNext.Num() > 0)
+	{
+		DebugOutPoursuitNext(OutPursuitNext);
 	}
+
+	// Vérifier si la séquence est terminée
+	if (GroupedPursuit.IsEmpty())
+	{
+		bIsSequenceDone = true;
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Pursuit sequence will be completed after this round"));
 	}
 }
 
@@ -119,7 +194,7 @@ bool UDTFluxPursuitManager::BindRankings()
 	{
 		if (!bIsRankingBounded)
 		{
-			CoreSubsystem->OnRequestedStageRankings.AddDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
+			CoreSubsystem->OnStageRankings.AddDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
 			bIsRankingBounded = true;
 		}
 		return bIsRankingBounded;
@@ -134,7 +209,7 @@ void UDTFluxPursuitManager::UnbindRankings()
 	{
 		if (bIsRankingBounded)
 		{
-			CoreSubsystem->OnRequestedStageRankings.RemoveDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
+			CoreSubsystem->OnStageRankings.RemoveDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
 			bIsRankingBounded = false;
 			return;
 		}
@@ -178,18 +253,30 @@ bool UDTFluxPursuitManager::LaunchPursuitSequence()
 			AllPursuits.Add(PursuitInfo);
 		}
 	}
+	UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("AllPursuits.Num() = %i"), AllPursuits.Num());
 	for (auto& Pursuit : AllPursuits)
 	{
 		if (TempGroups.Contains(Pursuit.StartTime))
 		{
-			TempGroups[Pursuit.StartTime].PursuitGroup.Add(Pursuit);
+			FDTFluxPursuitGroup& Group = TempGroups[Pursuit.StartTime];
+			Group.PursuitGroup.Add(Pursuit);
+			UE_LOG(logDTFluxCoreSubsystem, Warning,
+			       TEXT("Adding [%i] To PursuitGroup starting At %s, PursuitGroup.Num() %i"),
+			       Pursuit.Bib, *Pursuit.StartTime.ToString(), Group.PursuitGroup.Num());
 		}
 		else
 		{
-			FDTFluxPursuitGroup Group;
+			FDTFluxPursuitGroup NewGroup;
-			Group.StartTimeGlobal = Pursuit.StartTime;
+			UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("New Group starting At %s, Adding Bib [%i]"),
-			Group.PursuitGroup.Add(Pursuit);
+			       *Pursuit.StartTime.ToString(), Pursuit.Bib);
-			TempGroups.Add(Pursuit.StartTime, Group);
+			NewGroup.StartTimeGlobal = Pursuit.StartTime;
+			NewGroup.PursuitGroup.Add(Pursuit);
+			TempGroups.Add(Pursuit.StartTime, NewGroup);
+			for (const auto& Group : TempGroups)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Group.StartTime = %s, Group.PursuitGroup.Num() = %i"),
+				       *Group.Key.ToString(), Group.Value.PursuitGroup.Num());
+			}
 		}
 	}
 	TempGroups.KeySort([](const FDateTime& A, const FDateTime& B)
@@ -199,18 +286,18 @@ bool UDTFluxPursuitManager::LaunchPursuitSequence()
 	TMap<FDateTime, int> StartTimeFrequency;
 	int32 MaxFrequency = 0;
 	GroupedPursuit.Reserve(TempGroups.Num());
+	// parcours du TMap
 	for (const auto& Pair : TempGroups)
 	{
 		if (Pair.Value.StartTimeGlobal != FDateTime::MinValue() && Pair.Value.StartTimeGlobal != FDateTime::MaxValue())
 		{
-			StartTimeFrequency.FindOrAdd(Pair.Value.StartTimeGlobal)++;
+			// récuperation de la ref de la valeur actuel de la fréquence dans la TMap Freq
-			const FDateTime& PropertyValue = Pair.Value.StartTimeGlobal; // Votre propriété
+			int& CurrentFreq = StartTimeFrequency.FindOrAdd(Pair.Value.StartTimeGlobal, 0);
-			int32& Count = StartTimeFrequency.FindOrAdd(PropertyValue, 0);
+			CurrentFreq = Pair.Value.PursuitGroup.Num();
-			Count++;
+			if (CurrentFreq > MaxFrequency)
-			if (Count > MaxFrequency)
 			{
-				MaxFrequency = Count;
+				MaxFrequency = CurrentFreq;
-				MassStartTime = PropertyValue;
+				MassStartTime = Pair.Value.StartTimeGlobal;
 			}
 		}
 		GroupedPursuit.Add(Pair.Value);

Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h

@@ -54,12 +54,8 @@ public:
 	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
 	FOnTeamStatusUpdate OnTeamStatusUpdate;
 
-	DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey, StageKey,
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
-	                                             const FDTFluxStageRankings, StageRankings);
+	UDTFluxPursuitManager* PursuitManager = nullptr;
-
-	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
-	FOnRequestedStageRankings OnRequestedStageRankings;
-
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
 	bool GetContestRankings(const int ContestId, FDTFluxContestRankings& OutContestRankings);
@@ -80,16 +76,14 @@ public:
 	                             const bool bShouldUseCached = true);
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	TArray<FGuid> TrackedRequestContestRankings(const TArray<int> ForContests);
+	TArray<FGuid> TrackedRequestContestRankings(const TArray<int> ForContests, bool bEnableCache = true);
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	TArray<FGuid> TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages);
+	TArray<FGuid> TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages, bool bEnableCache = true);
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	TArray<FGuid> TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits);
+	TArray<FGuid> TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits, bool bEnableCache = true);
 
-	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
-	UDTFluxPursuitManager* PursuitManager = nullptr;
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
 	const FDTFluxParticipant GetParticipant(int InBib);

Source/DTFluxCoreSubsystem/Public/DTFluxPursuitManager.h

@@ -108,6 +108,10 @@ public:
 	UFUNCTION()
 	void OnRankingsReceived(const FDTFluxStageKey NewStageKey, const FDTFluxStageRankings NewStageRankings);
 
+
+	void DebugFocusNext(const TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext);
+	void DebugOutPoursuitNext(const TArray<FDTFluxPursuitInfo>& OutPursuitNext);
+
 private:
 	TMap<FDTFluxStageKey, bool> PendingStageRanking;
 	TArray<FDTFluxStageRankings> AllRankings;

Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp

@@ -23,11 +23,6 @@ bool FDTFluxTrackedRequest::CanRetry() const
 		(State == EDTFluxRequestState::Failed || State == EDTFluxRequestState::TimedOut);
 }
 
-bool FDTFluxTrackedRequest::IsCacheValid() const
-{
-	if (State != EDTFluxRequestState::Cached) return false;
-	return (FDateTime::Now() - CompletedAt).GetTotalSeconds() < Config.CacheValiditySeconds;
-}
 
 float FDTFluxTrackedRequest::GetRetryDelay() const
 {
@@ -40,11 +35,6 @@ bool FDTFluxTrackedRequest::Matches(EDTFluxApiDataType InType, int32 InContestId
 	return RequestType == InType && ContestId == InContestId && StageId == InStageId && SplitId == InSplitId;
 }
 
-FString FDTFluxTrackedRequest::GetCacheKey() const
-{
-	return FString::Printf(TEXT("%s_%d_%d_%d"),
-	                       *UEnum::GetValueAsString(RequestType), ContestId, StageId, SplitId);
-}
 
 void FDTFluxTrackedRequest::SetRawResponse(const FString& RawData)
 {
@@ -118,8 +108,8 @@ void FDTFluxQueuedRequestManager::Initialize(const FDTFluxRequestConfig& InDefau
 	DefaultConfig = InDefaultConfig;
 	bIsInitialized.store(true);
 
-	UE_LOG(logDTFluxNetwork, Log, TEXT("RequestManager initialized with timeout=%.1fs, cache=%.1fs"),
+	UE_LOG(logDTFluxNetwork, Log, TEXT("RequestManager initialized with timeout=%.1fs"),
-	       DefaultConfig.TimeoutSeconds, DefaultConfig.CacheValiditySeconds);
+	       DefaultConfig.TimeoutSeconds);
 }
 
 void FDTFluxQueuedRequestManager::Shutdown()
@@ -134,7 +124,6 @@ void FDTFluxQueuedRequestManager::Shutdown()
 		FScopeLock CallbacksLock_Local(&CallbacksLock);
 
 		AllRequests.Empty();
-		CacheKeyToRequestId.Empty();
 		SuccessCallbacks.Empty();
 		ErrorCallbacks.Empty();
 	}
@@ -154,37 +143,7 @@ FGuid FDTFluxQueuedRequestManager::CreateTrackedRequest(
 		UE_LOG(logDTFluxNetwork, Error, TEXT("RequestManager not initialized"));
 		return FGuid();
 	}
-
+	// Create new request
-	// Vérifier le cache d'abord
-	FString CachedResponse;
-	if (CustomConfig.bEnableCache && GetFromCache(RequestType, CachedResponse, ContestId, StageId, SplitId))
-	{
-		UE_LOG(logDTFluxNetwork, Log, TEXT("Request served from cache: Type=%s"),
-		       *UEnum::GetValueAsString(RequestType));
-
-		// Créer une "fausse" requête pour représenter le hit cache
-		auto CachedRequest = MakeShared<FDTFluxTrackedRequest>();
-		CachedRequest->RequestType = RequestType;
-		CachedRequest->ContestId = ContestId;
-		CachedRequest->StageId = StageId;
-		CachedRequest->SplitId = SplitId;
-		CachedRequest->Config = CustomConfig.bEnableCache ? CustomConfig : DefaultConfig;
-		CachedRequest->State = EDTFluxRequestState::Cached;
-		CachedRequest->RawResponseData = CachedResponse;
-		CachedRequest->CompletedAt = FDateTime::Now();
-
-		FGuid CacheRequestId = CachedRequest->RequestId;
-
-		{
-			FScopeLock Lock(&RequestsLock);
-			AllRequests.Add(CacheRequestId, CachedRequest);
-		}
-
-		RecordCacheHit();
-		return CacheRequestId;
-	}
-
-	// Créer une nouvelle requête
 	auto NewRequest = MakeShared<FDTFluxTrackedRequest>();
 	NewRequest->RequestType = RequestType;
 	NewRequest->ContestId = ContestId;
@@ -199,12 +158,8 @@ FGuid FDTFluxQueuedRequestManager::CreateTrackedRequest(
 		AllRequests.Add(RequestId, NewRequest);
 		TotalRequests++;
 	}
-
-	RecordCacheMiss();
-
 	UE_LOG(logDTFluxNetwork, Log, TEXT("Created tracked request %s: Type=%s, Contest=%d, Stage=%d, Split=%d"),
 	       *RequestId.ToString(), *UEnum::GetValueAsString(RequestType), ContestId, StageId, SplitId);
-
 	return RequestId;
 }
 
@@ -257,7 +212,6 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
 {
 	UE_LOG(logDTFluxNetwork, Log, TEXT("FDTFluxQueuedRequestManager::CompleteRequest() %s"), *RequestId.ToString());
 	TSharedPtr<FDTFluxTrackedRequest> Request;
-
 	{
 		FScopeLock Lock(&RequestsLock);
 		if (TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(RequestId))
@@ -265,19 +219,18 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
 			Request = *RequestPtr;
 		}
 	}
-
 	if (!Request.IsValid())
 	{
 		UE_LOG(logDTFluxNetwork, Warning, TEXT("Request %s not found"), *RequestId.ToString());
 		return false;
 	}
 
-	// Stocker la réponse brute
+	// Store RawResponse
 	Request->SetRawResponse(RawResponseData);
 	Request->CompletedAt = FDateTime::Now();
 	UE_LOG(logDTFluxNetwork, Log, TEXT("Request %s completed at %s"), *RequestId.ToString(),
 	       *Request->CompletedAt.ToString());
-	// Décider du parsing selon les callbacks et la configuration
+	// Decide to parse based upon config
 	bool bHasCallbacks = false;
 	{
 		FScopeLock Lock(&CallbacksLock);
@@ -292,7 +245,7 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
 		       bHasCallbacks ? TEXT("true") : TEXT("false"), bUseAsyncParsing ? TEXT("true") : TEXT("false"),
 		       RawResponseData.IsEmpty() ? TEXT("true") : TEXT("false"));
 
-		// Parsing asynchrone pour les callbacks
+		// Async parsing for Cb
 		FOnParsingCompleted OnCompleted = FOnParsingCompleted::CreateRaw(
 			this, &FDTFluxQueuedRequestManager::OnParsingCompleted
 		);
@@ -300,9 +253,8 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
 		FOnParsingFailed OnFailed = FOnParsingFailed::CreateRaw(
 			this, &FDTFluxQueuedRequestManager::OnParsingFailed
 		);
-
+		// Maybe send to parser in another place
 		AsyncParser->ParseResponseAsync(RequestId, RawResponseData, OnCompleted, OnFailed);
-		// CleanupCallbacks(RequestId);
 		UE_LOG(logDTFluxNetwork, Verbose, TEXT("Started async parsing for request %s"), *RequestId.ToString());
 		return true;
 	}
@@ -310,26 +262,21 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
 	{
 		UE_LOG(logDTFluxNetwork, Warning, TEXT("request %s completed without sync"), *RequestId.ToString());
 		// Compléter immédiatement sans parsing ou avec parsing sync
-		EDTFluxRequestState NewState = Request->Config.bEnableCache
+		EDTFluxRequestState NewState = EDTFluxRequestState::Completed;
-			                               ? EDTFluxRequestState::Cached
-			                               : EDTFluxRequestState::Completed;
-
 		ChangeRequestState(Request, NewState);
-
-		if (Request->Config.bEnableCache)
-		{
-			FScopeLock Lock(&RequestsLock);
-			CacheKeyToRequestId.Add(Request->GetCacheKey(), RequestId);
-		}
-
 		// Déclencher les callbacks avec les données brutes
 		TriggerCallbacks(*Request);
 		CleanupCallbacks(RequestId);
-
 		return true;
 	}
 }
 
+/**
+ * @todo Check protocol errors ???
+ * @param RequestId 
+ * @param ErrorMessage 
+ * @return 
+ */
 bool FDTFluxQueuedRequestManager::FailRequest(const FGuid& RequestId, const FString& ErrorMessage)
 {
 	TSharedPtr<FDTFluxTrackedRequest> Request;
@@ -350,7 +297,6 @@ bool FDTFluxQueuedRequestManager::FailRequest(const FGuid& RequestId, const FStr
 	Request->LastErrorMessage = ErrorMessage;
 	ChangeRequestState(Request, EDTFluxRequestState::Failed);
 
-	// Déclencher les callbacks d'erreur
 	TriggerCallbacks(*Request);
 	CleanupCallbacks(RequestId);
 
@@ -407,76 +353,6 @@ bool FDTFluxQueuedRequestManager::FindPendingRequest(
 	return false;
 }
 
-bool FDTFluxQueuedRequestManager::GetFromCache(
-	EDTFluxApiDataType RequestType,
-	FString& OutRawResponse,
-	int32 ContestId,
-	int32 StageId,
-	int32 SplitId) const
-{
-	FString CacheKey = GenerateCacheKey(RequestType, ContestId, StageId, SplitId);
-
-	FScopeLock Lock(&RequestsLock);
-
-	if (const FGuid* RequestId = CacheKeyToRequestId.Find(CacheKey))
-	{
-		if (const TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(*RequestId))
-		{
-			const TSharedPtr<FDTFluxTrackedRequest>& CachedRequest = *RequestPtr;
-
-			if (CachedRequest->IsCacheValid() && !CachedRequest->RawResponseData.IsEmpty())
-			{
-				OutRawResponse = CachedRequest->RawResponseData;
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-bool FDTFluxQueuedRequestManager::GetParsedFromCache(
-	EDTFluxApiDataType RequestType,
-	TSharedPtr<FDTFluxServerResponse>& OutResponse,
-	int32 ContestId,
-	int32 StageId,
-	int32 SplitId) const
-{
-	FString CacheKey = GenerateCacheKey(RequestType, ContestId, StageId, SplitId);
-
-	FScopeLock Lock(&RequestsLock);
-
-	if (const FGuid* RequestId = CacheKeyToRequestId.Find(CacheKey))
-	{
-		if (const TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(*RequestId))
-		{
-			const TSharedPtr<FDTFluxTrackedRequest>& CachedRequest = *RequestPtr;
-
-			if (CachedRequest->IsCacheValid())
-			{
-				// Parsing lazy si nécessaire
-				if (!CachedRequest->ParsedResponse.IsSet() && !CachedRequest->RawResponseData.IsEmpty())
-				{
-					OutResponse = AsyncParser->ParseResponseSync(CachedRequest->RawResponseData, 1.0f);
-					if (OutResponse.IsValid())
-					{
-						CachedRequest->ParsedResponse = OutResponse;
-						const_cast<FDTFluxTrackedRequest*>(CachedRequest.Get())->bIsResponseParsed = true;
-					}
-				}
-				else if (CachedRequest->ParsedResponse.IsSet())
-				{
-					OutResponse = CachedRequest->ParsedResponse.GetValue();
-				}
-
-				return OutResponse.IsValid();
-			}
-		}
-	}
-
-	return false;
-}
-
 // === ACCESSEURS ===
 
 bool FDTFluxQueuedRequestManager::GetRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const
@@ -554,9 +430,6 @@ FDTFluxQueuedRequestManager::FRequestStatistics FDTFluxQueuedRequestManager::Get
 		case EDTFluxRequestState::Retrying:
 			Stats.Pending++;
 			break;
-		case EDTFluxRequestState::Cached:
-			Stats.Cached++;
-			break;
 		case EDTFluxRequestState::Completed:
 			Stats.Completed++;
 			break;
@@ -568,46 +441,10 @@ FDTFluxQueuedRequestManager::FRequestStatistics FDTFluxQueuedRequestManager::Get
 	}
 
 	Stats.TotalRequests = TotalRequests;
-	Stats.CacheHits = CacheHits;
-	Stats.CacheMisses = CacheMisses;
-
-	if (Stats.TotalRequests > 0)
-	{
-		Stats.HitRate = ((float)Stats.CacheHits / (float)Stats.TotalRequests) * 100.0f;
-	}
-
 	return Stats;
 }
 
 // === NETTOYAGE ===
-
-int32 FDTFluxQueuedRequestManager::CleanupExpiredCache()
-{
-	FScopeLock Lock(&RequestsLock);
-
-	TArray<FGuid> ExpiredRequests;
-
-	for (const auto& [RequestId, Request] : AllRequests)
-	{
-		if (Request->State == EDTFluxRequestState::Cached && !Request->IsCacheValid())
-		{
-			ExpiredRequests.Add(RequestId);
-		}
-	}
-
-	for (const FGuid& RequestId : ExpiredRequests)
-	{
-		if (TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(RequestId))
-		{
-			const TSharedPtr<FDTFluxTrackedRequest>& Request = *RequestPtr;
-			CacheKeyToRequestId.Remove(Request->GetCacheKey());
-			AllRequests.Remove(RequestId);
-		}
-	}
-
-	return ExpiredRequests.Num();
-}
-
 int32 FDTFluxQueuedRequestManager::CleanupCompletedRequests(float OlderThanSeconds)
 {
 	FScopeLock Lock(&RequestsLock);
@@ -638,7 +475,6 @@ void FDTFluxQueuedRequestManager::ClearAllRequests()
 	FScopeLock CallbacksLock_Local(&CallbacksLock);
 
 	AllRequests.Empty();
-	CacheKeyToRequestId.Empty();
 	SuccessCallbacks.Empty();
 	ErrorCallbacks.Empty();
 
@@ -652,7 +488,6 @@ void FDTFluxQueuedRequestManager::Tick(float DeltaTime)
 
 	// Mise à jour des timers
 	TimeSinceLastTimeoutCheck += DeltaTime;
-	TimeSinceLastCacheCleanup += DeltaTime;
 	TimeSinceLastRetryCheck += DeltaTime;
 
 	// Vérifier les timeouts
@@ -668,13 +503,6 @@ void FDTFluxQueuedRequestManager::Tick(float DeltaTime)
 		ProcessRetries();
 		TimeSinceLastRetryCheck = 0.0f;
 	}
-
-	// Nettoyage du cache
-	if (TimeSinceLastCacheCleanup >= CacheCleanupInterval)
-	{
-		ProcessCacheCleanup();
-		TimeSinceLastCacheCleanup = 0.0f;
-	}
 }
 
 void FDTFluxQueuedRequestManager::ChangeRequestState(TSharedPtr<FDTFluxTrackedRequest> Request,
@@ -756,17 +584,11 @@ void FDTFluxQueuedRequestManager::ProcessRetries()
 	}
 }
 
-void FDTFluxQueuedRequestManager::ProcessCacheCleanup()
-{
-	CleanupExpiredCache();
-	CleanupCompletedRequests(600.0f);
-}
-
 void FDTFluxQueuedRequestManager::TriggerCallbacks(const FDTFluxTrackedRequest& Request)
 {
 	FScopeLock Lock(&CallbacksLock);
 
-	if (Request.State == EDTFluxRequestState::Completed || Request.State == EDTFluxRequestState::Cached)
+	if (Request.State == EDTFluxRequestState::Completed)
 	{
 		// Success Cb
 		const FOnDTFluxRequestSuccess* SuccessCallback = SuccessCallbacks.Find(Request.RequestId);
@@ -793,18 +615,6 @@ void FDTFluxQueuedRequestManager::CleanupCallbacks(const FGuid& RequestId)
 	ErrorCallbacks.Remove(RequestId);
 }
 
-void FDTFluxQueuedRequestManager::RecordCacheHit() const
-{
-	FScopeLock Lock(&MetricsLock);
-	CacheHits++;
-}
-
-void FDTFluxQueuedRequestManager::RecordCacheMiss() const
-{
-	FScopeLock Lock(&MetricsLock);
-	CacheMisses++;
-}
-
 void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
                                                      TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess)
 {
@@ -833,16 +643,9 @@ void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
 	{
 		Request->ParsedResponse = ParsedResponse;
 		Request->bIsResponseParsed = true;
-		EDTFluxRequestState NewState = Request->Config.bEnableCache
+		EDTFluxRequestState NewState = EDTFluxRequestState::Completed;
-			                               ? EDTFluxRequestState::Cached
-			                               : EDTFluxRequestState::Completed;
 
 		ChangeRequestState(Request, NewState);
-		if (Request->Config.bEnableCache)
-		{
-			FScopeLock Lock(&RequestsLock);
-			CacheKeyToRequestId.Add(Request->GetCacheKey(), RequestId);
-		}
 		UE_LOG(logDTFluxNetwork, Log,
 		       TEXT("DTFluxQueuedRequestManager: Async parsing completed for request %s"),
 		       *RequestId.ToString());
@@ -854,7 +657,6 @@ void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
 
 		UE_LOG(logDTFluxNetwork, Error, TEXT("Async parsing failed for request %s"), *RequestId.ToString());
 	}
-	// ✅ FIX: Déclencher les callbacks maintenant !
 	TriggerCallbacks(*Request);
 	CleanupCallbacks(RequestId);
 }
@@ -866,13 +668,3 @@ void FDTFluxQueuedRequestManager::OnParsingFailed(const FGuid& RequestId, const
 	       *ErrorMessage);
 	FailRequest(RequestId, FString::Printf(TEXT("Parsing failed: %s"), *ErrorMessage));
 }
-
-FString FDTFluxQueuedRequestManager::GenerateCacheKey(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId,
-                                                      int32 SplitId)
-{
-	return FString::Printf(TEXT("%s_%d_%d_%d"),
-	                       *UEnum::GetValueAsString(RequestType),
-	                       ContestId,
-	                       StageId,
-	                       SplitId);
-}

Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp

@@ -36,8 +36,6 @@ void UDTFluxNetworkSubsystem::Initialize(FSubsystemCollectionBase& Collection)
 	DefaultConfig.TimeoutSeconds = 5.0f;
 	DefaultConfig.MaxRetries = 3;
 	DefaultConfig.RetryBackoffMultiplier = 1.5f;
-	DefaultConfig.bEnableCache = true;
-	DefaultConfig.CacheValiditySeconds = 60.0f;
 
 	RequestManager->Initialize(DefaultConfig);
 
@@ -143,8 +141,6 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequest(
 	FDTFluxRequestConfig CustomConfig;
 	CustomConfig.TimeoutSeconds = TimeoutSeconds;
 	CustomConfig.MaxRetries = MaxRetries;
-	CustomConfig.bEnableCache = bEnableCache;
-	CustomConfig.CacheValiditySeconds = 60.0f;
 	CustomConfig.RetryBackoffMultiplier = 1.5f;
 
 	FGuid RequestId = RequestManager->CreateTrackedRequest(RequestType, ContestId, StageId, SplitId, CustomConfig);
@@ -153,15 +149,11 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequest(
 	{
 		// Récupérer la requête pour l'envoyer
 		if (const FDTFluxTrackedRequest* Request = RequestManager->GetRequestPtr(RequestId))
-		{
-			// Si la requête est déjà en cache, pas besoin d'envoyer
-			if (Request->State != EDTFluxRequestState::Cached)
 		{
 			RequestManager->MarkRequestAsSent(RequestId);
 			SendQueuedRequest(*Request);
 		}
 	}
-	}
 
 	return RequestId;
 }
@@ -174,8 +166,8 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
 	FOnDTFluxRequestSuccess& OnSuccess,
 	FOnDTFluxRequestError& OnError,
 	float TimeoutSeconds,
-	int32 MaxRetries,
+	int32 MaxRetries
-	bool bEnableCache)
+)
 {
 	if (!RequestManager.IsValid())
 	{
@@ -186,8 +178,6 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
 	FDTFluxRequestConfig CustomConfig;
 	CustomConfig.TimeoutSeconds = TimeoutSeconds;
 	CustomConfig.MaxRetries = MaxRetries;
-	CustomConfig.bEnableCache = bEnableCache;
-	CustomConfig.CacheValiditySeconds = 60.0f;
 	CustomConfig.RetryBackoffMultiplier = 1.5f;
 
 	FGuid RequestId = RequestManager->CreateTrackedRequestWithCallbacks(
@@ -196,14 +186,11 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
 	if (RequestId.IsValid())
 	{
 		if (const FDTFluxTrackedRequest* Request = RequestManager->GetRequestPtr(RequestId))
-		{
-			if (Request->State != EDTFluxRequestState::Cached)
 		{
 			RequestManager->MarkRequestAsSent(RequestId);
 			SendQueuedRequest(*Request);
 		}
 	}
-	}
 
 	return RequestId;
 }
@@ -227,7 +214,6 @@ bool UDTFluxNetworkSubsystem::HasRequestReceivedResponse(const FGuid& RequestId)
 	if (GetTrackedRequest(RequestId, Request))
 	{
 		return Request.State == EDTFluxRequestState::Completed ||
-			Request.State == EDTFluxRequestState::Cached ||
 			!Request.RawResponseData.IsEmpty();
 	}
 	return false;
@@ -264,22 +250,19 @@ int32 UDTFluxNetworkSubsystem::GetPendingRequestCount() const
 	return 0;
 }
 
-void UDTFluxNetworkSubsystem::GetRequestStatistics(int32& OutPending, int32& OutCached, int32& OutCompleted,
+void UDTFluxNetworkSubsystem::GetRequestStatistics(int32& OutPending, int32& OutCompleted,
-                                                   int32& OutFailed, float& OutHitRate) const
+                                                   int32& OutFailed) const
 {
 	if (RequestManager.IsValid())
 	{
 		FDTFluxQueuedRequestManager::FRequestStatistics Stats = RequestManager->GetStatistics();
 		OutPending = Stats.Pending;
-		OutCached = Stats.Cached;
 		OutCompleted = Stats.Completed;
 		OutFailed = Stats.Failed;
-		OutHitRate = Stats.HitRate;
 	}
 	else
 	{
-		OutPending = OutCached = OutCompleted = OutFailed = 0;
+		OutPending = OutCompleted = OutFailed = 0;
-		OutHitRate = 0.0f;
 	}
 }
 
@@ -362,7 +345,7 @@ void UDTFluxNetworkSubsystem::RegisterWebSocketEvents()
 		                                             &UDTFluxNetworkSubsystem::OnWebSocketMessageSentEvent_Subsystem);
 }
 
-void UDTFluxNetworkSubsystem::UnregisterWebSocketEvents()
+void UDTFluxNetworkSubsystem::UnregisterWebSocketEvents() const
 {
 	if (!WsClient.IsValid()) return;
 
@@ -794,11 +777,10 @@ void UDTFluxNetworkSubsystem::SendQueuedRequest(const FDTFluxTrackedRequest& Que
 
 bool UDTFluxNetworkSubsystem::ShouldUseAsyncParsing(const FString& JsonData) const
 {
-	// Critères pour décider du parsing asynchrone :
+	// Critère pour décider du parsing asynchrone :
 	// - Taille des données (> 1KB par défaut)
-	// - Charge actuelle du système
+	// Pour le moment uniquement taille 
-	// - Type de données (certains types sont plus complexes à parser)
 
-	const int32 AsyncThreshold = 1024; // 1KB
+	constexpr int32 AsyncThreshold = 1024; // 1KB
 	return JsonData.Len() > AsyncThreshold;
 }

Source/DTFluxNetwork/Public/DTFluxQueuedManager.h

@@ -26,7 +26,6 @@ enum class EDTFluxRequestState : uint8
 	Completed UMETA(DisplayName = "Completed"),
 	Failed UMETA(DisplayName = "Failed"),
 	TimedOut UMETA(DisplayName = "TimedOut"),
-	Cached UMETA(DisplayName = "Cached"),
 	Retrying UMETA(DisplayName = "Retrying")
 };
 
@@ -43,12 +42,6 @@ struct DTFLUXNETWORK_API FDTFluxRequestConfig
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
 	float RetryBackoffMultiplier = 1.5f;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	bool bEnableCache = true;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	float CacheValiditySeconds = 60.0f;
 };
 
 USTRUCT(BlueprintType)
@@ -112,10 +105,8 @@ struct DTFLUXNETWORK_API FDTFluxTrackedRequest
 
 	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;
 };
@@ -137,7 +128,7 @@ DECLARE_MULTICAST_DELEGATE_OneParam(FOnRequestFailedNative, const FDTFluxTracked
 // ================================================================================================
 
 /**
- * Gestionnaire de requêtes trackées avec cache, timeout, retry et parsing asynchrone
+ * Gestionnaire de requêtes trackées timeout, retry et parsing asynchrone
  * Implémentation C++ pure avec SmartPointers pour des performances optimales
  */
 class DTFLUXNETWORK_API FDTFluxQueuedRequestManager : public FTickableGameObject
@@ -229,7 +220,7 @@ public:
 	 */
 	bool RetryRequest(const FGuid& RequestId);
 
-	// === RECHERCHE ET CACHE ===
+	// === RECHERCHE ===
 
 	/**
 	 * Chercher une requête en attente correspondant aux critères
@@ -242,28 +233,6 @@ public:
 		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 ===
 
 	/**
@@ -294,25 +263,15 @@ public:
 	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
@@ -321,7 +280,7 @@ public:
 	int32 CleanupCompletedRequests(float OlderThanSeconds = 300.0f);
 
 	/**
-	 * Vider toutes les requêtes et le cache
+	 * Vider toutes les requêtes
 	 */
 	void ClearAllRequests();
 
@@ -353,17 +312,14 @@ private:
 
 	// === 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;
@@ -373,8 +329,6 @@ private:
 	// === MÉTRIQUES ===
 	mutable FCriticalSection MetricsLock;
 	mutable int32 TotalRequests = 0;
-	mutable int32 CacheHits = 0;
-	mutable int32 CacheMisses = 0;
 
 
 	// === PARSER ASYNCHRONE ===
@@ -397,11 +351,6 @@ private:
 	 */
 	void ProcessRetries();
 
-	/**
-	 * Nettoyer le cache périodiquement
-	 */
-	void ProcessCacheCleanup();
-
 	/**
 	 * Déclencher les callbacks pour une requête
 	 */
@@ -412,17 +361,6 @@ private:
 	 */
 	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 ===
 
 	/**
@@ -434,11 +372,4 @@ private:
 	 * 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);
 };

Source/DTFluxNetwork/Public/Subsystems/DTFluxNetworkSubsystem.h

@@ -125,8 +125,7 @@ public:
 		FOnDTFluxRequestSuccess& OnSuccess,
 		FOnDTFluxRequestError& OnError,
 		float TimeoutSeconds = 5.0f,
-		int32 MaxRetries = 3,
+		int32 MaxRetries = 3
-		bool bEnableCache = true
 	);
 
 	// === ACCESSEURS BLUEPRINT POUR LES REQUÊTES TRACKÉES ===
@@ -166,8 +165,7 @@ public:
 	 * 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,
+	void GetRequestStatistics(int32& OutPending, int32& OutCompleted, int32& OutFailed) const;
-	                          float& OutHitRate) const;
 
 	// === REQUÊTES LEGACY (Compatibilité totale) ===
 
@@ -249,7 +247,7 @@ private:
 
 	// === GESTION DES ÉVÉNEMENTS WEBSOCKET ===
 	void RegisterWebSocketEvents();
-	void UnregisterWebSocketEvents();
+	void UnregisterWebSocketEvents() const;
 	void OnWebSocketConnected_Subsystem();
 	void OnWebSocketConnectionError_Subsystem(const FString& Error);
 	void OnWebSocketClosedEvent_Subsystem(int32 StatusCode, const FString& Reason, bool bWasClean);