feature(facade): Facade hinzugefügt

Facade als Anlaufpunkt für das Backend implementiert, um Trennung zu gewährleisten

src/main/java/de/deversmann/domain/CSVReader.java

@@ -4,36 +4,54 @@ import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.List;
 
 public class CSVReader {
 
-    /**
-     * Liest die CSV-Datei ein und gibt die enthaltenen Werte als zweidimensionales int-Array zurück.
-     *
-     * @param csvFile Pfad zur CSV-Datei
-     * @return zweidimensionales Array, das die Zahlen aus der CSV enthält
-     * @throws IOException wenn ein Fehler beim Lesen auftritt
-     */
-    public int[][] readCsvToIntArray(String csvFile) throws IOException {
-        ArrayList<int[]> rows = new ArrayList<>();
+    public PuzzleData readPuzzleWithSolution(String csvFile) throws IOException {
+        List<int[]> puzzleRows = new ArrayList<>();
+        List<int[]> solutionCoordinates = new ArrayList<>();
 
         try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
             String line;
+            boolean inSolutionPart = false;
+
             while ((line = br.readLine()) != null) {
-                String[] tokens = line.split(",");
-                int[] row = new int[tokens.length];
-                for (int i = 0; i < tokens.length; i++) {
-                    row[i] = Integer.parseInt(tokens[i].trim());
+                line = line.trim();
+                if (line.isEmpty()) {
+                    continue;
+                }
+                if (line.startsWith("//Lösung") || line.startsWith("//")) {
+                    inSolutionPart = true;
+                    continue;
+                }
+
+                if (!inSolutionPart) {
+                    // Puzzle-Teil
+                    String[] tokens = line.split(",");
+                    int[] rowValues = new int[tokens.length];
+                    for (int i = 0; i < tokens.length; i++) {
+                        rowValues[i] = Integer.parseInt(tokens[i].trim());
+                    }
+                    puzzleRows.add(rowValues);
+                } else {
+                    // Lösungsteil
+                    String[] coords = line.split(",");
+                    if (coords.length == 2) {
+                        int row = Integer.parseInt(coords[0].trim());
+                        int col = Integer.parseInt(coords[1].trim());
+                        solutionCoordinates.add(new int[]{row, col});
+                    }
                 }
-                rows.add(row);
             }
         }
 
-        // ArrayList in 2D-Array umwandeln
-        int[][] result = new int[rows.size()][];
-        for (int i = 0; i < rows.size(); i++) {
-            result[i] = rows.get(i);
+        // puzzleRows -> 2D-Array
+        int[][] puzzleArray = new int[puzzleRows.size()][];
+        for (int i = 0; i < puzzleRows.size(); i++) {
+            puzzleArray[i] = puzzleRows.get(i);
         }
-        return result;
+
+        return new PuzzleData(puzzleArray, solutionCoordinates);
     }
 }

src/main/java/de/deversmann/facade/Facade.java

@@ -1,4 +1,101 @@
 package de.deversmann.facade;
 
+import de.deversmann.domain.*;
+
+import java.io.IOException;
+import java.util.List;
+
 public class Facade {
+
+    private final CSVReader csvReader;
+    private final HighscoreManager highscoreManager;
+    private final Zeiterfassung zeiterfassung;
+
+    private PuzzleData currentPuzzleData;
+    private String currentPuzzleName;
+    private int currentErrorCount = 0;
+
+    public Facade() {
+        this.csvReader = new CSVReader();
+        this.highscoreManager = new HighscoreManager();
+        this.zeiterfassung = new Zeiterfassung();
+    }
+
+    public void ladeSpielfeld(String csvPfad) throws IOException {
+        this.currentPuzzleData = csvReader.readPuzzleWithSolution(csvPfad);
+        this.currentPuzzleName = csvPfad;
+        this.currentErrorCount = 0;
+
+        zeiterfassung.stop();
+        zeiterfassung.start();
+        System.out.println("Neues Spielfeld geladen, Timer + Fehler=0");
+    }
+
+    public long stopZeiterfassung() {
+        zeiterfassung.stop();
+        return zeiterfassung.getElapsedTimeInSeconds();
+    }
+
+    public long getElapsedTimeSoFar() {
+        return zeiterfassung.getElapsedTimeInSeconds();
+    }
+
+    public int[][] getAktuellesPuzzle() {
+        return (currentPuzzleData != null) ? currentPuzzleData.getPuzzle() : null;
+    }
+
+    public List<int[]> getLoesungsKoordinaten() {
+        return (currentPuzzleData != null) ? currentPuzzleData.getSolutionCoordinates() : null;
+    }
+
+    // Fehler-Tracking
+    public void incrementErrorCount() {
+        currentErrorCount++;
+    }
+
+    public int getCurrentErrorCount() {
+        return currentErrorCount;
+    }
+
+    // Highscore
+    public void addHighscoreForCurrentPuzzle(String playerName, long timeSeconds, int errorCount) {
+        if (currentPuzzleName != null && !currentPuzzleName.isEmpty()) {
+            highscoreManager.addHighscore(currentPuzzleName, playerName, timeSeconds, errorCount);
+        }
+    }
+
+    public List<HighscoreEntry> getHighscoresForCurrentPuzzle() {
+        if (currentPuzzleName == null) {
+            return List.of();
+        }
+        return highscoreManager.getHighscores(currentPuzzleName);
+    }
+
+    public double getAverageTimeForCurrentPuzzle() {
+        if (currentPuzzleName == null) {
+            return -1;
+        }
+        return highscoreManager.getAverageTime(currentPuzzleName);
+    }
+
+    public String getCurrentPuzzleName() {
+        return currentPuzzleName;
+    }
+
+    public void saveCurrentPuzzleHighscoreToFile() throws IOException {
+        if (currentPuzzleName == null) return;
+        String base = currentPuzzleName.replaceAll(".*/", "");
+        String shortName = base.replace(".csv", "") + "_highscore.txt";
+        highscoreManager.saveSinglePuzzle(currentPuzzleName, shortName);
+        System.out.println("Highscore zu " + base + " in " + shortName + " gespeichert.");
+    }
+
+
+    public void loadCurrentPuzzleHighscoreFromFile() throws IOException {
+        if (currentPuzzleName == null) return;
+        String base = currentPuzzleName.replaceAll(".*/", "");
+        String shortName = base.replace(".csv", "") + "_highscore.txt";
+        highscoreManager.loadSinglePuzzle(currentPuzzleName, shortName);
+        System.out.println("Highscore zu " + base + " aus " + shortName + " geladen (falls existiert).");
+    }
 }