#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <sys/types.h>
#include <vector>

#include "board/board.hpp"
#include "moves.hpp"

constexpr std::array<std::uint64_t, 64> computeKnightAttacks() {
  std::array<std::uint64_t, 64> attacks{};

  constexpr std::array<int, 8> knight_moves{-10, 6, 15, 17, 10, -6, -15, -17};

  for (int i = 0; i < 64; i++) {
    uint64_t bb = 0;
    for (int offset : knight_moves) {
      int next = i + offset;
      if (next >= 64 || next < 0) {
        continue;
      }
      const int fileDelta = (next % 8) - (i % 8);
      if (fileDelta != 1 && fileDelta != 2 && fileDelta != -1 &&
          fileDelta != -2) {
        continue;
      };
      bb |= 1ULL << next;
    }
    attacks[static_cast<size_t>(i)] = bb;
  }
  return attacks;
}

constexpr std::array<std::array<std::uint64_t, 64>, 2> computePawnAttacks() {
  std::array<std::array<std::uint64_t, 64>, 2> attacks{};

  for (bool color : {false, true}) {
    int step = 8 * (color ? 1 : -1);
    for (int i = 0; i < 64; i++) {
      uint64_t bb = 0;
      for (int fileOffset : {-1, 1}) {
        int next = i + fileOffset;
        next += step;
        if (next >= 64 || next < 0) {
          continue;
        }
        const int fileDelta = (next % 8) - (i % 8);
        if (fileDelta != 1 && fileDelta != 2 && fileDelta != -1 &&
            fileDelta != -2) {
          continue;
        };
        bb |= 1ULL << next;
      }
      attacks[static_cast<size_t>(color)][static_cast<size_t>(i)] = bb;
    }
  }
  return attacks;
}

constexpr std::array<std::uint64_t, 64> KNIGHT_ATTACKS = computeKnightAttacks();
constexpr std::array<std::array<std::uint64_t, 64>, 2> PAWN_ATTACKS =
    computePawnAttacks();

static void GenerateKnightMoves(const Game &g, std::vector<uint16_t> &moves,
                                bool GenerateQuietMoves) {
  uint64_t knights = g.PieceBitboards[g.turn][KNIGHT];
  while (knights != 0) {
    auto from = static_cast<uint8_t>(__builtin_ctzll(knights));
    knights &= knights - 1;
    uint64_t knight_attacks = KNIGHT_ATTACKS[static_cast<size_t>(from)];
    while (knight_attacks != 0) {
      auto next = static_cast<uint8_t>(__builtin_ctzll(knight_attacks));
      knight_attacks &= knight_attacks - 1;

      bool hasFriendlyPiece = g.turn
                                  ? (g.WhitePieceBitboard & (1ULL << next)) > 0
                                  : (g.BlackPieceBitboard & (1ULL << next)) > 0;

      bool isCaptuare = (g.PieceBitboard & (1ULL << next)) > 0;
      if (hasFriendlyPiece) {
        continue;
      }
      if (!GenerateQuietMoves && !isCaptuare) {
        continue;
      }
      moves.push_back(CreateMove(from, next));
    }
  }
};

void GeneratePawnMoves(const Game &g, uint8_t from,
                       std::vector<uint16_t> &moves, bool quietMoves) {
  Piece pawn = g.pieces[from];
  if (pawn.type != PAWN) {
    assert(false && "Calling generate pawn moves on non pawn");
    return;
  }
  const Position position = IndexToPosition(from);
  const int step = (pawn.color ? 1 : -1) * 8;
  int next = from + step;
  constexpr std::array<int, 2> startingRank = {6, 1};

  // wrap check
  if (position.rank + (pawn.color ? 1 : -1) < 0 ||
      position.rank + (pawn.color ? 1 : -1) >= 8) {
    return;
  }

  const bool oneStepOccupied = (g.PieceBitboard & (1ULL << (from + step))) != 0;

  // if piece it want to move to is none and it as legal move
  if (!oneStepOccupied && quietMoves) {
    if (IndexToPosition(next).rank == (pawn.color ? 7 : 0)) {
      moves.push_back(CreateMove(from, static_cast<uint8_t>(next), QUEEN));
      moves.push_back(CreateMove(from, static_cast<uint8_t>(next), ROOK));
      moves.push_back(CreateMove(from, static_cast<uint8_t>(next), BISHOP));
      moves.push_back(CreateMove(from, static_cast<uint8_t>(next), KNIGHT));
    } else {
      moves.push_back(CreateMove(from, static_cast<uint8_t>(next)));
    }

    const bool twoStepOccupied =
        (g.PieceBitboard & (1ULL << (from + (step * 2)))) != 0;

    if (position.rank == startingRank[static_cast<size_t>(pawn.color)] &&
        !twoStepOccupied) {
      moves.push_back(
          CreateMove(static_cast<uint8_t>(PositionToIndex(position)),
                     static_cast<uint8_t>(from + (step * 2))));
    }
  };

  uint64_t enpassant = 0;
  if (g.canEnpassant) {
    enpassant |= (1ULL << PositionToIndex(g.enPassant));
  }

  uint64_t pawn_attacks = PAWN_ATTACKS[static_cast<size_t>(pawn.color)][from];

  pawn_attacks &=
      (pawn.color ? g.BlackPieceBitboard : g.WhitePieceBitboard) | enpassant;

  while (pawn_attacks != 0) {
    auto i = static_cast<uint8_t>(__builtin_ctzll(pawn_attacks));
    pawn_attacks &= pawn_attacks - 1;

    if (IndexToPosition(i).rank == (pawn.color ? 7 : 0)) {
      moves.push_back(CreateMove(from, i, QUEEN));
      moves.push_back(CreateMove(from, i, KNIGHT));
      moves.push_back(CreateMove(from, i, ROOK));
      moves.push_back(CreateMove(from, i, BISHOP));
    } else {
      moves.push_back(CreateMove(from, i));
    }
  }
};
void GenerateKingMoves(Game *g, int from, std::vector<uint16_t> &moves,
                       bool GenerateQuietMoves) {
  if (g->pieces[from].type != KING) {
    assert(false && "calling generate king moves on non king");
    return;
  }
  if (g->pieces[from].color != g->turn) {
    assert(false && "calling generate king moves on king of opposite color");
    return;
  }
  constexpr std::array<int, 8> king_moves{-1, 1, 8, -8, -9, 9, -7, 7};
  for (int offset : king_moves) {
    uint8_t next = static_cast<uint8_t>(from + offset);
    if (next >= 64) {
      continue;
    }
    if (std::abs((next % 8) - (from % 8)) > 1) {
      continue;
    };
    if (g->pieces[next].type != NONEPIECE) {
      if (g->pieces[next].color == g->turn) {
        continue;
      };
    }
    if (!GenerateQuietMoves && g->pieces[next].type == NONEPIECE) {
      continue;
    }

    moves.push_back(CreateMove(static_cast<uint8_t>(from), next));
  }
};

std::vector<uint16_t> GetPseudoLegalMoves(Game *g, bool GenerateQuietMoves) {
  std::vector<uint16_t> moves;
  moves.reserve(40);

  GenerateKnightMoves(*g, moves, GenerateQuietMoves);

  constexpr std::array<int, 4> rook_Moves{-1, 1, 8, -8};
  constexpr std::array<int, 4> bishop_Moves{-9, 9, -7, 7};

  uint64_t piece_bitboard = g->PieceBitboard;
  while (piece_bitboard != 0) {
    uint8_t i = static_cast<uint8_t>(__builtin_ctzll(piece_bitboard));
    piece_bitboard &= piece_bitboard - 1;
    Piece piece = g->pieces[i];
    if (piece.type == NONEPIECE) {
      assert(false && "got none piece in piece bitboard");
    }
    if (piece.color != g->turn) {
      continue;
    }

    if (piece.type == PAWN) {
      GeneratePawnMoves(*g, i, moves, GenerateQuietMoves);
    }
    if (piece.type == BISHOP) {
      GenerateSlidingMoves(g, i, bishop_Moves, moves, GenerateQuietMoves);
    }
    if (piece.type == ROOK) {
      GenerateSlidingMoves(g, i, rook_Moves, moves, GenerateQuietMoves);
    }
    if (piece.type == QUEEN) {
      GenerateSlidingMoves(g, i, rook_Moves, moves, GenerateQuietMoves);
      GenerateSlidingMoves(g, i, bishop_Moves, moves, GenerateQuietMoves);
    }
    if (piece.type == KING) {
      GenerateKingMoves(g, i, moves, GenerateQuietMoves);
      if (GenerateQuietMoves) {
        GenerateCastlingMoves(i, g, moves);
      }
    };
  };

  return moves;
}
bool IsSquareAttacked(Game *g, Position square, bool byColor) {
  int target = PositionToIndex(square);

  // Pawn attacks: a pawn of byColor attacks diagonally "forward" from its
  // own perspective. White pawns (rank increases toward rank 7) attack from
  // one rank below the target; Black pawns attack from one rank above.
  int pawnRank = square.rank + (byColor ? -1 : 1);

  if (pawnRank >= 0 && pawnRank < 8) {
    for (int fileOffset : {-1, 1}) {
      int file = square.file + fileOffset;
      if (file < 0 || file >= 8)
        continue;

      Piece p = g->pieces[pawnRank * 8 + file];
      if (p.type == PAWN && p.color == byColor) {
        return true;
      }
    }
  }

  // Knight attacks
  constexpr std::array<int, 8> knightOffsets{-17, -15, -10, -6, 6, 10, 15, 17};
  for (int offset : knightOffsets) {
    int from = target + offset;
    if (from < 0 || from >= 64)
      continue;

    int fileDiff = std::abs((from % 8) - (target % 8));
    if (fileDiff != 1 && fileDiff != 2)
      continue;

    Piece p = g->pieces[from];
    if (p.type == KNIGHT && p.color == byColor)
      return true;
  }

  // King attacks
  constexpr std::array<int, 8> kingOffsets{-9, -8, -7, -1, 1, 7, 8, 9};
  for (int offset : kingOffsets) {
    int from = target + offset;
    if (from < 0 || from >= 64)
      continue;
    if (std::abs((from % 8) - (target % 8)) > 1)
      continue;

    Piece p = g->pieces[from];
    if (p.type == KING && p.color == byColor)
      return true;
  }

  // Rooks + queens (orthogonal rays)
  constexpr std::array<int, 4> rookDirs{-8, 8, -1, 1};
  for (int dir : rookDirs) {
    int pos = target;
    while (true) {
      int next = pos + dir;
      if (next < 0 || next >= 64)
        break;
      if ((dir == 1 || dir == -1) && next / 8 != pos / 8)
        break; // horizontal wrap

      Piece p = g->pieces[next];
      if (p.type != NONEPIECE) {
        if (p.color == byColor && (p.type == ROOK || p.type == QUEEN))
          return true;
        break;
      }
      pos = next;
    }
  }

  // Bishops + queens (diagonal rays)
  constexpr std::array<int, 4> bishopDirs{-9, 9, -7, 7};
  for (int dir : bishopDirs) {
    int pos = target;
    while (true) {
      int next = pos + dir;
      if (next < 0 || next >= 64)
        break;
      if (std::abs((next % 8) - (pos % 8)) != 1)
        break; // diagonal wrap

      Piece p = g->pieces[next];
      if (p.type != NONEPIECE) {
        if (p.color == byColor && (p.type == BISHOP || p.type == QUEEN))
          return true;
        break;
      }
      pos = next;
    }
  }

  return false;
}
std::vector<uint16_t> GetLegalMoves(Game *g, bool quietMove) {
  std::vector<uint16_t> moves = GetPseudoLegalMoves(g, quietMove);
  std::vector<uint16_t> legalMoves;
  legalMoves.reserve(moves.size());

  for (const uint16_t &move : moves) {
    Undo undo = MakeMove(move, g);

    bool legal = true;

    Position kingPosition = FindKing(g, !g->turn);

    // opponent attacks our king?
    if (IsSquareAttacked(g, kingPosition, g->turn)) {
      legal = false;
    }

    UndoMove(undo, g);

    if (legal) {
      legalMoves.push_back(move);
    }
  }

  return legalMoves;
}
GameState GetNewGameState(Game *g) {
  // make sure we dont override game ending states
  if (g->state == DRAW || g->state == WHITE_WON || g->state == BLACK_WON) {
    return g->state;
  }

  auto legalMoves = GetLegalMoves(g);

  if (legalMoves.empty()) {
    Position kingPosition = FindKing(g, g->turn);

    bool check = IsSquareAttacked(g, kingPosition, !g->turn);

    if (check) {
      g->state = g->turn ? BLACK_WON : WHITE_WON;
    } else {
      g->state = DRAW;
    }
  }
  return g->state;
}

Position IndexToPosition(int i) {
  auto rank = static_cast<uint8_t>(i / 8); // 0-7
  auto file = static_cast<uint8_t>(i % 8); // 0-7
  return {.rank = rank, .file = file};
}

void GenerateSlidingMoves(Game *b, int from,
                          const std::array<int, 4> &directions,
                          std::vector<uint16_t> &moves,
                          bool GenerateQuietMoves) {
  for (uint i = 0; i < directions.size(); i++) {
    int direction = directions[i];

    int i2 = from;
    while (true) {
      i2 += direction;
      int oldFile = (i2 - direction) % 8;
      int newFile = i2 % 8;

      if (direction == 7 || direction == -7 || direction == 9 ||
          direction == -9) {
        if (std::abs(newFile - oldFile) != 1) {
          break;
        }
      }
      if (i2 >= 64 || i2 < 0) {
        break;
      }

      if ((direction == 1 || direction == -1) &&
          (i2 / 8 != (i2 - direction) / 8)) {
        break;
      }
      if (b->pieces[i2].color == b->turn && b->pieces[i2].type != NONEPIECE) {
        break;
      }
      if (!GenerateQuietMoves && b->pieces[i2].type == NONEPIECE) {
        continue;
      }
      moves.push_back(
          CreateMove(static_cast<uint8_t>(from), static_cast<uint8_t>(i2)));
      if (b->pieces[i2].color != b->turn && b->pieces[i2].type != NONEPIECE) {
        break;
      }
    }
  };
};
void GenerateCastlingMoves(int from, Game *g, std::vector<uint16_t> &moves) {
  Piece piece = g->pieces[from];
  if (piece.type != KING) {
    assert(false && "Calling generate castling moves on non king piece");
    std::cout << "Internal error\n";
    exit(1);
  }
  if (from != 60 && !g->turn) {
    return;
  }
  if (from != 4 && g->turn) {
    return;
  }
  bool oneToRight = (g->PieceBitboard & (1ULL << (from + 1))) > 0;
  bool twoToRight = (g->PieceBitboard & (1ULL << (from + 2))) > 0;
  bool oneToLeft = (g->PieceBitboard & (1ULL << (from - 1))) > 0;
  bool twoToLeft = (g->PieceBitboard & (1ULL << (from - 2))) > 0;
  bool threeToLeft = (g->PieceBitboard & (1ULL << (from - 3))) > 0;

  Position kingPosition = FindKing(g, g->turn);

  bool check = IsSquareAttacked(g, kingPosition, !g->turn);
  if (check) {
    return;
  }
  auto pathIsSafe = [&](int step) {
    return !IsSquareAttacked(g, IndexToPosition(from + step), !g->turn) &&
           !IsSquareAttacked(g, IndexToPosition(from + (2 * step)), !g->turn);
  };
  if (g->turn) {
    // white
    if (!oneToRight && !twoToRight && g->whiteCastleKing && pathIsSafe(1)) {
      moves.push_back(CreateMove(static_cast<uint8_t>(from),
                                 static_cast<uint8_t>(from + 2)));
    }
    if (!oneToLeft && !twoToLeft && !threeToLeft && g->whiteCastleQueen &&
        pathIsSafe(-1)) {
      moves.push_back(CreateMove(static_cast<uint8_t>(from),
                                 static_cast<uint8_t>(from - 2)));
    }
  }
  if (!g->turn) {
    // black
    if (!oneToRight && !twoToRight && g->blackCastleKing && pathIsSafe(1)) {
      moves.push_back(CreateMove(static_cast<uint8_t>(from),
                                 static_cast<uint8_t>(from + 2)));
    }
    if (!oneToLeft && !twoToLeft && !threeToLeft && g->blackCastleQueen &&
        pathIsSafe(-1)) {
      moves.push_back(CreateMove(static_cast<uint8_t>(from),
                                 static_cast<uint8_t>(from - 2)));
    }
  }
}