/**

 * 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 java.util.Locale;

import net.java.html.json.ComputedProperty;

import net.java.html.json.Function;

import net.java.html.json.Model;

import net.java.html.json.Property;

@Model(className="Board", properties={

    @Property(name = "rows", type = Row.class, array = true),

    @Property(name = "turn", type = BoardModel.ColorType.class)

})

public class BoardModel {

    @Function static void selected(Board b, Square data) {

        Square previoslySelected = findSelectedSquare(b);

        if (previoslySelected == null) {

            if (data.getPiece() != null && data.getPieceColor() == b.getTurn()) {

                data.setSelected(true);

                Rules.computeAccessible(b, data);

            }

        } else {

            if (data.getPiece() != null && data.getPieceColor() == previoslySelected.getPieceColor()) {

                previoslySelected.setSelected(false);

                data.setSelected(true);

                Rules.computeAccessible(b, data);

                return;

            }

            if (data.isAccessible()) {

                previoslySelected.setSelected(false);

                data.setPieceColor(previoslySelected.getPieceColor());

                data.setPiece(previoslySelected.getPiece());

                b.setTurn(b.getTurn() == ColorType.WHITE ? ColorType.BLACK : ColorType.WHITE);

                previoslySelected.setPiece(null);

                previoslySelected.setPieceColor(null);

                Rules.computeAccessible(b, null);

            }

        }

    }

    @ComputedProperty static boolean whiteTurn(ColorType turn) {

        return turn == ColorType.WHITE;

    }

    @ComputedProperty static boolean blackTurn(ColorType turn) {

        return turn == ColorType.BLACK;

    }

    static Square findSquare(Board b, char column, int row) {

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

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

                if (square.getX() == column && square.getY() == row) {

                    return square;

                }

            }

        }

        return null;

    }

    static Square findSelectedSquare(Board b) {

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

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

                if (square.isSelected()) {

                    return square;

                }

            }

        }

        return null;

    }

    @Model(className="Row", properties = {

        @Property(name = "columns", type = Square.class, array = true)

    })

    static class RowsImpl {

    }

    enum PieceType {

        PAWN(5), ROCK(2), KNIGHT(4), BISHOP(3), QUEEN(1), KING(0);

        final int entityIndex;

        PieceType(int ei) {

            this.entityIndex = ei;

        }

        String computeEntity(ColorType color) {

            if (color == null) {

                color = ColorType.WHITE;

            }

            int base;

            switch (color) {

                case WHITE: base = 12; break;

                case BLACK: base = 18; break;

                default:

                    throw new AssertionError();

            }

            return "&#98" + String.valueOf(base + entityIndex) + ";";

        }

    }

    enum ColorType {

        WHITE, BLACK;

    }

    @Model(className="Square", properties = {

        @Property(name = "piece", type = PieceType.class),

        @Property(name = "pieceColor", type = ColorType.class),

        @Property(name = "color", type = ColorType.class),

        @Property(name = "x", type = int.class),

        @Property(name = "y", type = int.class),

        @Property(name = "selected", type = boolean.class),

        @Property(name = "accessible", type = boolean.class),

    })

    static class PieceImpl {

        @ComputedProperty static String pieceEntity(

            PieceType piece, ColorType pieceColor

        ) {

            if (piece == null) {

                return "";

            }

            return piece.computeEntity(pieceColor);

        }

        @ComputedProperty static String squareColor(

            ColorType color, boolean selected, boolean accessible

        ) {

            if (selected) {

                return "selected";

            }

            if (accessible) {

                return "accessible";

            }

            if (color == null) {

                return "";

            } else {

                return color.toString().toLowerCase(Locale.US);

            }

        }

    }

    public static void initialize(String[] args) {

        Board b = createBoard();

        b.applyBindings();

    }

    static Board createBoard() {

        Board b = new Board();

        b.setTurn(ColorType.WHITE);

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

            Row r = new Row();

            b.getRows().add(r);

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

                Square s = new Square();

                s.setX(j);

                s.setY(i);

                s.setColor((i + j) % 2 == 1 ? ColorType.WHITE : ColorType.BLACK);

                r.getColumns().add(s);

                if (i == 2) {

                    s.setPiece(PieceType.PAWN);

                    s.setPieceColor(ColorType.WHITE);

                } else if (i == 7) {

                    s.setPiece(PieceType.PAWN);

                    s.setPieceColor(ColorType.BLACK);

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

                    s.setPieceColor(i == 1 ? ColorType.WHITE : ColorType.BLACK);

                    PieceType t;

                    switch (j) {

                        case 'A': case 'H': t = PieceType.ROCK; break;

                        case 'B': case 'G': t = PieceType.KNIGHT; break;

                        case 'C': case 'F': t = PieceType.BISHOP; break;

                        case 'D': t = PieceType.QUEEN; break;

                        default: t = PieceType.KING; break;

                    }

                    s.setPiece(t);

                }

            }

        }

        return b;

    }

}