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

/*

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.

*/

#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];
Pawn whitePieces[10]; // 8 pawns + 2 rooks
Pawn blackPieces[10];

// 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(whitePieces) / sizeof(whitePieces[0]); i++)
        whitePieces[i] = Pawn(i, "white");

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

    return success;
}

int gMouseX = 0;
int gMouseY = 0;

bool clicked = false;
Rook rook(0, "white");
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;

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

            if (turn == "white")
            {
                for (int i = 0; i < sizeof(whitePieces) / sizeof(whitePieces[0]); i++)
                    whitePieces[i].handleEvents(events);
                rook.handleEvents(events);
            }
            else
                for (int i = 0; i < sizeof(blackPieces) / sizeof(blackPieces[0]); i++)
                    blackPieces[i].handleEvents(events);
        }

        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 < sizeof(whitePieces) / sizeof(whitePieces[0]); i++)
        {
            poses[i][0] = whitePieces[i].getX();
            poses[i][1] = whitePieces[i].getY();
            whitePieces[i].move(gMouseX, gMouseY, clicked, turn, poses);
            SDL_SetRenderDrawColor(gRenderer, 255, 0, 0, 255);
            SDL_RenderFillRect(gRenderer, &whitePieces[i].getRect());
            posesCounter++;

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

        // 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(blackPieces) / sizeof(blackPieces[0]); i++)
        {
            poses[i + posesCounter][0] = blackPieces[i].getX();
            poses[i + posesCounter][1] = blackPieces[i].getY();
            blackPieces[i].move(gMouseX, gMouseY, clicked, turn, poses);
            SDL_SetRenderDrawColor(gRenderer, 0, 0, 255, 255);
            SDL_RenderFillRect(gRenderer, &blackPieces[i].getRect());

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

        SDL_RenderPresent(gRenderer);
    }

    return 0;
}