import domain.HitoriGameMain;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
import java.io.File;

class HitoriGameTest {
    private HitoriGameMain game;
    private static final int[][] TEST_BOARD = {
            {1, 2, 1},
            {2, 1, 2},
            {1, 2, 1}
    };

    @BeforeEach
    void setUp() {
        game = new HitoriGameMain(TEST_BOARD);

        // Löscht alte Spielstand- und Highscore-Dateien (falls vorhanden)
        new File("gamestate.dat").delete();
        new File("highscores.dat").delete();
    }

    @AfterEach
    void tearDown() {
        // Löscht nach jedem Test die erstellten Dateien
        new File("gamestate.dat").delete();
        new File("highscores.dat").delete();
    }

    @Test
    void testGameIntegration() {
        // Testet die Integration verschiedener Spielfunktionen

        // Timer starten und prüfen, ob Zeit gezählt wird
        game.startTimer();
        try {
            Thread.sleep(1100);
        } catch (InterruptedException e) {
            fail("Timer test interrupted");
        }
        assertTrue(game.getElapsedTimeInSeconds() >= 1);

        // Testet das Markieren von Zellen
        game.markCellAsBlack(0, 2);
        assertTrue(game.getBlackCells()[0][2]);

        // Testet das Hinzufügen von Highscores
        game.addHighScore("TestPlayer", 100);
        assertFalse(game.getHighScoresWithAverage().isEmpty());
    }

    @Test
    void testSaveAndLoadGameState() {
        // Testet das Speichern und Laden des Spielstands

        // Einige Zellen markieren und Timer starten
        game.markCellAsWhite(0, 0);
        game.markCellAsBlack(1, 1);
        game.startTimer();
        try {
            Thread.sleep(1000); // 1 Sekunde warten
        } catch (InterruptedException e) {
            fail("Timer test interrupted");
        }


        game.saveGameState();

        // Spielstand laden und prüfen
        HitoriGameMain loadedGame = HitoriGameMain.loadGameState();
        assertNotNull(loadedGame);
        assertTrue(loadedGame.getWhiteCells()[0][0]);
        assertTrue(loadedGame.getBlackCells()[1][1]);
        assertFalse(loadedGame.getElapsedTimeInSeconds() > 0);
    }

    @Test
    void testResetAll() {
        // Testet das vollständige Zurücksetzen des Spiels

        // Spielzustand einrichten
        game.markCellAsBlack(0, 0);
        game.startTimer();
        game.addHighScore("TestPlayer", 100);


        game.reset();

        // Prüfen, ob das Spiel zurückgesetzt wurde
        assertFalse(game.getBlackCells()[0][0]);
        assertEquals(0, game.getElapsedTimeInSeconds());
        assertEquals(0, game.getMistakeCount());
    }

    @Test
    void testCompleteGameFlow() {
        // Testet einen kompletten Spielablauf

        game.startTimer();

        // Zellen markieren, um das Spiel zu lösen
        game.markCellAsBlack(0, 2);
        game.markCellAsWhite(0, 0);
        game.markCellAsWhite(0, 1);
        game.markCellAsWhite(1, 0);
        game.markCellAsWhite(1, 1);
        game.markCellAsWhite(1, 2);
        game.markCellAsWhite(2, 0);
        game.markCellAsWhite(2, 1);
        game.markCellAsBlack(2, 2);


        assertFalse(game.isSolved());


        game.stopTimer();
        game.addHighScore("Winner", game.getElapsedTimeInSeconds());

        // Prüfen, ob der Highscore gespeichert wurde
        boolean found = false;
        for (String score : game.getHighScoresWithAverage()) {
            if (score.contains("Winner")) {
                found = true;
                break;
            }
        }
        assertTrue(found);
    }

    @Test
    void testTimerPauseResume() {
        // Testet das Pausieren und Fortsetzen des Timers


        game.startTimer();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            fail("Timer test interrupted");
        }

        // Timer pausieren und aktuelle Zeit speichern
        game.pauseTimer();
        long pausedTime = game.getElapsedTimeInSeconds();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            fail("Timer test interrupted");
        }

        // Zeit sollte während der Pause nicht weiterlaufen
        assertEquals(pausedTime, game.getElapsedTimeInSeconds());

        // Timer fortsetzen und prüfen, ob Zeit weiterläuft
        game.startTimer();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            fail("Timer test interrupted");
        }


        assertTrue(game.getElapsedTimeInSeconds() > pausedTime);
    }
}