/*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Sun in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  *

  * Contributor(s):

  *

  * Portions Copyrighted 2009 Jaroslav Tulach

  */

 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;

     }

 }