DTFluxAPI/Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h

#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"
#include "Types/Struct/DTFluxRankingStructs.h"
#include "Types/Struct/DTFluxSplitSensor.h"
#include "DTFluxCoreSubsystem.generated.h"


class UDTFluxNetworkSubsystem;
/** Forward Decl */
class UDTFluxModelAsset;
class UDTFluxPursuitManager;

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(BlueprintType, meta=(DisplayName="DTFlux Core Subsystem"))
class DTFLUXCORESUBSYSTEM_API UDTFluxCoreSubsystem : public UEngineSubsystem
{
	GENERATED_BODY()

public:
	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitRankings, FDTFluxSplitRankings, SplitRankings);

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

	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
	FOnStageRankings OnStageRankings;
	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_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey, StageKey,
	                                             const FDTFluxStageRankings, StageRankings);

	UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
	FOnRequestedStageRankings OnRequestedStageRankings;

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

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

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

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

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	bool GetStageRankingsWithKey(const FDTFluxStageKey StageKey, FDTFluxStageRankings& OutStageRankings,
	                             const bool bShouldUseCached = true);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	bool GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey, FDTFluxSplitRankings& OutSplitRankings,
	                             const bool bShouldUseCached = true);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	TArray<FGuid> TrackedRequestContestRankings(const TArray<int> ForContests);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	TArray<FGuid> TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	TArray<FGuid> TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits);

	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
	UDTFluxPursuitManager* PursuitManager = nullptr;

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void SendTeamListRequest();

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void SendRaceDataRequest();

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void SendContestRankingRequest(int InContestId);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void SendStageRankingRequest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void RequestAllStageRankingOfContest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void SendSplitRankingRequest(int InContestId, int InStageId, int InSplitId);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void RequestAllSplitRankingOfContest(int InContestId, int InStageId);

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId);

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

	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
	void RefreshStorage();

	UFUNCTION()
	TArray<int> GetCurrentContestsId();
	UFUNCTION()
	TArray<FDTFluxContest> GetCurrentContests();
	UFUNCTION()
	TArray<int> GetContestsIdForTime(const FDateTime Time);
	UFUNCTION()
	bool GetContestForId(const int Id, FDTFluxContest& OutContest);
	UFUNCTION()
	TArray<FDTFluxContest> GetContestsForTime(const FDateTime Time);

	UFUNCTION()
	void RequestRankingsForStages(const TArray<FDTFluxStage> RequestedStages) const;
	UFUNCTION()
	TArray<FDTFluxContest> GetContests();

protected:
	// ~Subsystem Interface
	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
	virtual void Deinitialize() override;
	// ~Subsystem Interface
	UFUNCTION()
	void SaveDataStorage();

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

	UFUNCTION()
	void ProcessRaceData(const FDTFluxRaceData& RaceDataDefinition);
	UFUNCTION()
	void ProcessTeamList(const FDTFluxTeamListDefinition& TeamListDefinition);
	UFUNCTION()
	void ProcessContestRanking(const FDTFluxContestRankings& ContestRankings);
	UFUNCTION()
	void ProcessStageRanking(const FDTFluxStageRankings& StageRankings);
	UFUNCTION()
	void ProcessSplitRanking(const FDTFluxSplitRankings& SplitRankings);
	UFUNCTION()
	void ProcessTeamStatusUpdate(const FDTFluxTeamStatusUpdate& NewParticipantStatus);
	UFUNCTION()
	void ProcessSplitSensor(const FDTFluxSplitSensorInfo& SplitSensorInfo);
	UFUNCTION()
	void ProcessTeamUpdate(const FDTFluxTeamListDefinition& TeamListDefinition);
	UFUNCTION()
	void SendRequest(const FString& Message);
	UFUNCTION()
	void RegisterDelegates();
};