/*

 * Quoridor server and related libraries

 * Copyright (C) 2009-2010 Martin Rexa

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://www.gnu.org/licenses/.

 */

package cz.xelfi.quoridor.statistics;

import cz.xelfi.quoridor.Board;

import cz.xelfi.quoridor.Move;

import cz.xelfi.quoridor.webidor.Game;

import cz.xelfi.quoridor.webidor.CommentedMove;

import cz.xelfi.quoridor.IllegalPositionException;

import java.util.Map;

import java.util.HashMap;

/**

 *

 * @author Martin Rexa

 */

public class OpeningTree {

    Map<String, OpeningTreeNode> nodes = new HashMap<String, OpeningTreeNode>();

    OpeningTreeNode root;

    public OpeningTree(){

        root = new OpeningTreeNode("ROOT");

        nodes.put("ROOT", root);

    }

    public OpeningTreeNode getRoot(){

        return root;

    }

    public OpeningTreeNode getNode(String hashCode){

        return nodes.get(hashCode);

    }

    public void processGame(Game game) throws IllegalPositionException{

        OpeningTreeNode node = root;

        OpeningTreeNode parentNode;

        OpeningTreeNode mirrorNode = root;

        OpeningTreeNode mirrorParentNode;

        Board board = Board.empty();

        Board mirrorBoard = Board.empty();

        root.addGame(game);

        for(CommentedMove move: game.getMoves()){

            if(!move.getMove().equals(Move.RESIGN)){

                parentNode = node;

                mirrorParentNode = mirrorNode;

                board = board.apply(move.getMove());

                mirrorBoard = mirrorBoard.apply(move.getMove().getMirrorMove());

                String hashCode = board.getCode();

                String mirrorHashCode = mirrorBoard.getCode();

                node = nodes.get(hashCode);

                if(node == null){

                    node = new OpeningTreeNode(hashCode);

                    nodes.put(hashCode, node);

                }

                node.addGame(game);

                mirrorNode = nodes.get(mirrorHashCode);

                if(mirrorHashCode.equals(hashCode)){

                    if(mirrorNode == null){

                        mirrorNode = node;

                    }

                }else{

                    if(mirrorNode == null){

                        mirrorNode = new OpeningTreeNode(mirrorHashCode);

                        nodes.put(mirrorHashCode, mirrorNode);

                    }

                    mirrorNode.addGame(game);

                }

                if(parentNode != null)

                    parentNode.addChild(move.getMove(),node);

                if(mirrorParentNode != null){

                    if(parentNode.equals(mirrorParentNode) && node.equals(mirrorNode))

                        ;

                    else

                        mirrorParentNode.addChild(move.getMove().getMirrorMove(),mirrorNode);

                }

            }

        }

        node.addFinishedGame(game);

        if(!node.equals(mirrorNode))

            mirrorNode.addFinishedGame(game);

    }

}