/*

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

     }

 }