/// <summary>
        /// Purpose: To perform the minimax algorithm to determine chess move
        /// </summary>
        /// <param name="boardState"></param>
        /// <param name="color"></param>
        /// <returns>char[] board to represent the move</returns>
        /// 

        public static char[] miniMax(char[] SRFen, ChessColor color)
        {
            TimeSpan maxTime = TimeSpan.FromMilliseconds(5500);
            Char[] initialBoard = (char[])SRFen.Clone();
            bool white;
            int alpha = -10000;
            int beta = 10000;
            int cutoff = 4;
            if (color == ChessColor.White) white = true;
            else white = false;
            int depth = 0;
            Stopwatch timer = new Stopwatch();
            timer.Start();
            int h;
            h = minValue(ref SRFen, depth + 1, white, alpha, beta, cutoff, ref timer);
            if (h == -5000) 
                return SRFen;
            char[] bestSoFar = (char[])SRFen.Clone();
            while (timer.Elapsed < maxTime && h != -9999)
            { 
                cutoff += 2;
                char[] temp = (char[])initialBoard.Clone();
                h = minValue(ref temp, depth + 1, white, alpha, beta, cutoff, bestSoFar, ref timer);
                if (h != -9999) bestSoFar = (char[])temp.Clone();
                if (h == -5000) 
                    return bestSoFar;
            }
            //this.Log("cutoff" + cutoff);
            return bestSoFar;
        }

        /// <summary>
        /// Takes a board and color, and returns a simplified state where friend pieces are represented
        /// by positive integers and always start on the same side of the board (0,0). Foe pieces are 
        /// represented as negative values
        /// </summary>
        /// <param name="board">The board to convert</param>
        /// <param name="color">The color of the player (friend)</param>
        /// <returns>A simplified representation of the current board</returns>
        public static int[,] GetSimpleState(ChessBoard board, ChessColor color)
        {
            int[,] state = new int[Columns, Rows];

            for (int col = 0; col < Columns; col++)
            {
                for (int row = 0; row < Rows; row++)
                {
                    int stateRow = row;
                    int stateCol = col;
                    if (color == ChessColor.White)
                    {
                        stateRow = Rows - row - 1;
                        stateCol = Columns - col - 1;
                    }

                    ChessPiece piece = board[col, row];

                    int multiplier = 1;
                    if (color == ChessColor.White && piece < ChessPiece.Empty
                        || color == ChessColor.Black && piece > ChessPiece.Empty)
                        multiplier = -1;

                    state[stateCol, stateRow] = multiplier * GamePieceToStatePiece[piece];
                }
            }
            return state;
        }

 /// <summary>
 /// Purpose: To calculate a heuristic value for the given board state
 /// </summary>
 /// <param name="boardState"></param>
 /// <param name="color"></param>
 /// <returns>integer representing the heuristic</returns>
 public static int GetHeuristicValue(byte[] boardState, ChessColor color)
 {
     bool white = color == ChessColor.White;
     int pH = GetPieceValueHeuristic(boardState, color);
     int pS = FEN.GetPieceHazard(boardState, white);
     return pH + pS;
 }

 public Player(string name, ChessColor color)
 {
     // TODO: Validate name lenght
     this.Name = name;
     this.Color = color;
     this.figures = new List<IFigure>();
 }

        /// <summary>
        /// Purpose: To calculate a heuristic based purely off piece value
        /// </summary>
        /// <param name="boardState"></param>
        /// <param name="color"></param>
        /// <returns></returns>
        private static int GetPieceValueHeuristic(byte[] boardState, ChessColor color)
        {
            int whiteValue = 0;
            int blackValue = 0;
            for (int i = 0; i < boardState.Length; i++)
            {
                if (boardState[i] != FEN._)
                {
                    if (boardState[i].IsUpper())
                        whiteValue += (pieceValues[boardState[i]] + GetPiecePositionValue(boardState[i], i));
                    else
                        blackValue += (pieceValues[boardState[i]] + GetPiecePositionValue(boardState[i], i));
                }
            }

            //Log("WV -" + whiteValue.ToString());
            //Log("BV -" + blackValue.ToString());

            if (color == ChessColor.White)
            {
                if (whiteValue - 20000 < 1500)
                {
                    lateGame = true;
                }
                return whiteValue - blackValue;
            }
            else
            {
                if (blackValue - 20000 < 1500)
                {
                    lateGame = true;
                }
                return blackValue - whiteValue;
            }
        }

 public static Piece GetType(string s, ChessColor color)
 {
     Piece p;
     switch (s)
     {
         case "Bishop":
             p = new Bishop(color);
             break;
         case "King":
             p = new King(color);
             break;
         case "Knight":
             p = new Knight(color);
             break;
         case "Pawn":
             p = new Pawn(color);
             break;
         case "Queen":
             p = new Queen(color);
             break;
         case "Rook":
             p = new Rook(color);
             break;
         default:
             throw new Exception("Piece unknown : " + s);
     }
     return p;
 }

 public ChessSquare(int y, int x, ChessColor color)
 {
     Loc = new Location();
     Loc.Y = y;
     Loc.X = x;
     Color = color;
 }

 /// <summary>
 /// The constructor.
 /// </summary>
 /// <param name="board">The board in which the square is located.</param>
 /// <param name="location">The location of the square.</param>
 /// <param name="color">The color of the square.</param>
 /// <param name="piece">The Chess piece that is on the square.</param>
 public Square(ChessBoard board, Location location, ChessColor color, ChessPiece piece = null)
 {
     this.Board = board;
     this.Location = location;
     this.Color = color;
     this.Piece = piece;
 }

 public void GenerateMoves(ChessBoard board, ChessColor color)
 {
     Moves = new List<ChessMove>();
     for (int y = 0; y < ChessBoard.NumberOfRows; y++)
     {
         for (int x = 0; x < ChessBoard.NumberOfColumns; x++)
         {
             if (color == ChessColor.White) // if player is white
             {
                 if (board[x, y] > ChessPiece.Empty)
                 {
                     switch (board[x, y])
                     {
                         case ChessPiece.WhiteBishop:
                             BishopMoves(board, x, y, color);
                             break;
                         case ChessPiece.WhiteQueen:
                             QueenMoves(board, x, y, color);
                             break;
                         case ChessPiece.WhiteKing:
                             break;
                         case ChessPiece.WhiteKnight:
                             KnightMoves(board, x, y, color);
                             break;
                         case ChessPiece.WhitePawn:
                             PawnMoves(board, x, y, color);
                             break;
                         case ChessPiece.WhiteRook:
                             RookMoves(board, x, y, color);
                             break;
                     }
                 }
             }
             else if ( color == ChessColor.Black)
             {
                 switch (board[x, y])
                 {
                     case ChessPiece.BlackBishop:
                         BishopMoves(board, x, y, color);
                         break;
                     case ChessPiece.BlackQueen:
                         QueenMoves(board, x, y, color);
                         break;
                     case ChessPiece.BlackKing:
                         break;
                     case ChessPiece.BlackKnight:
                         KnightMoves(board, x, y, color);
                         break;
                     case ChessPiece.BlackPawn:
                         PawnMoves(board, x, y, color);
                         break;
                     case ChessPiece.BlackRook:
                         RookMoves(board, x, y, color);
                         break;
                 }
             }
         }
     }
 }

        public Piece( ChessColor color )
        {
            Rules = new Collection<Rule>();

            Color = color;

            InitializeRules();
        }

 /// <summary>
 /// this will define BoardAfterMove, TheMove, and HValue based on move
 /// </summary>
 /// <param name="board"></param>
 /// <param name="move"></param>
 /// <param name="colorofEnemy"></param>
 public Hueristic(ChessBoard board, ChessMove move, ChessColor colorofEnemy)
 {
     BoardBeforeMove = board.Clone();
     BoardAfterMove = board.Clone();
     BoardAfterMove.MakeMove(move);
     TheMove = move;
     //HValue = CalculateHueristicBasic(board, colorofEnemy);
     HValue = CalculateHueristicAdvanced(colorofEnemy);
 }

        private bool CheckOtherFigureIfValid(IBoard board, Position to, ChessColor color)
        {
            var otherFigure = board.GetFigureAtPosition(to);
            if (otherFigure != null && otherFigure.Color == color)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Purpose: Lower the Heuristic value if our queen is put in danger
        /// </summary>
        /// <param name="boardState"></param>
        /// <param name="color"></param>
        /// <returns></returns>
        private static int PieceSafety(char[] boardState, ChessColor color)
        {
            int hazardPenalty = 0;
            bool white = color == ChessColor.White;
            hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'q'), white) ? -400 : 0;
            hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'r'), white) ? -200 : 0;
            hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'n'), white) ? -150 : 0;
            hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'b'), white) ? -155 : 0;
            hazardPenalty += FENExtensions.PieceNotSafe(boardState, FENExtensions.GetPiecePos(boardState, white, 'p'), white) ? -40 : 0;

            return hazardPenalty;
        }

 public Node(ChessColor c, ChessMove m, Node p)
 {
     color = c;
     move = m;
     parent = p;
     if (parent == null)
     {
         depth = 0;
     }
     else
     {
         depth = parent.depth + 1;
     }
 }

		public GameGump( Mobile m, ChessGame game, ChessColor color, string message, bool move, bool moving ): base( 60, 25 )
		{
			m.CloseGump( typeof( GameGump ) );

			m_Game = game;
			m_Message = message;
			m_Color = color;
			m_Move = move;
			m_Moving = moving;

			if ( move && ! moving )
				m_Game.SendMoveTarget( m );

			MakeGump();
		}

        /// <summary>
        /// Purpose: Lower the Heuristic value if our queen is put in danger
        /// </summary>
        /// <param name="boardState"></param>
        /// <param name="color"></param>
        /// <returns></returns>
        private static int PieceSafety(byte[] boardState, ChessColor color)
        {
            int hazardPenalty = 0;
            bool white = color == ChessColor.White;

            hazardPenalty = FEN.GetPieceHazard (boardState, white);
            /*
                hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.q), white) ? -400 : 0;
            //hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.r), white) ? -200 : 0;
            //hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.n), white) ? -150 : 0;
            //hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.b), white) ? -155 : 0;
            //hazardPenalty += FEN.PieceNotSafe(boardState, FEN.GetPiecePos(boardState, white, FEN.p), white) ? -40 : 0;*/

            return hazardPenalty;
        }

        /// <summary>
        /// AIProfiler keeps the profiling stats for the AI. This object is what's passed
        /// to each AI when they call the Profiler property from IChessAI
        /// </summary>
        /// <param name="myColor">This is the color of the AI being profiled. It's mostly used when outputing the results</param>
        internal AIProfiler(ChessColor myColor)
        {
            NodesPerSecond = -1;
            MinisProfilerTag = -1;
            MaxsProfilerTag = -1;
            AIName = string.Empty;
            AIColor = myColor;
            Depth = 0;

            _numFrameworkMethods = Enum.GetValues(typeof(ProfilerMethodKey)).Length;
            IsEnabled = false;
            MoveDepths = new List<int>();
            MoveTimes = new List<TimeSpan>();
            Turns = new List<int[]>();
            FxTurns = new List<int[]>();
        }

        /// <summary>
        /// High Number = better board for your color
        /// </summary>
        /// <param name="board"></param>
        /// <param name="colorOfEnemyTeam"></param>
        /// <returns></returns>
        int CalculateBoardHP(ChessBoard board, ChessColor colorOfMyTeam)
        {
            int score = 0;
            for (int x = 0; x < 8; x++)
            {
                for (int y = 0; y < 8; y++)
                {
                    if (colorOfMyTeam == ChessColor.Black && BoardAfterMove[x, y] < ChessPiece.Empty) //if black
                        score += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
                    else if (colorOfMyTeam == ChessColor.White && BoardAfterMove[x, y] > ChessPiece.Empty) //if white
                        score += StudentAI.Piece.CalculatePieceValue(BoardAfterMove[x, y]);
                }
            }

            return score;
        }

        /// <summary>
        /// Converts a state based move to a ChessBoard move
        /// </summary>
        /// <param name="stateMove">The move the convert</param>
        /// <param name="playerColor">The color of hte player</param>
        /// <returns>The move corrected to work with ChessBoard</returns>
        public static ChessMove GetGameMove(ChessMove stateMove, ChessColor playerColor)
        {
            if (stateMove == null)
                return null;

            ChessMove gameMove = stateMove.Clone();

            if (playerColor == ChessColor.White)
            {
                gameMove.From.X = Columns - gameMove.From.X - 1;
                gameMove.From.Y = Rows - gameMove.From.Y - 1;
                gameMove.To.X = Columns - gameMove.To.X - 1;
                gameMove.To.Y = Rows - gameMove.To.Y - 1;
            }

            return gameMove;
        }

 /// <summary>
 /// gets a list of available moves for a color
 /// </summary>
 public static List<ChessMove> getmovesofcolor(StudentAI ai, ChessColor color, ChessBoard board)
 {
     List<ChessMove> colormoves = new List<ChessMove>();
     for (int y = 0; y < 8; y++)
     {
         for (int x = 0; x < 8; x++)
         {
             if (color == ChessColor.Black)
             {
                 switch (board[x, y])
                 {
                     case ChessPiece.BlackPawn:
                     case ChessPiece.BlackKnight:
                     case ChessPiece.BlackBishop:
                     case ChessPiece.BlackQueen:
                     case ChessPiece.BlackRook:
                     case ChessPiece.BlackKing:
                         colormoves.AddRange(getmovesofpiece(ai, color, board, new ChessLocation(x, y)));
                         break;
                     default:
                         break;
                 }
             }
             if (color == ChessColor.White)
             {
                 switch (board[x, y])
                 {
                     case ChessPiece.WhitePawn:
                     case ChessPiece.WhiteKnight:
                     case ChessPiece.WhiteBishop:
                     case ChessPiece.WhiteQueen:
                     case ChessPiece.WhiteRook:
                     case ChessPiece.WhiteKing:
                         colormoves.AddRange(getmovesofpiece(ai, color, board, new ChessLocation(x, y)));
                         break;
                     default:
                         break;
                 }
             }
         }
     }
     return colormoves;
 }