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


#include "DTFluxCoreSubsystemTools.h"

void UDTFluxCoreSubsystemTools::FilterContestRankings(FDTFluxContestRankings& ContestRankings,
	const EDTFluxSortingRankingType RankingType, TArray<FDTFluxContestRanking>& OutContestRankings, bool bAscendant)
{
	// On fait une copie locale des Rankings
    TArray<FDTFluxContestRanking> ContestArray = ContestRankings.Rankings;

    // Tri par type + direction
    ContestArray.Sort([RankingType, bAscendant](const FDTFluxContestRanking& A, const FDTFluxContestRanking& B)
    {
        switch (RankingType)
        {
        case EDTFluxSortingRankingType::Rank:
            return bAscendant ? A.Rank < B.Rank : A.Rank > B.Rank;

        case EDTFluxSortingRankingType::Bib:
            return bAscendant ? A.Bib < B.Bib : A.Bib > B.Bib;

        case EDTFluxSortingRankingType::Gap:
            return CompareTimeString(A.Gap, B.Gap, bAscendant);

        case EDTFluxSortingRankingType::SwimSpeed:
            return CompareSpeed(A.SpeedSwimAverage, B.SpeedSwimAverage, bAscendant);

        case EDTFluxSortingRankingType::RunningSpeed:
            return CompareSpeed(A.SpeedRunningAverage, B.SpeedRunningAverage, bAscendant);

        case EDTFluxSortingRankingType::TotalSpeed:
            return CompareSpeed(A.SpeedTotalAverage, B.SpeedTotalAverage, bAscendant);

        default:
            return CompareTimeString(A.Time, B.Time, bAscendant);
        }
    });

    // Réaffecte les données triées
    ContestRankings.Rankings = ContestArray;
    OutContestRankings = ContestArray;
}

void UDTFluxCoreSubsystemTools::FilterStageRankings(FDTFluxStageRankings& InStageRankings,
    const EDTFluxSortingRankingType RankingType, FDTFluxStageRankings& OutStageRankings, bool bAscendant)
{
    // TArray<FDTFluxDetailedRankings> StageArray = static_cast<TDF>()InStageRankings.Rankings;
}

void UDTFluxCoreSubsystemTools::FilterSplitRankings(FDTFluxSplitRankings& SplitRankings,
    const EDTFluxSortingRankingType RankinType, FDTFluxSplitRankings& OutSplitRankings, bool bAscendant)
{
}


float UDTFluxCoreSubsystemTools::ConvertTimeStringToSeconds(const FString& TimeString)
{

        // Format attendu : "HH:MM:SS"
        TArray<FString> Parts;
        TimeString.ParseIntoArray(Parts, TEXT(":"), true);

        if (Parts.Num() == 3)
        {
            const int32 Hours = FCString::Atoi(*Parts[0]);
            const int32 Minutes = FCString::Atoi(*Parts[1]);
            const int32 Seconds = FCString::Atoi(*Parts[2]);
            return Hours * 3600 + Minutes * 60 + Seconds;
        }
        if (Parts.Num() == 2)
        {
            const int32 Minutes = FCString::Atoi(*Parts[0]);
            const int32 Seconds = FCString::Atoi(*Parts[1]);
            return 3600 + Minutes * 60 + Seconds;
        }
        if (Parts.Num() == 1)
        {
            return FCString::Atoi(*Parts[0]);
        }
        return -1.0f;
}

bool UDTFluxCoreSubsystemTools::CompareTimeString(const FString& A_TimeStr, const FString& B_TimeStr, bool bAscendant)
{
    const float A_Time = ConvertTimeStringToSeconds(A_TimeStr);
    const float B_Time = ConvertTimeStringToSeconds(B_TimeStr);

    return bAscendant ? A_Time < B_Time : A_Time > B_Time;
}

bool UDTFluxCoreSubsystemTools::CompareSpeed(const FString& A_SpeedStr, const FString& B_SpeedStr, bool bAscendant)
{
    float A_Speed = FCString::Atof(*A_SpeedStr);
    float B_Speed = FCString::Atof(*B_SpeedStr);

    if (bAscendant)
    {
        return A_Speed < B_Speed;
    }
        return A_Speed > B_Speed;
}