#include "user_interface_abstraction.h"
#include "chess_board.h"
#include <stack>
#include <string.h>

#define MARGIN 300

const char File_Names[12][17] = {"pawn_white.bmp", "pawn_black.bmp",
                                    "king_white.bmp", "king_black.bmp",
                                    "tower_white.bmp", "tower_black.bmp",
                                    "horse_white.bmp", "horse_black.bmp",
                                    "bishop_white.bmp", "bishop_black.bmp",
                                    "queen_white.bmp", "queen_black.bmp",
                                    };

static int Height;
static int Width;
static SDL_Texture * Board_Texture;
static SDL_Rect Rectangle;
static int Board_Width;
SDL_Surface *bitmapSurface = NULL;
SDL_Texture * bitmapTextures[12] = {NULL};

static uint8_t Current_Binary_Board[12] = {0};


/**
 * @brief  Funtion for that will draw the current state of the board including pecies and colors for suggested and possible moves.
 * @param  *p_renderer pointer to the renderer object: 
 * @retval None
 */
static void ui_draw_board(SDL_Renderer *p_renderer, uint8_t board_lights[12][8], uint8_t board_state[12][8])
{
    SDL_SetRenderTarget(p_renderer, Board_Texture);
    SDL_SetRenderDrawColor(p_renderer, 0x7f, 0x7f, 0x7f, 0);
    SDL_RenderClear(p_renderer);
    SDL_RenderDrawRect(p_renderer, &Rectangle);
    SDL_SetRenderDrawColor(p_renderer, 0xFF, 0xFF, 0xFF, 0x00);
    Rectangle.w = Board_Width;
    Rectangle.h = Board_Width;
    Rectangle.x = (Width - Board_Width) / 2;
    Rectangle.y = (Height - Board_Width) / 2;
    SDL_RenderFillRect(p_renderer, &Rectangle);
    SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
    const int square_size = Board_Width / 8;
    int starting_x = Rectangle.x;
    Rectangle.w = square_size;
    Rectangle.h = square_size;
    for (size_t j = 0; j < 8; j++)
    {
        Rectangle.x = starting_x;
        for (size_t i = 0; i < 8; i++)
        {
            if ((board_lights[j][i] == POTENTIAL_MOVE) || (board_lights[j][i] == POTENTIAL_CASTLE))
            {
                SDL_SetRenderDrawColor(p_renderer, 0x00, 0xFF, 0x00, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
            }
            else if ((board_lights[j][i] == POTENTIAL_TAKE) || (board_lights[j][i] == PIECE_NEEDS_TO_BE_HERE) || (board_lights[j][i] == PIECE_NEEDS_TO_BE_REMOVED))
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0x00, 0x00, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
            }
            else if (board_lights[j][i] == PIECE_ORIGIN)
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0x00, 0xFF, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
            }
            else if (board_lights[j][i] == ERROR_MOVE)
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0xFF, 0x00, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
            }
            else if (board_lights[j][i] == CONVERTING_PAWN)
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0x3B, 0x7A, 0x57);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
            }
            else if (((i % 2) + (j % 2))  == 1)
            {
                SDL_RenderFillRect(p_renderer, &Rectangle);
            }
            else
            {
                /* code */
            }
            
            if((board_state[j][i] & 0x0Fu) != SQUARE_EMPTY)
            {
                SDL_RenderCopy(p_renderer, bitmapTextures[(board_state[j][i] & 0x0Fu)], NULL, &Rectangle);
            }

            Rectangle.x += square_size;
        }
        Rectangle.y += square_size;
    }

    Rectangle.x = ((Width - Board_Width) / 2) - (2 * square_size);
    Rectangle.y = (Height - Board_Width) / 2;
    int starting_y = Rectangle.y;
    SDL_SetRenderDrawColor(p_renderer, 0x6F, 0x6f, 0x6f, 0x00);

    /* Now we draw the jail */
    for (size_t j = 8; j < 12; j++)
    {
        Rectangle.y = starting_y;
        for (size_t i = 0; i < 8; i++)
        {
            if (board_lights[j][i] == PIECE_NEEDS_TO_BE_HERE)
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0x00, 0x00, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x6F, 0x6F, 0x6F, 0x00);
            }
            else if (board_lights[j][i] == ERROR_MOVE)
            {
                SDL_SetRenderDrawColor(p_renderer, 0xFF, 0xFF, 0x00, 0x00);
                SDL_RenderFillRect(p_renderer, &Rectangle);
                SDL_SetRenderDrawColor(p_renderer, 0x6F, 0x6F, 0x6F, 0x00);
            }
            else
            {
                SDL_RenderFillRect(p_renderer, &Rectangle);
            }
            

            
            if ((board_state[j][i] & 0x0Fu) != SQUARE_EMPTY)
            {
                SDL_RenderCopy(p_renderer, bitmapTextures[(board_state[j][i] & 0x0Fu)], NULL, &Rectangle);
            }


            Rectangle.y += square_size;
        }
        /*If we are at the end of second jail row, jump to the other side */
        if(j == 9)
        {
            Rectangle.x += (Board_Width + square_size);
        }
        else
        {
            Rectangle.x += square_size;
        }
    }

    SDL_SetRenderTarget(p_renderer, NULL);
    SDL_RenderCopy(p_renderer, Board_Texture, NULL, NULL);
}


void ui_redraw_board(SDL_Renderer *p_renderer)
{
    uint8_t board_lights[12][8];
    uint8_t board_state[12][8];
    Board_get_lights_and_state(board_lights, board_state);
    ui_draw_board(p_renderer, board_lights, board_state);
}

/**
 * @brief  Function for resizing the display of the board
 * @param  p_renderer: pointer to the renderer
 * @param  w: width of the new window
 * @param  h: hight of the new window
 * @retval None
 */
void ui_resize(SDL_Renderer *p_renderer, int w, int h)
{
    Width = w;
    Height = h;
    SDL_DestroyTexture(Board_Texture);
    Board_Texture = SDL_CreateTexture(p_renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h);
    Board_Width = ((w > h) ? h : w) - MARGIN;
    // get rid of rounding errors
    Board_Width -= Board_Width % 8;
}

/**
 * @brief  Function for registering an incoming click
 * @param  p_renderer: Pointer to the renderer
 * @param  x: x location of the click
 * @param  y: y location of the click 
 * @retval 
 */
void ui_click(SDL_Renderer *p_renderer, int x, int y)
{
    SDL_Point const point = {x, y};
    const int square_size = Board_Width / 8;
    Rectangle.w = Board_Width + (4 * square_size);
    Rectangle.h = Board_Width;
    Rectangle.x = ((Width - Board_Width) / 2) - (2 * square_size);
    Rectangle.y = (Height - Board_Width) / 2;
    if (SDL_PointInRect(&point, &Rectangle))
    {
        Rectangle.x = (Width - Board_Width) / 2;
        Rectangle.w = Board_Width;
        int starting_y = Rectangle.y;
        const int starting_x = Rectangle.x;
        Rectangle.w = square_size;
        Rectangle.h = square_size;
        for (size_t j = 0; j < 8; j++)
        {
            Rectangle.x = starting_x;
            for (size_t i = 0; i < 8; i++)
            {
                if(SDL_PointInRect(&point, &Rectangle))
                {
                    Current_Binary_Board[j] ^= (1u << i);
                    Board_Changed(Current_Binary_Board);
                    goto draw_square;
                }
                Rectangle.x += square_size;
            }
            Rectangle.y += square_size;
        }

        Rectangle.x = ((Width - Board_Width) / 2) - (2 * square_size);
        /* Now we draw the jail */
        for (size_t j = 8; j < 12; j++)
        {
            Rectangle.y = starting_y;
            for (size_t i = 0; i < 8; i++)
            {
                if (SDL_PointInRect(&point, &Rectangle))
                {
                    Current_Binary_Board[j] ^= (1u << i);
                    Board_Changed(Current_Binary_Board);
                    goto draw_square;
                }
                Rectangle.y += square_size;
            }
            /*If we are at the end of second jail row, jump to the other side */
            if (j == 9)
            {
                Rectangle.x += (Board_Width + square_size);
            }
            else
            {
                Rectangle.x += square_size;
            }
        }
        draw_square:
        SDL_SetRenderTarget(p_renderer, Board_Texture);
        ui_redraw_board(p_renderer);//, Board_Lights, Board_State);
        SDL_RenderCopy(p_renderer, Board_Texture, NULL, NULL);
        SDL_RenderPresent(p_renderer);
    }
}

void ui_init(SDL_Renderer *p_renderer)
{   
    Current_Binary_Board[0] = 0xFF;
    Current_Binary_Board[1] = 0xFF;
    Current_Binary_Board[6] = 0xFF;
    Current_Binary_Board[7] = 0xFF;

    for (uint8_t i = 0; i < 12; i++)
    {
        //location of all the sprites plus the size of file names
        char file[25] = "sprites/";
        memcpy(&file[8], File_Names[i], 16);
        bitmapSurface = SDL_LoadBMP(file);
        bitmapTextures[i] = SDL_CreateTextureFromSurface(p_renderer, bitmapSurface);
    }
    SDL_FreeSurface(bitmapSurface);
}