/**

 * 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.demo.minesweeper;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import net.java.html.json.ComputedProperty;

import net.java.html.json.Function;

import net.java.html.json.Model;

import net.java.html.json.ModelOperation;

import net.java.html.json.Property;

/** Model of the mine field.

 */

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

    @Property(name = "state", type = MinesModel.GameState.class),

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

})

final class MinesModel {

    enum GameState {

        IN_PROGRESS, WON, LOST;

    }

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

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

    })

    static class RowModel {

    }

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

        @Property(name = "state", type = SquareType.class),

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

    })

    static class SquareModel {

        @ComputedProperty static String html(SquareType state) {

            if (state == null) return " ";

            switch (state) {

                case EXPLOSION: return "B";

                case UNKNOWN: return "?";

                case DISCOVERED: return "✔";  

                case N_0: return " ";

            }

            return "" + state.ordinal();

        }

        @ComputedProperty static String style(SquareType state) {

            return state == null ? null : state.toString();

        }

    }

    enum SquareType {

        N_0, N_1, N_2, N_3, N_4, N_5, N_6, N_7, N_8,

        UNKNOWN, EXPLOSION, DISCOVERED;

        final boolean isVisible() {

            return name().startsWith("N_");

        }

        final SquareType moreBombsAround() {

            switch (this) {

                case EXPLOSION:

                case UNKNOWN:

                case DISCOVERED:

                case N_8:

                    return this;

            }

            return values()[ordinal() + 1];

        }

    }

    @Function static void smallGame(Mines model) {

        model.init(5, 5, 5);

    }

    @Function static void normalGame(Mines model) {

        model.init(10, 10, 10);

    }

    @ModelOperation static void init(Mines model, int width, int height, int mines) {

        List<Row> rows = new ArrayList<Row>(height);

        for (int y = 0; y < height; y++) {

            Square[] columns = new Square[width];

            for (int x = 0; x < width; x++) {

                columns[x] = new Square(SquareType.UNKNOWN, false);

            }

            rows.add(new Row(columns));

        }

        Random r = new Random();

        while (mines > 0) {

            int x = r.nextInt(width);

            int y = r.nextInt(height);

            final Square s = rows.get(y).getColumns().get(x);

            if (s.isMine()) {

                continue;

            }

            s.setMine(true);

            mines--;

        }

        model.setState(GameState.IN_PROGRESS);

        model.getRows().clear();

        model.getRows().addAll(rows);

    }

    @ModelOperation static void computeMines(Mines model) {

        List<Integer> xBombs = new ArrayList<Integer>();

        List<Integer> yBombs = new ArrayList<Integer>();

        final List<Row> rows = model.getRows();

        boolean emptyHidden = false;

        SquareType[][] arr = new SquareType[rows.size()][];

        for (int y = 0; y < rows.size(); y++) {

            final List<Square> columns = rows.get(y).getColumns();

            arr[y] = new SquareType[columns.size()];

            for (int x = 0; x < columns.size(); x++) {

                Square sq = columns.get(x);

                if (sq.isMine()) {

                    xBombs.add(x);

                    yBombs.add(y);

                }

                if (sq.getState().isVisible()) {

                    arr[y][x] = SquareType.N_0;

                } else {

                    if (!sq.isMine()) {

                        emptyHidden = true;

                    }

                }

            }

        }

        for (int i = 0; i < xBombs.size(); i++) {

            int x = xBombs.get(i);

            int y = yBombs.get(i);

            incrementAround(arr, x, y);

        }

        for (int y = 0; y < rows.size(); y++) {

            final List<Square> columns = rows.get(y).getColumns();

            for (int x = 0; x < columns.size(); x++) {

                Square sq = columns.get(x);

                final SquareType newState = arr[y][x];

                if (newState != null && newState != sq.getState()) {

                    sq.setState(newState);

                }

            }

        }

        if (!emptyHidden) {

            model.setState(GameState.WON);

            showAllBombs(model, SquareType.DISCOVERED);

        }

    }

    private static void incrementAround(SquareType[][] arr, int x, int y) {

        incrementAt(arr, x - 1, y - 1);

        incrementAt(arr, x - 1, y);

        incrementAt(arr, x - 1, y + 1);

        incrementAt(arr, x + 1, y - 1);

        incrementAt(arr, x + 1, y);

        incrementAt(arr, x + 1, y + 1);

        incrementAt(arr, x, y - 1);

        incrementAt(arr, x, y + 1);

    }

    private static void incrementAt(SquareType[][] arr, int x, int y) {

        if (y >= 0 && y < arr.length) {

            SquareType[] r = arr[y];

            if (x >= 0 && x < r.length) {

                SquareType sq = r[x];

                if (sq != null) {

                    r[x] = sq.moreBombsAround();

                }

            }

        }

    }

    static void showAllBombs(Mines model, SquareType state) {

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

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

                if (square.isMine()) {

                    square.setState(state);

                }

            }

        }

    }

    @Function static void click(Mines model, Square data) {

        if (model.getState() != GameState.IN_PROGRESS) {

            return;

        }

        switch (data.getState()) {

            case UNKNOWN: 

                if (data.isMine()) {

                    showAllBombs(model, SquareType.EXPLOSION);

                    model.setState(GameState.LOST);

                } else {

                    expandKnown(model, data);

                }

            break;

        }

    }

    private static void expandKnown(Mines model, Square data) {

        final List<Row> rows = model.getRows();

        for (int y = 0; y < rows.size(); y++) {

            final List<Square> columns = rows.get(y).getColumns();

            for (int x = 0; x < columns.size(); x++) {

                Square sq = columns.get(x);

                if (sq == data) {

                    expandKnown(model, x, y);

                    return;

                }

            }

        }

    }

    private static void expandKnown(Mines model, int x , int y) {

        if (y < 0 || y >= model.getRows().size()) {

            return;

        }

        final List<Square> columns = model.getRows().get(y).getColumns();

        if (x < 0 || x >= columns.size()) {

            return;

        }

        final Square sq = columns.get(x);

        if (sq.getState() == SquareType.UNKNOWN) {

            sq.setState(SquareType.N_0);

            model.computeMines();

            if (sq.getState() == SquareType.N_0) {

                expandKnown(model, x - 1, y - 1);

                expandKnown(model, x - 1, y);

                expandKnown(model, x - 1, y + 1);

                expandKnown(model, x , y - 1);

                expandKnown(model, x, y + 1);

                expandKnown(model, x + 1, y - 1);

                expandKnown(model, x + 1, y);

                expandKnown(model, x + 1, y + 1);

            }

        }

    }

}