// LEARN SUBCLASSES. WOULD HAVE SAVED A GOOD PORTION OF TIME AND WOULD HAVE RESULTED IN A LOT LESS LINES
// ALSO LEARN ERROR HANDLING AND EXCEPTIONS

/*

TODO:
- Allow user to make pawn turn into any other piece should the pawn reach the opposite side of the board.
- Put 2 rooks on each side of the board and allow for them to kill/be killed.
- pieces are moving with being clicked...? the piece is still selected even if another piece is selected afterwards..

*/

#include <SDL.h>
#include <SDL_image.h>
#include <iostream>
#include <string>
#include "pawn.h"
#include "rook.h"

using namespace std;

const int WINDOW_WIDTH = 800;
const int WINDOW_HEIGHT = 800;
SDL_Window* gWindow = nullptr;
SDL_Renderer* gRenderer = nullptr;

bool init()
{
    bool success = true;
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
    {
        cout << "SDL failed to initialize! SDL error: " << SDL_GetError() << endl;
        success = false;
    }
    else
    {
        gWindow = SDL_CreateWindow("Chess", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN);
        if (gWindow == nullptr)
        {
            cout << "SDL failed to create the window! SDL error: " << SDL_GetError() << endl;
            success = false;
        }
        gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
        if (gRenderer == nullptr)
        {
            success = false;
            cout << "SDL failed to create the renderer! SDL error: " << SDL_GetError() << endl;
        }
        if (IMG_Init(IMG_INIT_PNG) < 0)
        {
            cout << "IMG failed to initialize PNG! IMG error: " << IMG_GetError() << endl;
            success = false;
        }
    }

    return success;
}

SDL_Texture* loadTexture(string path)
{
    SDL_Surface* loadedSurface = IMG_Load(path.c_str());
    if (loadedSurface == nullptr)
        cout << "Error loading surface! IMG error: " << IMG_GetError() << endl;
    SDL_Texture* finalSurface = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);
    return finalSurface;
}

SDL_Texture* spritesheet;
// 8x8 are the dimensions of a chess board
SDL_Rect tileRects[8 * 8];
// should've studied subclasses prior to this, as it would have made this so much more line efficient
int whitePieces = 10;
int blackPieces = 10;

Pawn whitePawns[8];
Pawn blackPawns[8];
Rook whiteRooks[2];
Rook blackRooks[2];

// currently 16 pieces. each piece has 2 positions (x, y).
int poses[16][2];
bool loadMedia()
{
    bool success = true;
    spritesheet = loadTexture("spritesheet.png");

    int counter = 0;
    int counter2 = 0;
    for (int i = 0; i < sizeof(tileRects) / sizeof(tileRects[0]); i++)
    {
        tileRects[i].w = 100;
        tileRects[i].h = 100;

        if (counter2 >= 8)
            counter2 = 0;
        if (i % 8 == 0 && i != 0)
        {
            counter2++;
            counter++;
        }
        tileRects[i].x = 100 * counter2;

        if (counter > 0)
            tileRects[i].y = 100 * counter;

        counter2++;
    }

    for (int i = 0; i < sizeof(whitePawns) / sizeof(whitePawns[0]); i++)
        whitePawns[i] = Pawn(i, "white");

    for (int i = 0; i < sizeof(blackPawns) / sizeof(blackPawns[0]); i++)
        blackPawns[i] = Pawn(i, "black");

    for (int i = 0; i < sizeof(whiteRooks) / sizeof(whiteRooks[0]); i++)
        whiteRooks[i] = Rook(i * 7, "white");

    for (int i = 0; i < sizeof(blackRooks) / sizeof(blackRooks[0]); i++)
        blackRooks[i] = Rook(i * 7, "black");

    return success;
}

int gMouseX = 0;
int gMouseY = 0;

bool clicked = false;
int main(int argc, char* argv[])
{
    init();
    loadMedia();

    string turn = "white";

    SDL_Event events;
    bool running = true;
    while (running)
    {
        int posesCounter = 0;
        while (SDL_PollEvent(&events) != 0)
        {
            if (events.type == SDL_QUIT)
                running = false;

            bool leftClick = false;
            if (events.type == SDL_MOUSEBUTTONDOWN)
                leftClick = true;
            else
                leftClick = false;

            if (turn == "white")
            {
                for (int i = 0; i < sizeof(whitePawns) / sizeof(whitePawns[0]); i++)
                {
                    // this makes it so that you have to click the piece for it to be selected, and click again for it to go somewhere.
                    if (whitePawns[i].mSelected && leftClick)
                        whitePawns[i].canMove = true;
                    else
                        whitePawns[i].canMove = false;
                    whitePawns[i].handleEvents(events, leftClick);

                    // this ensures that only when piece is selected at once.
                    if (whitePawns[i].mSelected)
                    {
                        for (int j = 0; j < sizeof(whitePawns) / sizeof(whitePawns[0]); j++)
                            if (j != i)
                                whitePawns[j].mSelected = false;
                        for (int j = 0; j < sizeof(whiteRooks) / sizeof(whiteRooks[0]); j++)
                            whiteRooks[j].mSelected = false;
                    }

                }

                for (int i = 0; i < sizeof(whiteRooks) / sizeof(whiteRooks[0]); i++)
                {
                    if (whiteRooks[i].mSelected && leftClick)
                        whiteRooks[i].canMove = true;
                    else
                        whiteRooks[i].canMove = false;
                    whiteRooks[i].handleEvents(events, leftClick);

                    if (whiteRooks[i].mSelected)
                    {
                        for (int j = 0; j < sizeof(whitePawns) / sizeof(whitePawns[0]); j++)
                            whitePawns[j].mSelected = false;
                        if (i == 1)
                            whitePawns[0].mSelected = false;
                        else
                            whitePawns[1].mSelected = false;
                    }

                }
            }
            else
            {
                for (int i = 0; i < sizeof(blackPawns) / sizeof(blackPawns[0]); i++)
                {
                    if (blackPawns[i].mSelected && leftClick)
                        blackPawns[i].canMove = true;
                    else
                        blackPawns[i].canMove = false;
                    blackPawns[i].handleEvents(events, leftClick);

                    if (blackPawns[i].mSelected)
                    {
                        for (int j = 0; j < sizeof(blackPawns) / sizeof(blackPawns[0]); j++)
                            if (j != i)
                                blackPawns[j].mSelected = false;
                        for (int j = 0; j < sizeof(blackRooks) / sizeof(blackRooks[0]); j++)
                            blackRooks[j].mSelected = false;
                    }
                }
                for (int i = 0; i < sizeof(blackRooks) / sizeof(blackRooks[0]); i++)
                {
                    if (blackRooks[i].mSelected && leftClick)
                        blackRooks[i].canMove = true;
                    else
                        blackRooks[i].canMove = false;
                    blackRooks[i].handleEvents(events, leftClick);

                    if (blackRooks[i].mSelected)
                    {
                        for (int j = 0; j < sizeof(blackPawns) / sizeof(blackPawns[0]); j++)
                            blackPawns[j].mSelected = false;
                        if (i == 1)
                            blackPawns[0].mSelected = false;
                        else
                            blackPawns[1].mSelected = false;
                    }

                }
            }

        }

        SDL_GetMouseState(&gMouseX, &gMouseY);
        gMouseX /= 100;
        gMouseY /= 100;

        SDL_SetRenderDrawColor(gRenderer, 0, 0, 0, 255);
        SDL_RenderClear(gRenderer);

        for (int i = 0; i < sizeof(tileRects) / sizeof(tileRects[0]); i++)
        {
            if (i % 2 == 0)
            {
                SDL_SetRenderDrawColor(gRenderer, 84, 168, 9, 255);
                SDL_RenderFillRect(gRenderer, &tileRects[i]);
            }
            else
            {
                SDL_SetRenderDrawColor(gRenderer, 255, 255, 255, 255);
                SDL_RenderFillRect(gRenderer, &tileRects[i]);
            }
        }

        for (int i = 0; i < whitePieces; i++)
        {
            if (i <= 7)
            {
                poses[i][0] = whitePawns[i].getX();
                poses[i][1] = whitePawns[i].getY();
                whitePawns[i].move(gMouseX, gMouseY, clicked, turn, poses);
                SDL_SetRenderDrawColor(gRenderer, 255, 0, 0, 255);
                SDL_RenderFillRect(gRenderer, &whitePawns[i].getRect());

                if (whitePawns[i].killedPiece)
                {
                    for (int j = 0; j < sizeof(blackPawns) / sizeof(blackPawns[0]); j++)
                    {
                        if (blackPawns[j].getX() == whitePawns[i].getX() && blackPawns[j].getY() == whitePawns[i].getY())
                        {
                            blackPawns[j].killed = true;
                            turn = "black";
                        }
                    }
                }
                posesCounter++;
            }
            else if (i > 7 && i <= 9)
            {
                poses[i][0] = whiteRooks[i - posesCounter].getX();
                poses[i][1] = whiteRooks[i - posesCounter].getY();
                whiteRooks[i - posesCounter].move(gMouseX, gMouseY, clicked, turn, poses);
                SDL_SetRenderDrawColor(gRenderer, 255, 255, 0, 255);
                SDL_RenderFillRect(gRenderer, &whiteRooks[i - posesCounter].getRect());
            }
            //posesCounter++;
        }

        // OI FUTURE ME. YOU'RE GOING TO HAVE TO MAKE THE POSESCOUNTER INCREMENT IN THIS FOR LOOP OR ELSE IT WON'T WORK!!
        for (int i = 0; i < sizeof(blackPawns) / sizeof(blackPawns[0]); i++)
        {
            poses[i + posesCounter + 2][0] = blackPawns[i].getX();
            poses[i + posesCounter + 2][1] = blackPawns[i].getY();
            blackPawns[i].move(gMouseX, gMouseY, clicked, turn, poses);
            SDL_SetRenderDrawColor(gRenderer, 0, 0, 255, 255);
            SDL_RenderFillRect(gRenderer, &blackPawns[i].getRect());

            if (blackPawns[i].killedPiece)
            {
                for (int j = 0; j < sizeof(whitePawns) / sizeof(whitePawns[0]); j++)
                {
                    if (blackPawns[i].getX() == whitePawns[j].getX() && blackPawns[i].getY() == whitePawns[j].getY())
                    {
                        whitePawns[j].killed = true;
                        turn = "white";
                    }
                }
            }
        }

        SDL_RenderPresent(gRenderer);
    }

    return 0;
}