#include "chess.h"
#include "data.h"
/* last modified 01/06/16 */
/*
 *******************************************************************************
 *                                                                             *
 *   MakeMove() is responsible for updating the position database whenever a   *
 *   piece is moved.  It performs the following operations:  (1) update the    *
 *   board structure itself by moving the piece and removing any captured      *
 *   piece.  (2) update the hash keys.  (3) update material counts.  (4) then  *
 *   update castling status.  (5) and finally update number of moves since     *
 *   last reversible move.                                                     *
 *                                                                             *
 *   There are some special-cases handled here, such as en passant captures    *
 *   where the enemy pawn is not on the <target> square, castling which moves  *
 *   both the king and rook, and then rook moves/captures which give up the    *
 *   castling right to that side when the rook is moved.                       *
 *                                                                             *
 *   note:  side = 1 if white is to move, 0 otherwise.  enemy is the opposite  *
 *   and is 1 if it is not white to move, 0 otherwise.                         *
 *                                                                             *
 *******************************************************************************
 */
void MakeMove(TREE * RESTRICT tree, int ply, int side, int move) {
  uint64_t bit_move;
  int piece, from, to, captured, promote, enemy = Flip(side), cpiece;
#if defined(DEBUG)
  int i;
#endif

/*
 ************************************************************
 *                                                          *
 *  First, some basic information is updated for all moves  *
 *  before we do the piece-specific stuff.  We need to save *
 *  the current position and both hash signatures, and add  *
 *  the current position to the repetition-list for the     *
 *  side on move, before the move is actually made on the   *
 *  board.  We also update the 50 move rule counter which   *
 *  will be reset if a capture or pawn move is made here.   *
 *                                                          *
 *  If the en passant flag was set the previous ply, we     *
 *  have already used it to generate moves at this ply and  *
 *  we need to clear it before continuing.  If it is set,   *
 *  we also need to update the hash signature since the EP  *
 *  opportunity no longer exists after making any move at   *
 *  this ply (one ply deeper than when a pawn was advanced  *
 *  two squares).                                           *
 *                                                          *
 ************************************************************
 */
#if defined(DEBUG)
  ValidatePosition(tree, ply, move, "MakeMove(1)");
#endif
  tree->status[ply + 1] = tree->status[ply];
  tree->save_hash_key[ply] = HashKey;
  tree->save_pawn_hash_key[ply] = PawnHashKey;
  if (EnPassant(ply + 1)) {
    HashEP(EnPassant(ply + 1));
    EnPassant(ply + 1) = 0;
  }
  Reversible(ply + 1)++;
/*
 ************************************************************
 *                                                          *
 *  Now do the things that are common to all pieces, such   *
 *  as updating the bitboards and hash signature.           *
 *                                                          *
 ************************************************************
 */
  piece = Piece(move);
  from = From(move);
  to = To(move);
  captured = Captured(move);
  promote = Promote(move);
  bit_move = SetMask(from) | SetMask(to);
  cpiece = PcOnSq(to);
  ClearSet(bit_move, Pieces(side, piece));
  ClearSet(bit_move, Occupied(side));
  Hash(side, piece, from);
  Hash(side, piece, to);
  PcOnSq(from) = 0;
  PcOnSq(to) = pieces[side][piece];
/*
 ************************************************************
 *                                                          *
 *  Now do the piece-specific things by jumping to the      *
 *  appropriate routine.                                    *
 *                                                          *
 ************************************************************
 */
  switch (piece) {
    case pawn:
      HashP(side, from);
      HashP(side, to);
      Reversible(ply + 1) = 0;
      if (captured == 1 && !cpiece) {
        Clear(to + epsq[side], Pawns(enemy));
        Clear(to + epsq[side], Occupied(enemy));
        Hash(enemy, pawn, to + epsq[side]);
        HashP(enemy, to + epsq[side]);
        PcOnSq(to + epsq[side]) = 0;
        Material -= PieceValues(enemy, pawn);
        TotalPieces(enemy, pawn)--;
        TotalAllPieces--;
        captured = 0;
      }
      if (promote) {
        TotalPieces(side, pawn)--;
        Material -= PieceValues(side, pawn);
        Clear(to, Pawns(side));
        Hash(side, pawn, to);
        HashP(side, to);
        Hash(side, promote, to);
        PcOnSq(to) = pieces[side][promote];
        TotalPieces(side, occupied) += p_vals[promote];
        TotalPieces(side, promote)++;
        Material += PieceValues(side, promote);
        Set(to, Pieces(side, promote));
      } else if ((Abs(to - from) == 16) && (mask_eptest[to] & Pawns(enemy))) {
        EnPassant(ply + 1) = to + epsq[side];
        HashEP(to + epsq[side]);
      }
      break;
    case knight:
    case bishop:
    case queen:
      break;
    case rook:
      if (Castle(ply + 1, side) > 0) {
        if ((from == rook_A[side]) && (Castle(ply + 1, side) & 2)) {
          Castle(ply + 1, side) &= 1;
          HashCastle(1, side);
        } else if ((from == rook_H[side]) && (Castle(ply + 1, side) & 1)) {
          Castle(ply + 1, side) &= 2;
          HashCastle(0, side);
        }
      }
      break;
    case king:
      KingSQ(side) = to;
      if (Castle(ply + 1, side) > 0) {
        if (Castle(ply + 1, side) & 2)
          HashCastle(1, side);
        if (Castle(ply + 1, side) & 1)
          HashCastle(0, side);
        if (Abs(to - from) == 2) {
          Castle(ply + 1, side) = -1;
          piece = rook;
          if (to == rook_G[side]) {
            from = rook_H[side];
            to = rook_F[side];
          } else {
            from = rook_A[side];
            to = rook_D[side];
          }
          bit_move = SetMask(from) | SetMask(to);
          ClearSet(bit_move, Rooks(side));
          ClearSet(bit_move, Occupied(side));
          Hash(side, rook, from);
          Hash(side, rook, to);
          PcOnSq(from) = 0;
          PcOnSq(to) = pieces[side][rook];
        } else
          Castle(ply + 1, side) = 0;
      }
      break;
  }
/*
 ************************************************************
 *                                                          *
 *  If this is a capture move, we also have to update the   *
 *  information that must change when a piece is removed    *
 *  from the board.                                         *
 *                                                          *
 ************************************************************
 */
  if (captured) {
    Reversible(ply + 1) = 0;
    TotalAllPieces--;
    if (promote)
      piece = promote;
    Hash(enemy, captured, to);
    Clear(to, Pieces(enemy, captured));
    Clear(to, Occupied(enemy));
    Material -= PieceValues(enemy, captured);
    TotalPieces(enemy, captured)--;
    if (captured != pawn)
      TotalPieces(enemy, occupied) -= p_vals[captured];
    switch (captured) {
      case pawn:
        HashP(enemy, to);
        break;
      case knight:
      case bishop:
      case queen:
        break;
      case rook:
        if (Castle(ply + 1, enemy) > 0) {
          if ((to == rook_A[enemy]) && (Castle(ply + 1, enemy) & 2)) {
            Castle(ply + 1, enemy) &= 1;
            HashCastle(1, enemy);
          } else if ((to == rook_H[enemy]) && (Castle(ply + 1, enemy) & 1)) {
            Castle(ply + 1, enemy) &= 2;
            HashCastle(0, enemy);
          }
        }
        break;
      case king:
#if defined(DEBUG)
        Print(2048, "captured a king (Make)\n");
        for (i = 1; i <= ply; i++)
          Print(2048,
              "ply=%2d, phase=%d, piece=%2d,from=%2d,to=%2d,captured=%2d\n",
              i, tree->phase[i], Piece(tree->curmv[i]), From(tree->curmv[i]),
              To(tree->curmv[i]), Captured(tree->curmv[i]));
        Print(2048, "ply=%2d, piece=%2d,from=%2d,to=%2d,captured=%2d\n", i,
            piece, from, to, captured);
        if (log_file)
          DisplayChessBoard(log_file, tree->position);
#endif
        break;
    }
  }
#if defined(DEBUG)
  ValidatePosition(tree, ply + 1, move, "MakeMove(2)");
#endif
  return;
}

/* last modified 01/06/16 */
/*
 *******************************************************************************
 *                                                                             *
 *   MakeMoveRoot() is used to make a move at the root of the game tree,       *
 *   before any searching is done.  It uses MakeMove() to execute the move,    *
 *   but then copies the resulting position back to position[0], the actual    *
 *   board position.  It handles the special-case of the draw-by-repetition    *
 *   rule by clearing the repetition list when a non-reversible move is made,  *
 *   since no repetitions are possible once such a move is played.             *
 *                                                                             *
 *******************************************************************************
 */
void MakeMoveRoot(TREE * RESTRICT tree, int side, int move) {
  int player;

/*
 ************************************************************
 *                                                          *
 *  First, make the move and then reset the repetition      *
 *  index if the 50 move rule counter was reset to zero.    *
 *                                                          *
 ************************************************************
 */
  MakeMove(tree, 0, side, move);
  if (Reversible(1) == 0)
    rep_index = -1;
  tree->rep_list[++rep_index] = HashKey;
/*
 ************************************************************
 *                                                          *
 *  One odd action is to note if the castle status is       *
 *  currently negative, which indicates that that side      *
 *  castled during the previous search.  We simply set the  *
 *  castle status for that side to zero and we are done.    *
 *                                                          *
 *  We then copy this back to ply=0 status (which is the    *
 *  permanent game-board ply).                              *
 *                                                          *
 ************************************************************
 */
  for (player = black; player <= white; player++)
    Castle(1, player) = Max(0, Castle(1, player));
  tree->status[0] = tree->status[1];
}