#include <locale.h>
#include <stdio.h>
#include <string.h>

#include "config.h"
#include "pieces.h"


void print_board(int board[128]) {
  for (int rank = 7; rank >= 0; rank--) {
    printf("%i|", rank + 1);
    for (int file = 0; file < 8; file++) {
      int piece = board[rank * 16 + file];
      printf("%s ", pieces[piece]);
    }
    printf("\n");
  }
  printf("  a b c d e f g h\n");
}

void parse_FEN(char* FEN, int board[128]) {
  // TODO: parse everything, not position only
  int rank = 7;
  int file = 0;
  size_t lenght = strlen(FEN);

  for (int k = 0; k < lenght; k++) {
    if (FEN[k] > '0' && FEN[k] <= '8') {
      int last_file = file + FEN[k] - '0';
      for (file; file < last_file; file++) {
        board[rank * 16 + file] = EMPTY;
      }
    } else {
      switch (FEN[k]) {
        case 'r':
          board[rank * 16 + file] = BLACK | ROOK;
          break;
        case 'R':
          board[rank * 16 + file] = ROOK;
          break;
        case 'n':
          board[rank * 16 + file] = BLACK | KNIGHT;
          break;
        case 'N':
          board[rank * 16 + file] = KNIGHT;
          break;
        case 'b':
          board[rank * 16 + file] = BLACK | BISHOP;
          break;
        case 'B':
          board[rank * 16 + file] = BISHOP;
          break;
        case 'q':
          board[rank * 16 + file] = BLACK | QUEEN;
          break;
        case 'Q':
          board[rank * 16 + file] = QUEEN;
          break;
        case 'k':
          board[rank * 16 + file] = BLACK | KING;
          break;
        case 'K':
          board[rank * 16 + file] = KING;
          break;
        case 'p':
          board[rank * 16 + file] = BLACK | PAWN;
          break;
        case 'P':
          board[rank * 16 + file] = PAWN;
          break;
        case '/':
          rank--;
          file = -1; // so that it becomes 0
          break;
        case ' ':
          return;
        default:
          board[rank * 16 + file] = KNIGHT;
      }
      file++;
    }
  }
}

int notation_to_index(int file, int rank) {
  return (rank - 1) * 16 + (file - 'a');
}

void index_to_notation(int index, char notation[2]) {
  notation[0] = (index & FILE_MASK) + 'a';
  notation[1] = (index >> 4) + '1';
}

void print_move(int move[2]) {
  char move_in_notation[] = "xy XY";
  index_to_notation(move[0], move_in_notation);
  index_to_notation(move[1], move_in_notation + 3);
  printf("%s\n", move_in_notation);
};

void input_move(int move[2]) {
  char file;
  int rank;
  char file_destination;
  int rank_destination;

  scanf(" %c%i %c%i", &file, &rank, &file_destination, &rank_destination);

  move[0] = notation_to_index(file, rank);
  move[1] = notation_to_index(file_destination, rank_destination);
};

int validate_move(int move[2], int color, int* board) {
  int origin = move[0];
  int destination = move[1];

  if ((origin & 0x88) || (destination & 0x88)) return -1;

  int piece = board[origin];
  int* legal_move;

  if (piece % 2 != color) return -3;

  switch (piece & NO_COLOR) {
    case KNIGHT:
      legal_move = knightMoves;
      break;
    case BISHOP:
      legal_move = bishopMoves;
      break;
    case ROOK:
      legal_move = rookMoves;
      break;
    case QUEEN:
      legal_move = queenMoves;
      break;
    case KING:
      legal_move = kingMoves;
      break;
    case PAWN:
      if (piece & BLACK) legal_move = blackPawnMoves;
      else legal_move = pawnMoves;
      break;
    default:
      return -2;
  }

  while(*legal_move) {
    for (int square = origin + *legal_move; !(square & 0x88); square += *legal_move) {
      int target_piece = board[square];

      if (square == destination) {
        if (target_piece & color) return -4;
        return target_piece;
      }

      if (target_piece != EMPTY) break;
      if ((piece & NO_COLOR) == PAWN || piece == KNIGHT || piece == KING) break;
    }
    legal_move++;
  }

  return -5;
}

char* VALIDATION_ERRORS[] = {
  "trying to access off-board square",
  "no piece on origin square",
  "opponent piece on origin square",
  "trying to capture your own piece",
  "move is not allowed",
};

int apply_move(int move[2], int* board) {
  int origin = move[0];
  int destination = move[1];
  int piece = board[origin];

  board[destination] = piece;
  board[origin] = EMPTY;

  return board[destination];
}

int main() {
  int board[128];
  parse_FEN(DEFAULT_FEN, board);
  print_board(board);


  int move[2];
  int color = 0;

  while (1) {
    printf("Enter a move for %s:\n", COLORS[color]);
    input_move(move);

    int error = validate_move(move, color, board);
    if (error < 0) {
      printf("Invalid move: %s!\n", VALIDATION_ERRORS[-1 - error]);
    } else {
      apply_move(move, board);
      print_board(board);
      color ^= 1;
    }
  }

	return 0;
}