DTFluxAPI/Source/DTFluxNetwork/Public/DTFluxAsyncParser.h

// ================================================================================================
// 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;
};