/**

 * The MIT License (MIT)

 *

 * Copyright (C) 2013 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

package org.apidesign.html.demo.chess;

import org.apidesign.html.demo.chess.Color;

import org.apidesign.html.demo.chess.Rules;

import org.apidesign.html.demo.chess.BoardModel;

import org.apidesign.html.demo.chess.BoardModel.PieceType;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import static org.testng.Assert.*;

import org.testng.annotations.Test;

/**

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

public class BoardModelTest {

    public BoardModelTest() {

    }

    @Test public void whiteRockLeftBottom() {

        Board b = Rules.createBoard();

        Row bottom = b.getRows().get(7);

        Square left = bottom.getColumns().get(0);

        assertEquals(left.getPiece(), PieceType.ROCK, "Rock is on bottom left square");

        assertEquals(left.getPieceColor(), Color.W, "It is white");

        assertEquals(left.getColor(), Color.B, "Square is black");

    }

    @Test public void e2e4e7e6() {

        Board b = Rules.createBoard();

        b.setGameId("myId");

        setPlayer(b, Color.W);

        assertEquals(b.getTurn(), Color.W);

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        assertNotNull(e2);

        BoardModel.selected(b, e2);

        assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        assertNotNull(e4);

        BoardModel.selected(b, e4);

        assertNull(e2.getPiece(), "No pawn at e2");

        assertEquals(e4.getPiece(), BoardModel.PieceType.PAWN, "Pawn moved successfully");

        assertNull(BoardModel.findSelectedSquare(b), "No square selected");

        BoardModel.selected(b, e4);

        assertNull(BoardModel.findSelectedSquare(b), "No square selected, it is blacks turn");

        List<Move> mvs1 = b.getMoves();

        assertEquals(1, mvs1.size(), "First move was made: " + mvs1);

        Move firstMove = mvs1.get(0);

        assertEquals(firstMove.getPiece(), PieceType.PAWN, "Moving with pawn");

        assertEquals(firstMove.getRound(), 1, "First round of moves");

        assertEquals(firstMove.getTurn(), Color.W, "Moved by white");

        assertTrue(firstMove.isWhiteMove(), "Really moved by white");

        assertTrue(b.isBlackTurn(), "black's turn");

        Square e7 = BoardModel.findSquare(b, 'E', 7);

        Move blackMv = BoardModel.MoveImpl.valueOf("E7E6");

        BoardModel.moveUpdate(b, blackMv, 

            Collections.singletonList("PE4"), 

            Collections.singletonList("PE6"), 

            Color.W, null

        );

        assertNull(e7.getPiece(), "Piece has been moved");

        List<Move> mvs = b.getMoves();

        assertEquals(2, mvs.size(), "There are two moves now: " + mvs);

        Move secondMove = mvs.get(1);

        assertEquals(secondMove.getPiece(), PieceType.PAWN, "Moving with pawn");

        assertEquals(secondMove.getRound(), 1, "Still 1st round of moves");

        assertEquals(secondMove.getTurn(), Color.B, "Moved by black");

        assertFalse(secondMove.isWhiteMove(), "Really moved by black");

    }

    @Test public void unselect() {

        Board b = Rules.createBoard();

        b.setGameId("myId");

        setPlayer(b, Color.W);

        assertEquals(b.getTurn(), Color.W);

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        assertNotNull(e2);

        BoardModel.selected(b, e2);

        assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

        BoardModel.selected(b, e2);

        assertNull(BoardModel.findSelectedSquare(b), "E2 is unselected");

        for (Row row : b.getRows()) {

            for (Square s : row.getColumns()) {

                assertFalse(s.isAccessible(), "No square is accessible anymore: " + s);

            }

        }

    }

    @Test public void discaredMove() {

        Board b = Rules.createBoard();

        b.setGameId("myId");

        setPlayer(b, Color.W);

        assertEquals(b.getTurn(), Color.W);

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        assertNotNull(e2);

        BoardModel.selected(b, e2);

        assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        assertNotNull(e4);

        BoardModel.selected(b, e4);

        assertNull(e2.getPiece(), "No pawn at e2");

        assertEquals(b.getMoves().size(), 1, "One move recorded");

        assertEquals(b.getMoves().get(0), b.getPendingMove(), "Pending move is waiting");

    }

    @Test public void cantSelectEmptySquare() {

        Board b = Rules.createBoard();

        Square e3 = BoardModel.findSquare(b, 'E', 3);

        assertNotNull(e3);

        BoardModel.selected(b, e3);

        assertNull(BoardModel.findSelectedSquare(b), "No square is selected");

    }

    @Test public void cantTakeOwnPiece() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square e1 = BoardModel.findSquare(b, 'E', 1);

        assertNotNull(e1);

        BoardModel.selected(b, e1);

        assertEquals(BoardModel.findSelectedSquare(b), e1, "E1 is selected");

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        assertNotNull(e2);

        BoardModel.selected(b, e2);

        assertNotNull(e1.getPiece(), "King remains at e1");

        assertEquals(e2.getPiece(), BoardModel.PieceType.PAWN, "Pawn remains");

        assertEquals(BoardModel.findSelectedSquare(b), e2, "e2 now selected");

    }

    @Test public void knightMustMoveToF3() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square g1 = BoardModel.findSquare(b, 'G', 1);

        BoardModel.selected(b, g1);

        Square f3 = BoardModel.findSquare(b, 'F', 3);

        assertTrue(f3.isAccessible(), "This is a field where knight can move");

        Square g3 = BoardModel.findSquare(b, 'G', 3);

        assertFalse(g3.isAccessible(), "Not a place for knight");

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        assertFalse(e2.isAccessible(), "Not a place either, occupied");

        BoardModel.selected(b, g3);

        assertNull(g3.getPiece(), "No figure was moved");

        assertTrue(g1.isSelected(), "Original square still selected");

        BoardModel.selected(b, f3);

        assertEquals(f3.getPiece(), PieceType.KNIGHT, "Moved");

        assertFalse(g3.isSelected(), "No longer selected");

    }

    @Test public void pawnCanTakeToSide() {

        Board b = Rules.createBoard();

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        Square d7 = BoardModel.findSquare(b, 'D', 7);

        Square d5 = BoardModel.findSquare(b, 'D', 5);

        BoardModel.selected(b, e2);

        BoardModel.selected(b, e4);

        setPlayer(b, Color.B);

        BoardModel.selected(b, d7);

        BoardModel.selected(b, d5);

        setPlayer(b, Color.W);

        BoardModel.selected(b, e4);

        assertTrue(d5.isAccessible(), "Can take on d5");

        BoardModel.selected(b, d5);

        assertNull(e4.getPiece(), "No pawn on e4");

        assertEquals(d5.getPieceColor(), Color.W, "White Pawn on d5");

    }

    @Test public void pawnCanJumpOnAnother() {

        Board b = Rules.createBoard();

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        Square d7 = BoardModel.findSquare(b, 'D', 7);

        Square d5 = BoardModel.findSquare(b, 'D', 5);

        Square e7 = BoardModel.findSquare(b, 'E', 7);

        Square e6 = BoardModel.findSquare(b, 'E', 6);

        Square e5 = BoardModel.findSquare(b, 'E', 5);

        BoardModel.selected(b, e2);

        BoardModel.selected(b, e4);

        setPlayer(b, Color.B);

        BoardModel.selected(b, d7);

        BoardModel.selected(b, d5);

        setPlayer(b, Color.W);

        BoardModel.selected(b, e4);

        BoardModel.selected(b, e5);

        setPlayer(b, Color.B);

        BoardModel.selected(b, e7);

        assertTrue(e6.isAccessible(), "Can move by one piece");

        assertFalse(e5.isAccessible(), "Can't move where other pawn is");

    }

    @Test public void showFirstMove() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square e2 = BoardModel.findSquare(b, 'E', 2);

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        Square d7 = BoardModel.findSquare(b, 'D', 7);

        Square d5 = BoardModel.findSquare(b, 'D', 5);

        BoardModel.selected(b, e2);

        BoardModel.selected(b, e4);

        Move blackMv = BoardModel.MoveImpl.valueOf("D7D5");

        BoardModel.moveUpdate(b, blackMv, 

            Collections.singletonList("PE4"), 

            Collections.singletonList("PD5"), 

            Color.W, null

        );

        assertEquals(b.getMoves().size(), 2, "Two moves");

        BoardModel.showPosition(b, b.getMoves().get(0));

        assertEquals(b.getRows().size(), 8, "Still eight rows");

        assertEquals(b.getRows().get(0).getColumns().size(), 8, "Eight columns");

        assertNull(e2.getPiece(), "e2 is empty");

        assertEquals(e4.getPiece(), PieceType.PAWN, "e4 has pawn");

        assertEquals(d7.getPiece(), PieceType.PAWN, "d7 has pawn");

        assertNull(d5.getPiece(), "Second move is not made");

        assertNull(b.getTurn(), "Nobody to make a move");

    }

    @Test public void initialPositionReadFromAServer() {

        List<String> blacks = Arrays.asList(

            "Pa7",

            "Pb7",

            "Pc7",

            "Pd7",

            "Pe7",

            "Pf7",

            "Pg7",

            "Ph7",

            "Ra8",

            "Nb8",

            "Bc8",

            "Qd8",

            "Ke8",

            "Bf8",

            "Ng8",

            "Rh8"

        );

        List<String> whites = Arrays.asList(

            "Ra1",

            "Nb1",

            "Bc1",

            "Qd1",

            "Ke1",

            "Bf1",

            "Ng1",

            "Rh1",

            "Pa2",

            "Pb2",

            "Pc2",

            "Pd2",

            "Pe2",

            "Pf2",

            "Pg2",

            "Ph2"

        );

        Board b = Rules.createBoard();

        Rules.initBoard(b, whites, blacks, Color.W);

        Board b2 = Rules.createBoard();

        Rules.initBoard(b2);

        for (int i = 0; i < 7; i++) {

            for (int j = 0; j < 7; j++) {

                Square s = b.getRows().get(i).getColumns().get(j);

                Square s2 = b2.getRows().get(i).getColumns().get(j);

                assertEquals(s.getPiece(), s2.getPiece(), "Same piece at " + i + "/" + j);

                assertEquals(s.getPieceColor(), s2.getPieceColor(), "Same piece color at " + i + "/" + j);

            }

        }

    }

    @Test public void allowSmallRochade() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square f1 = BoardModel.findSquare(b, 'F', 1);

        f1.setPiece(null);

        f1.setPieceColor(null);

        Square g1 = BoardModel.findSquare(b, 'G', 1);

        g1.setPiece(null);

        g1.setPieceColor(null);

        Square e1 = BoardModel.findSquare(b, 'E', 1);

        BoardModel.selected(b, e1);

        assertTrue(g1.isAccessible(), "Can do 0-0");

        BoardModel.selected(b, g1);

        assertNull(e1.getPiece());

        assertEquals(g1.getPiece(), PieceType.KING);

        assertEquals(f1.getPiece(), PieceType.ROCK);

    }

    @Test public void allowSmallRochadeForBlack() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.B);

        b.setTurn(Color.B);

        Square f8 = BoardModel.findSquare(b, 'F', 8);

        f8.setPiece(null);

        f8.setPieceColor(null);

        Square g8 = BoardModel.findSquare(b, 'G', 8);

        g8.setPiece(null);

        g8.setPieceColor(null);

        Square e8 = BoardModel.findSquare(b, 'E', 8);

        BoardModel.selected(b, e8);

        assertTrue(g8.isAccessible(), "Can do 0-0");

    }

    @Test public void disallowSmallRochadeWhenNoRock() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square f1 = BoardModel.findSquare(b, 'F', 1);

        f1.setPiece(null);

        f1.setPieceColor(null);

        Square g1 = BoardModel.findSquare(b, 'G', 1);

        g1.setPiece(null);

        g1.setPieceColor(null);

        Square h1 = BoardModel.findSquare(b, 'H', 1);

        h1.setPiece(null);

        h1.setPieceColor(null);

        Square e1 = BoardModel.findSquare(b, 'E', 1);

        BoardModel.selected(b, e1);

        assertFalse(g1.isAccessible(), "Cannot do 0-0 when there is no rock");

    }

    @Test public void disallowSmallRochadeWhenBishop() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square g1 = BoardModel.findSquare(b, 'G', 1);

        g1.setPiece(null);

        Square e1 = BoardModel.findSquare(b, 'E', 1);

        BoardModel.selected(b, e1);

        assertFalse(g1.isAccessible(), "Cannot do 0-0 when there is bishop");

    }

    @Test public void disallowSmallRochadeWhenKnight() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.W);

        Square f1 = BoardModel.findSquare(b, 'F', 1);

        f1.setPiece(null);

        Square e1 = BoardModel.findSquare(b, 'E', 1);

        BoardModel.selected(b, e1);

        assertFalse(f1.isAccessible(), "Cannot do 0-0 when there is knight");

    }

    @Test public void allowBigRochadeForBlack() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.B);

        b.setTurn(Color.B);

        Square b8 = BoardModel.findSquare(b, 'B', 8);

        b8.setPiece(null);

        b8.setPieceColor(null);

        Square c8 = BoardModel.findSquare(b, 'C', 8);

        c8.setPiece(null);

        c8.setPieceColor(null);

        Square d8 = BoardModel.findSquare(b, 'D', 8);

        d8.setPiece(null);

        d8.setPieceColor(null);

        Square e8 = BoardModel.findSquare(b, 'E', 8);

        BoardModel.selected(b, e8);

        assertTrue(c8.isAccessible(), "Can do 0-0-0");

    }

    @Test public void enPassant() {

        Board b = Rules.createBoard();

        setPlayer(b, Color.B);

        b.setTurn(Color.B);

        Square e7 = BoardModel.findSquare(b, 'E', 7);

        Square e4 = BoardModel.findSquare(b, 'E', 4);

        movePiece(e7, e4);

        Move move = new Move();

        move.setFrom(position('D', 2));

        move.setTo(position('D', 4));

        move.setPiece(PieceType.PAWN);

        b.getMoves().add(move);

        Square d2 = BoardModel.findSquare(b, 'D', 2);

        Square d4 = BoardModel.findSquare(b, 'D', 4);

        movePiece(d2, d4);

        BoardModel.selected(b, e4);

        Square e3 = BoardModel.findSquare(b, 'E', 3);

        assertTrue(e3.isAccessible(), "Obviously can move to e3");

        Square d3 = BoardModel.findSquare(b, 'D', 3);

        assertTrue(d3.isAccessible(), "Can also take on d3");

    }

    private void movePiece(Square from, Square to) {

        to.setPiece(from.getPiece());

        to.setPieceColor(from.getPieceColor());

        from.setPiece(null);

        from.setPieceColor(null);

    }

    private Position position(char c, int i) {

        Position p = new Position();

        p.setX(c);

        p.setY(i);

        return p;

    }

    private static void setPlayer(Board b, Color c) {

        b.setWhitePlayer("x");

        b.setBlackPlayer("y");

        if (c == Color.B) {

            b.setPlayer("y");

        } else {

            b.setPlayer("x");

        }

    }

}