module Fork
  extend self

  struct Move
    getter from : Int64
    getter to : Int64
    getter type : Int32
    getter promote_to : Int32
    getter castle : Int32
    getter double_push : Bool
    getter en_passant : Bool

    def initialize(@from : Int64, @to : Int64, @type : Int32, @promote_to : Int32 = 0, @castle = 0, @double_push = false, @en_passant = false)
    end

    def to_s
      "#{Fork.square_to_text(from)}#{Fork.square_to_text(to)}"
    end

    def set_promotion_piece(piece)
      @promote_to = piece
    end
  end

  module Moves
    extend self

    ROW  = 0x00000000000000FF_u64
    ROWS = Array(UInt64).new(8) { |i| ROW << (8 * i) }

    COL  = 0x0101010101010101_u64
    COLS = Array(UInt64).new(8) { |i| COL << i }

    BORDER = ROW[0] | ROW[7] | COL[0] | COL[7]

    WHITE_PAWN_MOVES = Array(UInt64).new(64) { |i| generate_pawn_moves(i, WHITE) }
    BLACK_PAWN_MOVES = Array(UInt64).new(64) { |i| generate_pawn_moves(i, BLACK) }

    WHITE_PAWN_ATTACKS = Array(UInt64).new(64) { |i| generate_pawn_attacks(i, WHITE) }
    BLACK_PAWN_ATTACKS = Array(UInt64).new(64) { |i| generate_pawn_attacks(i, BLACK) }

    EN_PASSANT_PHANTOM = Array(UInt64).new(64) { |i| en_passant_phantom(i) }

    KNIGHT_MOVES = Array(UInt64).new(64) { |i| generate_knight_moves(i) }

    KING_MOVES = Array(UInt64).new(64) { |i| generate_king_moves(i) }

    private def generate_pawn_moves(index, side)
      side == WHITE ? 1u64 << (index + 8) : 1u64 << (index - 8)
    end

    private def generate_pawn_attacks(index, side)
      sign = 1
      sign = -1 if side == BLACK
      row = index // 8
      return 0u64 if row == 7 && side == WHITE
      return 0u64 if row == 0 && side == BLACK
      b = 1_u64 << index
      (((b << (sign * 7)) | (b << (sign * 9))) & ROWS[row + (sign * 1)])
    end

    private def en_passant_phantom(i)
      row = i // 8
      if row == 1
        1u64 << i + 8
      elsif row == 6
        1u64 << i - 8
      else
        0u64
      end
    end

    private def generate_king_moves(index)
      row, col = index.divmod(8)
      bit = (1u64 << index)
      bitboard = 0u64
      bitboard = bitboard | (bit << 9) if col < 7
      bitboard = bitboard | (bit << 1) if col < 7
      bitboard = bitboard | (bit << -7) if col < 7

      bitboard = bitboard | (bit << 7) if col > 0
      bitboard = bitboard | (bit << -1) if col > 0
      bitboard = bitboard | (bit << -9) if col > 0

      bitboard = bitboard | (bit << 8)
      bitboard = bitboard | (bit << -8)

      bitboard
    end

    private def generate_knight_moves(index)
      row, col = index.divmod(8)
      bit = (1u64 << index)
      bitboard = 0u64
      bitboard = bitboard | (bit << 17) if col < 7
      bitboard = bitboard | (bit << 10) if col < 6
      bitboard = bitboard | (bit << 15) if col > 0
      bitboard = bitboard | (bit << 6) if col > 1

      bitboard = bitboard | (bit >> 17) if col > 0
      bitboard = bitboard | (bit >> 10) if col > 1
      bitboard = bitboard | (bit >> 15) if col < 7
      bitboard = bitboard | (bit >> 6) if col < 6

      bitboard
    end

    def generate(board)
      side = board.side
      player = board.player(side)
      enemy = board.player(Fork.enemy(side))
      player_occ = Fork.occupy(player)
      enemy_occ = Fork.occupy(enemy)
      both_occ = player_occ | enemy_occ
      free_occ = ~both_occ
      generated_moves = Array(Move).new(220)

      Fork.iterate_bitboard(player[PAWN]) do |start_index|
        moves = pawn_moves(side, start_index) & free_occ
        attacks = pawn_attacks(side, start_index)
        Fork.iterate_bitboard(moves | (attacks & enemy_occ)) do |end_index|
          row = end_index // 8
          if row == 0 || row == 7
            generated_moves << Move.new(start_index, end_index, PAWN, promote_to: KNIGHT)
            generated_moves << Move.new(start_index, end_index, PAWN, promote_to: BISHOP)
            generated_moves << Move.new(start_index, end_index, PAWN, promote_to: ROOK)
            generated_moves << Move.new(start_index, end_index, PAWN, promote_to: QUEEN)
          else
            generated_moves << Move.new(start_index, end_index, PAWN)
          end
        end
        if moves != 0
          row = start_index // 8
          if side == WHITE && row == 1
            if (1u64 << (start_index + 16)) & free_occ != 0
              generated_moves << Move.new(start_index, start_index + 16, PAWN, double_push: true)
            end
          elsif side == BLACK && row == 6
            if (1u64 << (start_index - 16)) & free_occ != 0
              generated_moves << Move.new(start_index, start_index - 16, PAWN, double_push: true)
            end
          end
        end
        if attacks & board.en_passant != 0
          generated_moves << Move.new(start_index, Fork.lsb(board.en_passant), PAWN, en_passant: true)
        end
      end

      Fork.iterate_bitboard(player[BISHOP]) do |start_index|
        moves = bishop_moves(start_index, player_occ, enemy_occ)
        Fork.iterate_bitboard(moves) do |end_index|
          generated_moves << Move.new(start_index, end_index, BISHOP)
        end
      end

      Fork.iterate_bitboard(player[KNIGHT]) do |start_index|
        moves = KNIGHT_MOVES[start_index] & (~player_occ)
        Fork.iterate_bitboard(moves) do |end_index|
          generated_moves << Move.new(start_index, end_index, KNIGHT)
        end
      end

      Fork.iterate_bitboard(player[ROOK]) do |start_index|
        moves = rook_moves(start_index, player_occ, enemy_occ)
        Fork.iterate_bitboard(moves) do |end_index|
          generated_moves << Move.new(start_index, end_index, ROOK)
        end
      end

      Fork.iterate_bitboard(player[QUEEN]) do |start_index|
        moves = rook_moves(start_index, player_occ, enemy_occ) | bishop_moves(start_index, player_occ, enemy_occ)
        Fork.iterate_bitboard(moves) do |end_index|
          generated_moves << Move.new(start_index, end_index, QUEEN)
        end
      end

      Fork.iterate_bitboard(player[KING]) do |start_index|
        moves = KING_MOVES[start_index] & (~player_occ)
        Fork.iterate_bitboard(moves) do |end_index|
          generated_moves << Move.new(start_index, end_index, KING)
        end
      end

      if side == WHITE
        if (board.castle & WHITE_KING_CASTLE != 0) &&
           !board.attacked?(E1, WHITE) && !board.attacked?(F1, WHITE) && !board.attacked?(G1, WHITE) &&
           (both_occ & (F1_BIT | G1_BIT)) == 0
          generated_moves << Move.new(E1, G1, KING, castle: WHITE_KING_CASTLE)
        end
        if (board.castle & WHITE_QUEEN_CASTLE != 0) &&
           !board.attacked?(C1, WHITE) && !board.attacked?(D1, WHITE) && !board.attacked?(E1, WHITE) &&
           (both_occ & (B1_BIT | C1_BIT | D1_BIT)) == 0
          generated_moves << Move.new(E1, C1, KING, castle: WHITE_QUEEN_CASTLE)
        end
      else
        if (board.castle & BLACK_KING_CASTLE != 0) &&
           !board.attacked?(E8, BLACK) && !board.attacked?(F8, BLACK) && !board.attacked?(G8, BLACK) &&
           (both_occ & (F8_BIT | G8_BIT)) == 0
          generated_moves << Move.new(E8, G8, KING, castle: BLACK_KING_CASTLE)
        end
        if (board.castle & BLACK_QUEEN_CASTLE != 0) &&
           !board.attacked?(C8, BLACK) && !board.attacked?(D8, BLACK) && !board.attacked?(E8, BLACK) &&
           (both_occ & (B8_BIT | C8_BIT | D8_BIT)) == 0
          generated_moves << Move.new(E8, C8, KING, castle: BLACK_QUEEN_CASTLE)
        end
      end

      generated_moves
    end

    def pawn_moves(side, i)
      side == WHITE ? WHITE_PAWN_MOVES[i] : BLACK_PAWN_MOVES[i]
    end

    def pawn_attacks(side, i)
      side == WHITE ? WHITE_PAWN_ATTACKS[i] : BLACK_PAWN_ATTACKS[i]
    end

    def bishop_moves(index, friends, enemies)
      row, col = index.divmod(8)
      bit = (1u64 << index)
      bitboard = 0u64

      1.upto(7) do |i|
        break if row + i > 7
        break if col + i > 7
        b = (bit << (i * 9))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      1.upto(7) do |i|
        break if row + i > 7
        break if col - i < 0
        b = (bit << (i * 7))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      1.upto(7) do |i|
        break if row - i < 0
        break if col + i > 7
        b = (bit << (i * (-7)))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      1.upto(7) do |i|
        break if row - i < 0
        break if col - i < 0
        b = (bit << (i * (-9)))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      bitboard
    end

    def rook_moves(index, friends, enemies)
      row, col = index.divmod(8)
      bitboard = 0u64

      (row + 1).upto(7) do |r|
        b = (1u64 << (r * 8 + col))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      (row - 1).downto(0) do |r|
        b = (1u64 << (r * 8 + col))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      (col - 1).downto(0) do |c|
        b = (1u64 << (row * 8 + c))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      (col + 1).upto(7) do |c|
        b = (1u64 << (row * 8 + c))
        break if b & friends != 0
        bitboard |= b
        break if b & enemies != 0
      end

      bitboard
    end
  end
end