DTFluxAPI/Source/DTFluxNetwork/Public/Struct/DTFluxRequestStructs.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

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


/**
 * Struct representing a base json object request to the server
 * Used to request data to the server
 */
USTRUCT()
struct FDTFluxRequestBase
{
	GENERATED_BODY()

public:
	UPROPERTY()
	FString Path = "";

	FDateTime CreatedAt = FDateTime::Now();
	FGuid RequestId = FGuid::NewGuid();
};

/**
 * Struct representing a RaceData json object request to the server
 * RaceData represents all data concerning the Race and its different Contests, Stages and Splits.
 */
USTRUCT()
struct FDTFluxRaceDataRequest : public FDTFluxRequestBase
{
	GENERATED_BODY()

public:
	FDTFluxRaceDataRequest()
	{
		Path = "race-datas";
	}
};

/**
 * Struct representing a TeamList json object request to the server
 * TeamList is the list of participants of the events
 */
USTRUCT()
struct FDTFluxTeamListRequest : public FDTFluxRequestBase
{
	GENERATED_BODY()

public:
	FDTFluxTeamListRequest()
	{
		Path = "team-list";
	}
};

/**
 * Struct representing a Ranking json request object for a specific to the server
 */
USTRUCT()
struct FDTFluxContestRankingRequest : public FDTFluxRequestBase
{
	GENERATED_BODY()

public:
	FDTFluxContestRankingRequest()
	{
		Path = "contest-ranking";
		ContestID = -1;
	}

	FDTFluxContestRankingRequest(int InContestID)
	{
		Path = "contest-ranking";
		ContestID = InContestID;
	}

	UPROPERTY()
	int ContestID;
};

/**
 * Struct representing a Ranking json request object for a specific Stage to the server
 */
USTRUCT()
struct FDTFluxStageRankingRequest : public FDTFluxRequestBase
{
	GENERATED_BODY()

public:
	FDTFluxStageRankingRequest()
	{
		Path = "stage-ranking";
		ContestID = -1;
		StageID = -1;
		SplitID = -1;
	}

	FDTFluxStageRankingRequest(int InContestID, int InStageId)
	{
		Path = "stage-ranking";
		ContestID = InContestID;
		StageID = InStageId;
		SplitID = -1;
	}

	UPROPERTY()
	int ContestID;
	UPROPERTY()
	int StageID;
	UPROPERTY()
	int SplitID;
};

/**
 * Struct representing a Ranking json request object for a specific Split to the server
 */
USTRUCT()
struct FDTFluxSplitRankingRequest : public FDTFluxStageRankingRequest
{
	GENERATED_BODY()

public:
	FDTFluxSplitRankingRequest()
	{
		Path = "stage-ranking";
		ContestID = -1;
		StageID = -1;
		SplitID = -1;
	}

	FDTFluxSplitRankingRequest(int InContestID, int InStageId, int InSplitId)
	{
		Path = "stage-ranking";
		ContestID = InContestID;
		StageID = InStageId;
		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);
	}
};