From 02e8de2a677cb979f80d21eeb63631a996bd6a20 Mon Sep 17 00:00:00 2001
From: MarcUs7i <96580944+MarcUs7i@users.noreply.github.com>
Date: Fri, 20 Sep 2024 17:50:35 +0200
Subject: [PATCH] It's working

---
 Highscore/HighscoreProcessing.cs | 136 ++++++++++++++++++++++++++++---
 1 file changed, 126 insertions(+), 10 deletions(-)

diff --git a/Highscore/HighscoreProcessing.cs b/Highscore/HighscoreProcessing.cs
index 2db2d91..d0259b4 100644
--- a/Highscore/HighscoreProcessing.cs
+++ b/Highscore/HighscoreProcessing.cs
@@ -26,7 +26,13 @@ public static class HighscoreProcessing
     /// <param name="filePath">Path to write to</param>
     public static void WriteOutputFileAndPrint(GameScore[] highscore, string filePath)
     {
-        // TODO
+        string[] lines = new string[highscore.Length + 1];
+        lines[0] = "Score;Date;Player";
+        for (int i = 0; i < highscore.Length; i++)
+        {
+            lines[i + 1] = $"{highscore[i].Score};{highscore[i].Date:dd.MM.yyyy};{highscore[i].Player.NickName} (#{highscore[i].Player.Id})";
+        }
+        File.WriteAllLines(filePath, lines);
     }
 
     /// <summary>
@@ -37,8 +43,36 @@ public static class HighscoreProcessing
     /// <returns>Array of parsed items; empty array if file does not exist or is empty</returns>
     public static GameScore[] LoadScoresFromFile(string filePath)
     {
-        // TODO
-        return [];
+        if (!Path.Exists(filePath))
+        {
+            return Array.Empty<GameScore>();
+        }
+        
+        string[] loadedScores = File.ReadAllLines(filePath);
+        if (loadedScores.Length <= 1)
+        {
+            return Array.Empty<GameScore>();
+        }
+        loadedScores = loadedScores[1..];
+        GameScore?[] gameScores = new GameScore[loadedScores.Length];
+        for (int i = 0; i < loadedScores.Length; i++)
+        {
+            if (TryParseGameScore(loadedScores[i], out GameScore? gameScore))
+            {
+                if(gameScore!.Player.Id < 0 || gameScore.Score < 0)
+                {
+                    gameScores[i] = null;
+                    continue;
+                }
+                gameScores[i] = gameScore!;
+            }
+            else
+            {
+                gameScores[i] = null;
+            }
+        }
+
+        return TrimArray(gameScores);
     }
 
     /// <summary>
@@ -49,9 +83,26 @@ public static class HighscoreProcessing
     /// <returns>True if parsed successfully; false otherwise</returns>
     public static bool TryParseGameScore(string line, out GameScore? gameScore)
     {
-        // TODO
         gameScore = null;
-        return false;
+        
+        string[] parts = line.Split(Separator);
+        if (parts.Length != 4)
+        {
+            return false;
+        }
+
+        if (!int.TryParse(parts[0], out int id) || !DateTime.TryParse(parts[2], out DateTime date) ||
+            !int.TryParse(parts[3], out int score))
+        {
+            return false;
+        }
+        if(parts[1] == string.Empty || score < 0)
+        {
+            return false;
+        }
+        
+        gameScore = new GameScore(new Player(id, parts[1]), score, date);
+        return true;
     }
 
     /// <summary>
@@ -63,8 +114,35 @@ public static class HighscoreProcessing
     /// <returns>An array containing the highest score of each user, based on passed scores</returns>
     public static GameScore[] FindBestScorePerUser(GameScore[] allScores)
     {
-        // TODO
-        return [];
+        GameScore[] sortedScored = allScores;
+        SortGameScores(sortedScored);
+        sortedScored = TrimScorePerUser(sortedScored);
+        return sortedScored;
+    }
+
+    private static GameScore[] TrimScorePerUser(GameScore?[] scores)
+    {
+        for (int i = 0; i < scores.Length; i++)
+        {
+            for (int j = 0; j < scores.Length; j++)
+            {
+                if (scores[i]?.Player.Id == scores[j]?.Player.Id && i != j)
+                {
+                    if(scores[i] == null || scores[j] == null)
+                    {
+                        continue;
+                    }
+                    if (scores[i]!.Score < scores[j]!.Score || 
+                        (scores[i]!.Score == scores[j]!.Score && scores[i]!.Date > scores[j]!.Date))
+                    {
+                        (scores[i], scores[j]) = (scores[j], scores[i]);
+                    }
+                    scores[j] = null;
+                }
+            }
+        }
+
+        return TrimArray(scores);
     }
 
     /// <summary>
@@ -75,7 +153,20 @@ public static class HighscoreProcessing
     /// <param name="scores">Scores to sort</param>
     public static void SortGameScores(GameScore[] scores)
     {
-        // TODO
+        for (int i = 0; i < scores.Length; i++)
+        {
+            for (int j = i + 1; j < scores.Length; j++)
+            {
+                if (scores[i].Score < scores[j].Score)
+                {
+                    (scores[i], scores[j]) = (scores[j], scores[i]);
+                }
+                else if (scores[i].Score == scores[j].Score && scores[i].Date > scores[j].Date)
+                {
+                    (scores[i], scores[j]) = (scores[j], scores[i]);
+                }
+            }
+        }
     }
 
     /// <summary>
@@ -85,7 +176,32 @@ public static class HighscoreProcessing
     /// <returns>A new array containing only the non-null entries from the passed array</returns>
     public static GameScore[] TrimArray(GameScore?[] arrayToTrim)
     {
-        // TODO
-        return [];
+        if (arrayToTrim.Length == 0)
+        {
+            return Array.Empty<GameScore>();
+        }
+        int index = 0;
+        foreach (var VARIABLE in arrayToTrim)
+        {
+            if (VARIABLE != null)
+            {
+                index++;
+            }
+        }
+        if (index == 0)
+        {
+            return Array.Empty<GameScore>();
+        }
+        
+        var trimmedArray = new GameScore[index];
+        index = 0;
+        for (int i = 0; i < arrayToTrim.Length; i++)
+        {
+            if (arrayToTrim[i] != null)
+            {
+                trimmedArray[index++] = arrayToTrim[i]!;
+            }
+        }
+        return trimmedArray;
     }
 }
\ No newline at end of file