/*

 * Quoridor server and related libraries

 * Copyright (C) 2009-2010 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * 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;

import cz.xelfi.quoridor.Player.Direction;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/** Encapsulates one possible move that can be applied to existing {@link Board}

 * by calling its {@link Board#apply} method.

 *

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

 */

public final class Move extends Object {

    final Direction[] direction;

    final Fence fence;

    private Move(Direction... arr) {

        direction = arr;

        fence = null;

    }

    private Move(Fence f) {

        fence = f;

        direction = null;

    }

    private Move() {

        fence = null;

        direction = null;

    }

    /** Moves the player's figure to north */

    public static final Move NORTH = new Move(Direction.NORTH);

    /** Moves the player's figure to east */

    public static final Move EAST = new Move(Direction.EAST);

    /** Moves the player's figure to south */

    public static final Move SOUTH = new Move(Direction.SOUTH);

    /** Moves the player's figure to west */

    public static final Move WEST = new Move(Direction.WEST);

    /** Allows the player to resign the game */

    public static final Move RESIGN = new Move();

    /** Places a fence into given position with specified orientation.

     * The faces postions are numbered 1-8 and A-H according to following

     * graph: <pre>

            H   G   F   E   D   C   B   A

            |   |   |   |   |   |   |   |

        +-----------------------------------+

        |                                   |

     1--|   +   +   +   +   +   +   +   +   |--1

        |                                   |

     2--|   +   +   +   +   +   +   +   +   |--2

        |                                   |

     3--|   +   +   +   +   +   +   +   +   |--3

        |                                   |

     4--|   +   +   +   +   +   +   +   +   |--4

[E]     |                                   |     [W]

     5--|   +   +   +   +   +   +   +   +   |--5

        |                                   |

     6--|   +   +   +   +   +   +   +   +   |--6

        |                                   |

     7--|   +   +   +   +   +   +   +   +   |--7

        |                                   |

     8--|   +   +   +   +   +   +   +   +   |--8

        |                                   |

        +-----------------------------------+

            |   |   |   |   |   |   |   |

            H   G   F   E   D   C   B   A

     * </pre>

     *

     *

     * @param column x-coordinate of the middle of the fence from 'A' to 'B'

     * @param row y-coordinate of the middle of the fence

     * @param orientation place the fence horizontally or vertically

     * @return the new board

     * @exception IllegalPositionException if the move is not possible

     */

    public static Move fence(char column, int row, Fence.Orientation orientation) throws IllegalPositionException {

        if (column < 'A' || 'H' < column) {

            throw new IllegalPositionException ("x coordinate has to be from A to H"); // NOI18N

        }

        if (row < 1 || row > 8) {

            throw new IllegalPositionException ("y coordinate has to be from 1 to 8"); // NOI18N

        }

        return new Move(new Fence ((column - 'A') * 2 + 1, row * 2 - 1, orientation));

    }

    /** Moves the player in given directions. After applying

     * the first direction, the pawn has to get on a position

     * that is occupied by other player's pawn.

     *

     * @param where one or two directions saying where

     * @return the new board

     * @exception IllegalPositionException if the move is not possible

     */

    public static Move jump(Direction first, Direction second) {

        return new Move(first, second);

    }

    /** Converts the value of the move string into valid move, if possible.

     *

     * @param move the string in format used by {@link #toString()}

     * @return the move which's toString() returns the move parameter

     * @throws IllegalPositionException raised in case the parameter does not

     *      represent a valid move

     */

    public static Move valueOf(String move) throws IllegalPositionException {

        switch (move.length()) {

            case 3:

            if (move.startsWith("H")) {

                return Move.fence(move.charAt(1), move.charAt(2) - '0', Fence.Orientation.HORIZONTAL);

            }

            if (move.startsWith("V")) {

                return Move.fence(move.charAt(1), move.charAt(2) - '0', Fence.Orientation.VERTICAL);

            }

            break;

            case 2:

                return Move.jump(Direction.valueOf(move.charAt(0)), Direction.valueOf(move.charAt(1)));

            case 1:

                switch (move.charAt(0)) {

                    case 'N': return Move.NORTH;

                    case 'S': return Move.SOUTH;

                    case 'E': return Move.EAST;

                    case 'W': return Move.WEST;

                }

            case 6:

                if ("RESIGN".equals(move)) {

                    return Move.RESIGN;

                }

        }

        throw new IllegalPositionException(move);

    }

    @Override

    public String toString() {

        if (fence != null) {

            switch (fence.getOrientation()) {

                case HORIZONTAL: return "H" + fence.getColumn() + fence.getRow();

                case VERTICAL: return "V" + fence.getColumn() + fence.getRow();

            }

            throw new IllegalStateException();

        } else {

            if (direction == null) {

                return "RESIGN"; // NOI18N

            }

            StringBuilder sb = new StringBuilder();

            for (Direction d : direction) {

                sb.append(d.name().charAt(0));

            }

            return sb.toString();

        }

    }

    @Override

    public boolean equals(Object obj) {

        if (obj == null) {

            return false;

        }

        if (getClass() != obj.getClass()) {

            return false;

        }

        final Move other = (Move) obj;

        if (!Arrays.deepEquals(this.direction, other.direction)) {

            return false;

        }

        if (this.fence != other.fence && (this.fence == null || !this.fence.equals(other.fence))) {

            return false;

        }

        return true;

    }

    @Override

    public int hashCode() {

        int hash = 3;

        hash = 47 * hash + Arrays.deepHashCode(this.direction);

        hash = 47 * hash + (this.fence != null ? this.fence.hashCode() : 0);

        return hash;

    }

    public Move getMirrorMove(){

        if(fence != null){

            return new Move(new Fence(16-fence.getX(), fence.getY(), fence.getOrientation()));

        }

        if(direction == null)

            return new Move();

        int dirSize = direction.length;

        Direction[] mirrorDirection = new Direction[dirSize];

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

            if(direction[i].equals(Direction.NORTH))

                mirrorDirection[i] = Direction.NORTH;

            else if(direction[i].equals(Direction.SOUTH))

                mirrorDirection[i] = Direction.SOUTH;

            else if(direction[i].equals(Direction.EAST))

                mirrorDirection[i] = Direction.WEST;

            else if(direction[i].equals(Direction.WEST))

                mirrorDirection[i] = Direction.EAST;

        }

        return new Move(mirrorDirection);

    }

    static List<Move> allMovements() {

        List<Move> arr = new ArrayList<Move>();

        arr.add(Move.EAST);

        arr.add(Move.WEST);

        arr.add(Move.NORTH);

        arr.add(Move.SOUTH);

        for (Direction d1 : Player.Direction.values()) {

            for (Direction d2 : Player.Direction.values()) {

                arr.add(Move.jump(d1, d2));

            }

        }

        return arr;

    }

}