#include "game_state.h"
#include "stdio.h"
#include <string.h>
#include "pawn.h"
#include "king.h"
#include "piece_logic.h"

static uint8_t Saved_Binary_Board[8] = {0};
static Game_State_t Game_State = {
    .game_over = false,
    .error_detected = false,
    .player_turn = WHITE_TURN,
    .turn_state = BEGINNING,
    .board_state = {0},
    .board_pieces = {0},
    .selected_piece = SQUARE_EMPTY,
    .castling_allowed = {{true, true},{true, true}},
    .en_passant = -1,
};
static uint8_t Error_Count = 0u;
static bool Check[2u] = {false, false};


/**
 * @brief  Function for clearing all of the lights on the board. Except for error moves.
 * @retval None
 */
void clear_board_state(void)
{
    for (size_t i = 0; i < 8; i++)
    {
        for (size_t j = 0; j < 8; j++)
        {
            if(Game_State.board_state[i*8+j] != ERROR_MOVE)
            {
                Game_State.board_state[i*8+j] = LIGHT_OFF;
            }
        }
    }

}


bool Set_Light(uint8_t piece, uint8_t row, uint8_t column, uint8_t state)
{
    bool ret_val = false;
    if (!Check_If_Move_Caused_Check(piece, row, column, &Game_State))
    {
        Game_State.board_state[row*8+column] = state;
        ret_val = true;
    }
    return ret_val;
}


/**
 * @brief  Function for switching the players turn. Incharge of handling the state machine reset.
 */
static void Switch_Turns(void)
{
    Game_State.turn_state = BEGINNING;
    Game_State.player_turn = !Game_State.player_turn;
    // Square is safe assumes the other team is trying to attack the square so for example at the end of
    // White's turn we want to see if the black king is now in check, so we will switch teams and then
    // Check if the current kings locations is safe. If it is safe then check is false, if it isnt safe then check is true.
    uint8_t white_black_idx = Game_State.player_turn ? 0u : 1u;

    Check[white_black_idx] = Check_Current_Players_Check_Status(&Game_State);

    //Last thing we need to check before switching turns is to check if the game is over.
    bool player_can_play = Check_If_Player_Can_Move(Game_State.player_turn, &Game_State);
    if(!player_can_play)
    {
        Game_State.game_over = true;
        Game_State.player_turn = !Game_State.player_turn;
        Game_State.error_detected = !Check[white_black_idx];
    }

}


/**
 * @brief  Function for toggeling a square's state.
 * @param  row_idx: row location that was toggled.
 * @param  column_idx: column location that was toggled.
 * @retval None
 */
static void Board_Square_Was_Toggled(uint8_t row_idx, uint8_t col_idx)
{
    if (Game_State.error_detected)
    {
        if (Game_State.board_state[row_idx*8+col_idx] == PIECE_ORIGIN)
        {
            Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
            Game_State.selected_piece = SQUARE_EMPTY;
            clear_board_state();
            Game_State.turn_state = BEGINNING;
        }
        else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_HERE)
        {
            Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
            Game_State.selected_piece = SQUARE_EMPTY;
            Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;

            if (Game_State.selected_piece == SQUARE_EMPTY)
            {
                Game_State.turn_state = BEGINNING;
                Game_State.player_turn = !Game_State.player_turn;
            }
        }
        else if (Game_State.board_state[row_idx*8+col_idx] == ERROR_MOVE)
        {
            Error_Count--;
            Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
            /* All Errors have been rectified so we can go back to where we were.*/
            if(Error_Count == 0u)
            {
                Game_State.error_detected = false;
            }
        }
        else
        {
            Error_Count++;
            Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
        }

    }
    else
    {
        switch (Game_State.turn_state)
        {
            /* We are waiting till the player who's turn it is picks up a piece that is on their team */
            case BEGINNING:
            {
                if ((Game_State.board_pieces[row_idx*8+col_idx] != SQUARE_EMPTY) && (white_team(Game_State.board_pieces[row_idx*8+col_idx]) == Game_State.player_turn))
                {
                    Game_State.selected_piece = Game_State.board_pieces[row_idx*8+col_idx];
                    Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
                    (void)Mark_Potential_Moves(Game_State.selected_piece, col_idx, row_idx, &Game_State);
                    Game_State.selected_piece_origin = row_idx*8+col_idx;
                    Game_State.board_state[row_idx*8+col_idx] = PIECE_ORIGIN;
                    Game_State.turn_state = IN_PROGRESS;
                }
                else
                {
                    if(!Converting_Pawn_If_Applicable(row_idx, col_idx, &Game_State))
                    {
                        Game_State.error_detected = true;
                        Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
                        Error_Count++;
                    }
                }

                break;
            }
            /* Person is in the middle of taking a turn for example they might already have a piece in the hand*/
            case IN_PROGRESS:
            {
                if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_MOVE)
                {
                    Check_If_Moving_King(row_idx, col_idx, &Game_State);
                    Check_If_Converting_Pawn(row_idx, col_idx, &Game_State);
                    Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
                    Game_State.selected_piece = SQUARE_EMPTY;
                    Mark_En_Passant_Target(row_idx*8+col_idx, &Game_State);
                    clear_board_state();
                    Switch_Turns();
                }
                else if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_TAKE)
                {
                    Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
                    Game_State.turn_state = FINALIZING;
                    clear_board_state();
                    Game_State.board_state[row_idx*8+col_idx] = PIECE_NEEDS_TO_BE_HERE;
                }
                else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_ORIGIN)
                {
                    Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
                    Game_State.selected_piece = SQUARE_EMPTY;
                    clear_board_state();
                    Game_State.turn_state = BEGINNING;
                }
                else if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_CASTLE)
                {
                    Check_If_Moving_King(row_idx, col_idx, &Game_State);
                    Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
                    Game_State.selected_piece = SQUARE_EMPTY;
                    clear_board_state();
                    if(col_idx == 2u)
                    {
                        Game_State.board_state[row_idx*8+3u] = PIECE_NEEDS_TO_BE_HERE;
                        Game_State.board_state[row_idx*8+0u] = PIECE_NEEDS_TO_BE_REMOVED;
                    }
                    else if(col_idx == 6u)
                    {
                        Game_State.board_state[row_idx*8+5u] = PIECE_NEEDS_TO_BE_HERE;
                        Game_State.board_state[row_idx*8+7u] = PIECE_NEEDS_TO_BE_REMOVED;
                    }
                    else
                    {
                        /* Do nothing. */
                    }

                }
                else if (Game_State.board_state[row_idx*8+col_idx] == EN_PASSANT)
                {
                    Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
                    Game_State.selected_piece = SQUARE_EMPTY;
                    clear_board_state();
                    if(row_idx == 2u)
                    {
                        Game_State.board_state[row_idx*8+col_idx+8] = EN_PASSANT_REMOVE;
                    }
                    else if(row_idx == 5u)
                    {
                        Game_State.board_state[row_idx*8+col_idx-8] = EN_PASSANT_REMOVE;
                    }
                    Game_State.turn_state = FINALIZING;
                }
                else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_REMOVED)
                {
                    Game_State.selected_piece = Game_State.board_pieces[row_idx*8+col_idx];
                    Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
                    Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
                    Game_State.turn_state = FINALIZING;
                }
                else
                {
                    Game_State.error_detected = true;
                    Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
                    Error_Count++;
                }
                break;
            }
            /* Player still needs to do something to complete their turn, like complete castle, en pessant, or converting a pawn*/
            case FINALIZING:
            {
                if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_HERE)
                {
                    Check_If_Moving_King(row_idx, col_idx, &Game_State);
                    Check_If_Converting_Pawn(row_idx, col_idx, &Game_State);
                    Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_piece;
                    Game_State.selected_piece = SQUARE_EMPTY;
                    Game_State.board_state[row_idx*8+col_idx] =  LIGHT_OFF;
                }
                else if (Game_State.board_state[row_idx*8+col_idx] == EN_PASSANT_REMOVE)
                {
                    Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
                    Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;

                }
                else
                {
                    if(!Converting_Pawn_If_Applicable(row_idx, col_idx, &Game_State))
                    {
                        Game_State.error_detected = true;
                        Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
                        Error_Count++;
                    }
                }

                if (Game_State.selected_piece == SQUARE_EMPTY)
                {
                    Switch_Turns();
                }

                break;
            }
            default:
            {
                break;
            }
        }
    }
}

void Board_get_lights_and_state(uint8_t * board_state, uint8_t * board_pieces)
{
    memcpy(board_state, Game_State.board_state, sizeof(Game_State.board_state));
    memcpy(board_pieces, Game_State.board_pieces, sizeof(Game_State.board_pieces));
}


/**
 * @brief  The Board changed so now we have to see what is different and act accordingly.
 * @note   Yes i know the design of this seems really bad but it's important to remember this is supposed to simulate the chess board I'm creating.
 *         so I'm designing it this way because of the hardware that I'm using.
 * @retval None
 */
void Board_Changed(uint8_t current_binary_board[8])
{
    for (uint8_t j = 0u; j < 8u; j++)
    {
        uint8_t difference = (current_binary_board[j] ^ Saved_Binary_Board[j]);
        if (difference != 0u)
        {
            for (uint8_t i = 0u; i < 8u; i++)
            {
                if((difference & (1u << i)) != 0u)
                {
                    Board_Square_Was_Toggled(j, i);
                }
            }
        }
        Saved_Binary_Board[j] = current_binary_board[j];
    }
}


/**
 * @brief  Function for initializing the board
 * @note
 * @retval None
 */
void game_state_init(void)
{
    for (uint8_t i = 0u; i < 8u; i++)
    {
        for (uint8_t j = 0u; j < 8u; j++)
        {
            Game_State.board_pieces[i*8+j] = SQUARE_EMPTY;
        }
    }
    Saved_Binary_Board[0] = 0xFF;
    Saved_Binary_Board[1] = 0xFF;
    Saved_Binary_Board[6] = 0xFF;
    Saved_Binary_Board[7] = 0xFF;

    //Place black pieces
    Game_State.board_pieces[0*8+0] = ROOK_BLACK;
    Game_State.board_pieces[0*8+7] = ROOK_BLACK;
    Game_State.board_pieces[0*8+1] = KNIGHT_BLACK;
    Game_State.board_pieces[0*8+6] = KNIGHT_BLACK;
    Game_State.board_pieces[0*8+2] = BISHOP_BLACK;
    Game_State.board_pieces[0*8+5] = BISHOP_BLACK;
    Game_State.board_pieces[0*8+3] = QUEEN_BLACK;
    Game_State.board_pieces[0*8+4] = KING_BLACK;
    Game_State.board_pieces[7*8+0] = ROOK_WHITE;
    Game_State.board_pieces[7*8+7] = ROOK_WHITE;
    Game_State.board_pieces[7*8+1] = KNIGHT_WHITE;
    Game_State.board_pieces[7*8+6] = KNIGHT_WHITE;
    Game_State.board_pieces[7*8+2] = BISHOP_WHITE;
    Game_State.board_pieces[7*8+5] = BISHOP_WHITE;
    Game_State.board_pieces[7*8+3] = QUEEN_WHITE;
    Game_State.board_pieces[7*8+4] = KING_WHITE;

    for (uint8_t i = 0; i < 8; i++)
    {
        Game_State.board_pieces[1*8+i] = PAWN_BLACK;
        Game_State.board_pieces[6*8+i] = PAWN_WHITE;
    }
}

Game_State_t * Board_get_game_state(void)
{
    return &Game_State;
}