/**

 * 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 com.oracle.chess.client.htmljava;

import java.util.ArrayList;

import java.util.List;

/** Common chess rules.

 *

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

 */

class Rules {

    static void computeAccessible(Board b, Square s) {

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

            for (Square ts : r.getColumns()) {

                ts.setAccessible(false);

            }

        }

        if (s == null) {

            return;

        }

        switch (s.getPiece()) {

            case BISHOP: 

                moveBishop(b, s);

                break;

            case KING:

                computeAccessible(b, s, 1, 1, 1);

                computeAccessible(b, s, 1, -1, 1);

                computeAccessible(b, s, -1, -1, 1);

                computeAccessible(b, s, -1, 1, 1);

                computeAccessible(b, s, 1, 0, 1);

                computeAccessible(b, s, 0, -1, 1);

                computeAccessible(b, s, 0, 1, 1);

                computeAccessible(b, s, -1, 0, 1);

                checkRochade(b, s);

                break;

            case ROCK:

                moveRock(b, s);

                break;

            case QUEEN:

                moveRock(b, s);

                moveBishop(b, s);

                break;

            case KNIGHT:

                computeAccessible(b, s, 2, 1, 1);

                computeAccessible(b, s, 2, -1, 1);

                computeAccessible(b, s, -2, -1, 1);

                computeAccessible(b, s, -2, 1, 1);

                computeAccessible(b, s, 1, 2, 1);

                computeAccessible(b, s, -1, 2, 1);

                computeAccessible(b, s, -1, -2, 1);

                computeAccessible(b, s, 1, -2, 1);

                break;

            case PAWN:

                pawns(b, s);

                break;

        }

    }

    private static void moveRock(Board b, Square s) {

        computeAccessible(b, s, 1, 0, 8);

        computeAccessible(b, s, 0, -1, 8);

        computeAccessible(b, s, -1, 0, 8);

        computeAccessible(b, s, 0, 1, 8);

    }

    private static void moveBishop(Board b, Square s) {

        computeAccessible(b, s, 1, 1, 8);

        computeAccessible(b, s, 1, -1, 8);

        computeAccessible(b, s, -1, -1, 8);

        computeAccessible(b, s, -1, 1, 8);

    }

    private static void computeAccessible(

        Board b, Square s, int dx, int dy,

        int limit

    ) {

        int x = s.getX();

        int y = s.getY();

        while (limit-- > 0) {

            x += dx;

            y += dy;

            Square next = BoardModel.findSquare(b, (char)x, y);

            if (next == null) {

                break;

            }

            if (next.getPieceColor() == s.getPieceColor()) {

                break;

            }

            next.setAccessible(true);

            if (next.getPieceColor() != null) {

                break;

            }

        }

    }

    private static void pawns(Board b, Square s) {

        final boolean white = s.getPieceColor() == Color.W;

        int dy = white ? 1 : -1;

        Square step = BoardModel.findSquare(b, (char)s.getX(), s.getY() + dy);

        if (step != null && step.getPiece() == null) {

            step.setAccessible(true);

            if ((s.getY() == 2 && white) || (s.getY() == 7 && !white)) {

                Square nextSTep = BoardModel.findSquare(b, (char)s.getX(), step.getY() + dy);

                if (nextSTep != null && step.getPiece() == null && nextSTep.getPiece() == null) {

                    nextSTep.setAccessible(true);

                }

            }

        }

        Color opposite = white ? Color.B : Color.W;

        Square takeLeft = BoardModel.findSquare(b, (char)(s.getX() - 1), s.getY() + dy);

        if (takeLeft != null && takeLeft.getPieceColor() == opposite) {

            takeLeft.setAccessible(true);

        }

        Square takeRight = BoardModel.findSquare(b, (char)(s.getX() + 1), s.getY() + dy);

        if (takeRight != null && takeRight.getPieceColor() == opposite) {

            takeRight.setAccessible(true);

        }

        if ((white && s.getY() == 5) || (!white && s.getY() == 4)) {

            int enPassantFrom = white ? 7 : 2;

            int enPassantTo = white ? 5 : 4;

            if (!b.getMoves().isEmpty()) {

                Move last = b.getMoves().get(b.getMoves().size() - 1);

                if (

                    last.getPiece() == BoardModel.PieceType.PAWN &&

                    last.getFrom().getY() == enPassantFrom &&

                    last.getTo().getY() == enPassantTo

                ) {

                    if (takeLeft != null && last.getFrom().getX() == s.getX() - 1) {

                        takeLeft.setAccessible(true);

                    }

                    if (takeRight != null && last.getFrom().getX() == s.getX() + 1) {

                        takeRight.setAccessible(true);

                    }

                }

            }

        }

    }

    static Board createBoard() {

        Board b = new Board();

        initBoardField(b);

        initBoard(b);

        return b;

    }

    private static void initBoardField(Board b) {

        List<Row> addRows = new ArrayList<>(8);

        for (int i = 8; i > 0; i--) {

            Square[] arr = new Square[8];

            for (char j = 'A'; j <= 'H'; j++) {

                arr[j - 'A'] = new Square(

                    new Position(j, i),

                    (i + j) % 2 == 1 ? Color.W : Color.B,

                    null, null, // figure

                    false, false, false

                );

            }

            addRows.add(new Row(arr));

        }

        b.getRows().addAll(addRows);

    }

    static void initBoard(Board b) {

        initBoard(b, true);

    }

    private static void initBoard(Board b, boolean init) {

        if (init) {

            b.setTurn(Color.W);

        }

        if (b.getRows().isEmpty()) {

            for (int i = 8; i > 0; i--) {

                Row r = b.getRows().get(8 - i);

                for (char j = 'A'; j <= 'H'; j++) {

                    Square s = r.getColumns().get(j - 'A');

                    s.setAccessible(false);

                    s.setPending(false);

                    r.getColumns().set(j - 'A', s);

                    initialPosition(s, init);

                }

            }

        } else {

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

                for (Square square : r.getColumns()) {

                    square.setAccessible(false);

                    square.setPending(false);

                    square.setPiece(null);

                    square.setPieceColor(null);

                    square.setSelected(false);

                    initialPosition(square, init);

                }

            }

        }

        b.setPendingMove(null);

    }

    private static void initialPosition(Square s, boolean init) {

        int row = s.getPosition().getY();

        char column = s.getPosition().getX();

        s.setPiece(null);

        s.setPieceColor(null);

        if (init) {

            if (row == 2) {

                s.setPiece(BoardModel.PieceType.PAWN);

                s.setPieceColor(Color.W);

            } else if (row == 7) {

                s.setPiece(BoardModel.PieceType.PAWN);

                s.setPieceColor(Color.B);

            } else if (row == 8 || row == 1) {

                s.setPieceColor(row == 1 ? Color.W : Color.B);

                BoardModel.PieceType t;

                switch (column) {

                    case 'A':

                    case 'H':

                        t = BoardModel.PieceType.ROCK;

                        break;

                    case 'B':

                    case 'G':

                        t = BoardModel.PieceType.KNIGHT;

                        break;

                    case 'C':

                    case 'F':

                        t = BoardModel.PieceType.BISHOP;

                        break;

                    case 'D':

                        t = BoardModel.PieceType.QUEEN;

                        break;

                    default:

                        t = BoardModel.PieceType.KING;

                        break;

                }

                s.setPiece(t);

            }

        }

    }

    static void initBoard(

        Board board, List<String> whites, List<String> blacks, Color turn

    ) {

        initBoard(board, false);

        for (String w : whites) {

            assert w.length() == 3 : "Expecting three letter string: '" + w + "'";

            w = w.toUpperCase();

            char column = w.charAt(1);

            int row = (w.charAt(2) - '0');

            Square s = BoardModel.findSquare(board, column, row);

            s.setPieceColor(Color.W);

            s.setPiece(BoardModel.PieceType.fromNotation(w.charAt(0)));

        }

        for (String w : blacks) {

            assert w.length() == 3 : "Expecting three letter string: '" + w + "'";

            w = w.toUpperCase();

            char column = w.charAt(1);

            int row = (w.charAt(2) - '0');

            Square s = BoardModel.findSquare(board, column, row);

            s.setPieceColor(Color.B);

            s.setPiece(BoardModel.PieceType.fromNotation(w.charAt(0)));

        }

        board.setTurn(turn);

    }

    private static void checkRochade(Board b, Square s) {

        if (s.getPosition().getX() == 'E') {

            int y = s.getPosition().getY();

            final Square gRow = BoardModel.findSquare(b, 'G', y);

            if (

                BoardModel.findSquare(b, 'H', y).getPiece() == BoardModel.PieceType.ROCK 

                &&

                BoardModel.findSquare(b, 'F', y).getPiece() == null

                &&

                gRow.getPiece() == null

            ) {

                gRow.setAccessible(true);

            }

            final Square cRow = BoardModel.findSquare(b, 'C', y);

            if (

                BoardModel.findSquare(b, 'A', y).getPiece() == BoardModel.PieceType.ROCK 

                &&

                BoardModel.findSquare(b, 'B', y).getPiece() == null

                &&

                BoardModel.findSquare(b, 'D', y).getPiece() == null

                &&

                cRow.getPiece() == null

            ) {

                cRow.setAccessible(true);

            }

        }

    }

}