LouisDuf-DouShouQi/Model/Tests/ModelTests/VerySimpleRulesTests.swift

import XCTest
@testable import Model
class VerySimpleRulesTests: XCTestCase {
    
    var rules: VerySimpleRules!
    var board: Board!

    override func setUp() {
        super.setUp()
        rules = VerySimpleRules()
        board = VerySimpleRules.createBoard()
    }

    override func tearDown() {
        rules = nil
        board = nil
        super.tearDown()
    }

    func testCreateBoard() {
        // Test que la fonction createBoard() retourne un plateau valide avec les dimensions attendues
        let board = VerySimpleRules.createBoard()
        XCTAssertEqual(board.nbRows, 5)
        XCTAssertEqual(board.nbColumns, 5)
    }

    func testGetNextPlayer() {
        // Teste que la fonction getNextPlayer() retourne le joueur suivant en fonction de l'historique des coups
        var rules = VerySimpleRules()
        rules.historic.append(Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 0, columnDestination: 1))
        XCTAssertEqual(rules.getNextPlayer(), .player2)

        rules.historic.append(Move(owner: .player2, rowOrigin: 0, columnOrigin: 1, rowDestination: 0, columnDestination: 2))
        XCTAssertEqual(rules.getNextPlayer(), .player1)
    }
    
    func testCheckBoardValid() {
        // Assurez-vous que la méthode `checkBoard` ne lève pas d'exception pour un plateau valide
        XCTAssertNoThrow(try VerySimpleRules.checkBoard(b: board))
    }

    func testCheckBoardInvalidDimensions() {
        // Création d'un plateau avec des dimensions invalides (4x4 au lieu de 5x5)
        var invalidCells = [[Cell]]()

        for _ in 0..<4 {
            var rowCells = [Cell]()
            for _ in 0..<4 {
                // Créez des cellules basiques, les détails dépendent de votre implémentation de Cell
                let cell = Cell(ofType: .jungle, ownedBy: .noOne, withPiece: nil)
                rowCells.append(cell)
            }
            invalidCells.append(rowCells)
        }

        let invalidBoard = Board(withGrid: invalidCells)!
        XCTAssertThrowsError(try VerySimpleRules.checkBoard(b: invalidBoard))
    }
    
    func testGetMoves() {
        // Supposons que pour une configuration de plateau spécifique, vous attendiez 3 mouvements possibles pour le joueur 1
        let expectedMoveCountForPlayer1 = 3 // Remplacez 3 par le nombre correct basé sur votre jeu

        // Test pour vérifier si getMoves retourne les bons mouvements pour le joueur 1
        let movesForPlayer1 = rules.getMoves(board: board, owner: .player1)

       // XCTAssertEqual(movesForPlayer1.count, expectedMoveCountForPlayer1)
    }

    func testIsMoveValid() {
        // Test pour un mouvement valide
        let validMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 1, columnDestination: 0)
        XCTAssertTrue(rules.isMoveValid(board: board, move: validMove))

        // Test pour un mouvement invalide (par exemple, déplacement vers une case occupée par le même joueur)
        let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 0, columnDestination: 1)
        XCTAssertFalse(rules.isMoveValid(board: board, move: invalidMove))
    }
   
    func testIsGameOver() {
        // Assurez-vous que `board` est bien initialisé
        guard let currentBoard = board else {
            XCTFail("Board is not initialized")
            return
        }

        // Créez un mouvement qui simule une fin de partie
        let winningMove = Move(owner: .player1, rowOrigin: 3, columnOrigin: 2, rowDestination: 4, columnDestination: 2)

        /*
        // Appliquez ce mouvement au plateau
        // Cette partie dépend de la façon dont votre jeu applique les mouvements
        // Ici, un exemple générique où nous remplaçons simplement la pièce dans la cellule de destination
        if let piece = currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece {
            currentBoard.grid[winningMove.rowDestination][winningMove.columnDestination].piece = piece
            currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece = nil
        }
        */

        // Testez si `isGameOver` détecte correctement la fin de partie
        let (isGameOver, result) = rules.isGameOver(board: currentBoard, lastMove: winningMove)

        XCTAssertTrue(isGameOver)
        // Vérifiez le résultat spécifique de la fin de partie
        switch result {
        case .winner(let winner, let winCondition):
            XCTAssertEqual(winner, .player1)
            XCTAssertEqual(winCondition, .denReached)
        default:
            XCTFail("Unexpected game over result")
        }
    }
    
    static var allTests = [
        ("testCreateBoard", testCreateBoard),
        ("testGetNextPlayer", testGetNextPlayer),
    ]
}