main.cpp

#include <glad/glad.h>
#include <glfw/glfw3.h>

#include "libs/shader.hpp"
#include "libs/VertexArray.hpp"
#include "libs/VertexBuffer.hpp"
#include "libs/VertexBufferLayout.hpp"
#include "libs/Renderer.hpp"
#include "libs/IndexBuffer.hpp"
#include "libs/Text.h"

#include "libs/glm/glm.hpp"
#include "libs/glm/gtc/matrix_transform.hpp"
#include "libs/glm/gtc/type_ptr.hpp"

#include "libs/Frame.h"
#include "libs/Label.h"
#include "libs/Grid.hpp"
#include "libs/Button.h"
#include "libs/CheckBox.h"
#include "libs/PageHandler.h"
#include "libs/LineEdit.h"

#include "libs/network/Client.h"
#include "libs/network/Server.h"

#include <vector>
#include <iostream>

// Settings
constexpr int SCR_WIDTH = 1920;
constexpr int SCR_HEIGHT = 1080;

uint8_t VSYNC = 1; // 1 for on and 0 for off

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void window_size_callback(GLFWwindow* window, int width, int height);
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);

// ---------------- GLOBAL VARIABLES ----------------

// Move to a class like PageHandler
Label redStats(1280.0f, 125.0f, "RED STATS - N/A", {1.0f, 0.0f, 0.0f});
Label yellowStats(1280.0f, 175.0f, "YELLOW STATS - N/A", {1.0f, 1.0f, 0.0f});
Label blueStats(1280.0f, 225.0f, "BLUE STATS - N/A", {0.0f, 0.1f, 1.0f});
Label greenStats(1280.0f, 275.0f, "GREEN STATS - N/A", {0.0f, 1.0f, 0.0f});

Label status(1010.0f, 900.0f, "Status: None");
Label WarTurn(1400.0f, 400.0f, "War Turn: None");
Label WarStats(1400.0f, 450.0f, "Attacks Used: 0 - 0");
Label currentTeamTxt(1010.0f, 800.0f, "Current Turn: N/A");
Label gameTitle(SCR_WIDTH/2-100, 400.0f, "EMPIRE", {0.9f, 0.0f, 0.0f});
Label gameOver(SCR_WIDTH/4, SCR_HEIGHT/2);
Label gameMenu(75.0f, 150.0f, "EMPIRES", {1.0f, 1.0f, 1.0f});
Label gameMenu2(78.5f, 158.0f, "EMPIRES", {0.0f, 0.0f, 0.0f});

Label serverAddr(500, 200, "Server Address: Unknown");
Label playersWaiting(500, 400, "Players In Matchmaking: 0");
Label playersInGame(500, 600, "Players In Game: 0");

Label matchmakingTitle(500, 350, "In matchmaking, please wait...");
Label description(500, 450);

std::vector<Button> buttons;
std::vector<Label*> labels;
std::vector<Frame> frames;
std::vector<CheckBox> checkboxes;
std::vector<LineEdit> lineEdits;

// --------------------------------------------------------------------

std::vector<float> vertices;
std::vector<float> texturedVertices;
int texturedVertexSize;
Grid* grid = nullptr;
ButtonGroup* buttonGroup = nullptr;
bool boatSelect = false;
bool boatMove = false;
uint8_t page = 1;
bool warSelection = false;
uint8_t attacksUsed = 2; // On page 1, used for player amount but on page 2 used for attack points amount
bool pauseMainLoop = false;
bool rebuildVertices = false;

VertexBufferLayout layout;
VertexArray* VAO = nullptr;
VertexBuffer* VBO = nullptr;

PlayModes playMode;
ClientManager* client;
Server* server; // Only used if hosting server

glm::mat4 projection = glm::ortho(0.0f, static_cast<float>(SCR_WIDTH), 0.0f, static_cast<float>(SCR_HEIGHT));

Renderer renderer;

struct
{
    int oldX = -1;
    int oldY = -1;
    int newX, newY;

    void Reset()
    {
        oldX = -1;
        oldY = -1;
    }
} XY, XY2;

// --------------------------------------------------

void InitMenu();
void InitSettings();
void StartGame();
void InitEndMenu();
void InitStartMenu();

void BuildBuffers();
void BuildWidgets();

void InitWarWidgets(const bool enable);
void BuyAttack();
void IncreaseAttack();
void DecreaseAttack();

void DeclareWar(Player& aggressor, Player& defender);
void SelectWar();
void WarAttack();
void WarSurrender();

void EndTurn();

void MoveBoat();
void BuyBoat();
void FishBoat();

void TreasureHuntLvl3();
void TreasureHuntLvl2();
void TreasureHuntLvl1();

void SetPlayerStatText();

void character_callback(GLFWwindow* window, unsigned int codepoint);

int main()
{

    // Initialise version 3.3 core
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_SAMPLES, 4);

    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "Empire", NULL, NULL);
    if (window == NULL)
    {
        std::cerr << "Failed to create GLFW window!\n";
        glfwTerminate();
        return EXIT_FAILURE;
    }

    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetWindowSizeCallback(window, window_size_callback);
    glfwMakeContextCurrent(window);
    glfwSetCharCallback(window, character_callback);

    glfwSwapInterval(VSYNC);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return EXIT_FAILURE;
    }

    std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;

    // Capture the cursor normally (without hiding or restricting it)
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
    glfwSetMouseButtonCallback(window, mouse_button_callback); // Mouse click

    // Enabled for text rendering
    glEnable(GL_CULL_FACE); glCheckError();
    glEnable(GL_BLEND); glCheckError();
    glEnable(GL_MULTISAMPLE); glCheckError();
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glCheckError();

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); glCheckError();
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); glCheckError();

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glCheckError();
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glCheckError();
    

    {
        buttonGroup = new ButtonGroup(projection, SCR_WIDTH, SCR_HEIGHT);
        LabelRenderer::Init(projection, SCR_WIDTH, SCR_HEIGHT);
        CheckBoxManager::Init(projection, SCR_WIDTH, SCR_HEIGHT);
        InitMenu();

        bool isInit = Socket::InitSocket();
        if (!isInit)
        {
            std::cerr << "Winsock failed to initialise.\n";
        }
        else
        {
            std::cout << "Winsock has successfully initialised.\n";
        }

        Shader shader("res/shaders/cool-vec.glsl", "res/shaders/cool-frag.glsl");
        shader.use();

        /*Texture texture;
        texture.loadTexture("res/image.jpg");
        texture.bind(1);*/

        shader.setInt("texture1", 1); // Equivalent to GL_TEXTURE1

        // Layout
        layout.push<float>(2);
        layout.push<float>(3);
        layout.push<float>(2);
        BuildBuffers();

        glm::vec3 teamColour;

        currentTeamTxt.SetTextScale(0.5f);

        WarTurn.hide();
        WarStats.hide();

        glm::vec3 endColour;

        int leftmouseButtonAction;
        uint8_t frameCounter = 0; // Every 10 frames check if the button is hovered
        while (!glfwWindowShouldClose(window))
        {
            renderer.clear();

            if (rebuildVertices)
            {
                BuildWidgets();
                rebuildVertices = false;
            }
            else if (pauseMainLoop)
            {
                glfwSwapBuffers(window);
                glfwPollEvents();
                continue;
            }
            if (client != nullptr)
            {
                int8_t warToggle = client->GetWarToggle();
                if (client->GetBuildWidgets())
                {
                    client->SetBuildWidgets(false);
                    BuildWidgets();
                    std::cout << "Rebuilt vertices due to Client class.\n";
                }
                else if (warToggle == 0) // Start
                {
                    client->SetWarToggle(-1); // Set to false
                    InitWarWidgets(true);
                }
                else if (warToggle == 1) // End
                {
                    client->SetWarToggle(-1); // Set to false
                    InitWarWidgets(false);
                }
            }

            leftmouseButtonAction = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT);

            // Input
            if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            {
                std::cout << "\nGAME ESCAPED!\n";
                glfwSetWindowShouldClose(window, true);
            }

            double x, y;
            Renderer::GetMousePos(window, x, y, SCR_WIDTH, SCR_HEIGHT);

            if (frameCounter == 10 || frameCounter == 5)
            {
                if (glfwGetKey(window, GLFW_KEY_BACKSPACE))
                {
                    for (LineEdit& lineEdit : lineEdits)
                    {
                        if (lineEdit.CheckIfSelected(x, y))
                        {
                            lineEdit.RemoveLastChar();
                            break;
                        }
                    }
                }
                if (page == 5 && server != nullptr)
                {
                    playersWaiting.SetText("Players In Matchmaking: " + std::to_string(server->GetPlayerSize(0)));
                    playersInGame.SetText("Players In Game (Estimated): " + std::to_string(server->GetPlayerSize(1)));
                }
            }

            if (frameCounter == 10)
            {
                for (Button& button : buttons)
                {
                    if (PushButton::IsClicked(button, x, y))
                    {
                        button.isHovered = true;
                        if (button.hoverCallback != nullptr)
                        {
                            button.hoverCallback();
                        }
                    }
                    else
                    {
                        button.isHovered = false;
                    }
                }
                frameCounter = 0;
            }


            shader.use();
            shader.setInt("textureSample", 0); // False, do not render as a texture
            renderer.drawArrays( *VAO, shader, (vertices.size()-texturedVertexSize) / 7 ); // Render non-textures
            shader.setInt("textureSample", 1); // True, render as a texture
            renderer.drawArrays( *VAO, shader, (texturedVertexSize / 7), (vertices.size()-texturedVertexSize) / 7 ); // Render textures

            buttonGroup->RenderBtnText(buttons);

            for (LineEdit& lineEdit : lineEdits)
            {
                lineEdit.Render();
            }

            if (grid != nullptr)
            {
                const Team& team = grid->GetPlayer().GetTeam();
                currentTeamTxt.SetText("Current Turn: " + Grid::GetTeamStr(team));
                currentTeamTxt.SetColour(Grid::GetTeamColour(team));
            }

            CheckBoxManager::RenderText(checkboxes, SCR_HEIGHT);

            // Render player stats
            LabelRenderer::Render(labels);

            if (grid != nullptr && grid->GetPlayerCount() <= 1)
            {
                std::cout << "GAME OVER!\n";
                InitEndMenu();
            }

            frameCounter++;

            glfwSwapBuffers(window);
            glfwPollEvents();
        }

        if (server != nullptr) { delete server; server = nullptr; }
        if (client != nullptr) { delete client; client = nullptr; }
        if (buttonGroup != nullptr) { delete buttonGroup; buttonGroup = nullptr; }
        buttonGroup = nullptr;
    }

    Socket::Cleanup();

    glfwTerminate();
    return EXIT_SUCCESS;
}






void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

void window_size_callback(GLFWwindow* window, int width, int height)
{
    vertices.clear();
    texturedVertices.clear();
    BuildWidgets();
}

void mouse_button_callback(GLFWwindow *window, int button, int action, int mods)
{
    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE)
    {
        double x, y;
        Renderer::GetMousePos(window, x, y, SCR_WIDTH, SCR_HEIGHT);

        bool build_grid = false;
        bool buildBuffers = false;

        for (LineEdit &lineEdit : lineEdits)
        {
            lineEdit.SetSelected(lineEdit.CheckIfSelected(x, y));
        }

        if (page == 2)
        {
            for (const Tile &tile : grid->GetTiles())
            {
                if (grid->IsWar())
                {
                    break;
                } // If there is a war, disable ALL tiles

                if (PushButton::IsClicked(tile.button, x, y))
                {
                    buildBuffers = true;
                    // Add a boat if possible, else return and do a status
                    if (boatMove)
                    {
                        // Make sure the boat exists
                        if (XY.oldX == -1 && XY.oldY == -1 && tile.validBoat && tile.boat.team == grid->GetPlayer().GetTeam())
                        {
                            XY.oldX = tile.button.x;
                            XY.oldY = tile.button.y;
                            break;
                        }
                        else if (XY.oldX != -1 && XY.oldY != -1)
                        {
                            if (playMode == PlayModes::LOCAL)
                            {
                                bool isAllowed = grid->MoveBoat(XY.oldX, XY.oldY, tile.button.x, tile.button.y);

                                if (!isAllowed)
                                {
                                    std::cerr << "Failed to buy boat!\n";
                                    boatMove = false;
                                }

                                // Reset button text
                                for (Button &button : buttons)
                                {
                                    if (button.GetText() == "Cancel Boat Transport")
                                    {
                                        button.SetText("Move Boat");
                                        boatMove = false;
                                        break;
                                    }
                                }

                                boatMove = false;
                                build_grid = true;
                                XY.Reset();
                                break;
                            }
                            else if (playMode == PlayModes::MULTIPLAYER)
                            {
                                Packet packet;
                                packet.requestType = RequestTypes::RequestType::MoveBoat;
                                packet.val1 = XY.oldX;
                                packet.val2 = XY.oldY;
                                client->SendRequest(packet);

                                packet.val1 = tile.button.x;
                                packet.val2 = tile.button.y;
                                client->SendRequest(packet);
                            }
                            break;
                        }
                    }
                    else if (boatSelect)
                    {
                        if (playMode == PlayModes::LOCAL)
                        {
                            if (!grid->BuyBoat(tile.button.x, tile.button.y))
                            {
                                std::cerr << "Failed to buy boat!\n";
                                status.SetText("Status: Failed to buy boat.");
                                boatSelect = false;
                            }

                            // Reset button text
                            for (Button &button : buttons)
                            {
                                if (button.GetText() == "Cancel Boat")
                                {
                                    button.SetText("Buy Boat");
                                    boatSelect = false;
                                    break;
                                }
                            }
                        }
                        else if (playMode == PlayModes::MULTIPLAYER)
                        {
                            Packet packet;
                            packet.requestType = RequestTypes::RequestType::BuyBoat;
                            packet.val1 = tile.button.x;
                            packet.val2 = tile.button.y;
                            packet.targetPlayer = client->GetTeam();
                            client->SendRequest(packet);
                        }

                        boatSelect = false;
                        build_grid = true;
                        break;
                    }
                    else if (warSelection)
                    {
                        if (XY2.oldX == -1 && XY2.oldY == -1) // Reset values
                        {
                            Team playerTeam = grid->GetPlayer().GetTeam();
                            // Make sure the province exists or is a navy boat
                            if (tile.team == playerTeam || (tile.validBoat && tile.boat.team == playerTeam))
                            {
                                XY2.oldX = tile.button.x;
                                XY2.oldY = tile.button.y;
                            }
                            break;
                        }
                        else
                        {
                            XY2.newX = tile.button.x;
                            XY2.newY = tile.button.y;

                            enum WarType : uint8_t
                            {
                                NavalWar = 0,
                                TotalWar
                            } warType;

                            if (tile.validBoat && tile.boat.team != grid->GetPlayer().GetTeam())
                            {
                                warType = WarType::NavalWar;
                            }
                            else
                            {
                                warType = WarType::TotalWar;
                            }

                            for (Player &player : grid->GetPlayers())
                            {
                                if (warType == WarType::NavalWar && player.GetTeam() == tile.boat.team)
                                {
                                    DeclareWar(grid->GetPlayer(), player);
                                    break;
                                }
                                else if (warType == WarType::TotalWar && player.GetTeam() == tile.team)
                                {
                                    DeclareWar(grid->GetPlayer(), player);
                                    break;
                                }
                            }
                        }
                        // Reset button text
                        for (Button &button : buttons)
                        {
                            if (button.GetText() == "Cancel War Declaration")
                            {
                                button.SetText("Declare War");
                                warSelection = false;
                                break;
                            }
                        }

                        warSelection = false;
                        build_grid = true;
                        XY2.Reset();
                        break;
                    }
                    else
                    {
                        if (playMode == PlayModes::LOCAL)
                        {
                            bool isAllowed = grid->BuyLand(tile);
                            if (!isAllowed)
                            {
                                std::cerr << "Failed to buy land!\n";
                                break;
                            }
                            std::cout << "Bought land\n";
                            build_grid = true;
                            buildBuffers = true;

                            break;
                        }
                        else if (playMode == PlayModes::MULTIPLAYER)
                        {
                            Packet packet;
                            packet.requestType = RequestTypes::RequestType::BuyLand;
                            packet.val1 = tile.button.x;
                            packet.val2 = tile.button.y;
                            client->SendRequest(packet);
                        }
                    }
                }
            }
        }

        // Add dynamic window button positions (resize the window properly)
        for (const Button &button : buttons)
        {
            // If mouseX is more than buttonX and mouseX is less than buttonX + width
            if (PushButton::IsClicked(button, x, y) && button.callback != nullptr)
            {
                button.callback();
                build_grid = true;
                buildBuffers = true;
                break;
            }
        }

        for (CheckBox &checkBox : checkboxes)
        {
            // If mouseX is more than buttonX and mouseX is less than buttonX + width
            if (PushButton::IsClicked(checkBox, x, y) && checkBox.callback != nullptr)
            {
                checkBox.SetChecked(!checkBox.isChecked);

                checkBox.callback();
                build_grid = true;
                buildBuffers = true;
                break;
            }
        }

        if (build_grid)
        {
            vertices.clear();
            texturedVertices.clear();
            BuildWidgets();

            if (grid != nullptr)
            {
                redStats.SetText("RED STATS - ELIMINATED");
                yellowStats.SetText("YELLOW STATS - ELIMINATED");
                greenStats.SetText("GREEN STATS - ELIMINATED");
                blueStats.SetText("BLUE STATS - ELIMINATED");

                SetPlayerStatText();
            }
        }

        if (buildBuffers)
        {
            BuildBuffers();
        }
    }

    if (grid != nullptr)
    {
        status.SetText(grid->GetLastStatus());
    }
}

void IncreaseAttack()
{
    if (attacksUsed >= 4 && page == 4) { return; }
    if (attacksUsed >= 255) { return; }

    for (Button& button : buttons)
    {
        if (button.GetText() == std::to_string(attacksUsed))
        {
            attacksUsed++;
            button.SetText(std::to_string(attacksUsed));
            break;
        }
    }
};

void DecreaseAttack()
{
    if (attacksUsed <= 2 && page == 4) { return; }
    if (attacksUsed <= 0) { return; }

    for (Button& button : buttons)
    {
        if (button.GetText() == std::to_string(attacksUsed))
        {
            attacksUsed--;
            button.SetText(std::to_string(attacksUsed));
            break;
        }
    }
};

void BuildBuffers()
{
    if (VAO != nullptr) { delete VAO; }
    if (VBO != nullptr) { delete VBO; }

    texturedVertexSize = texturedVertices.size();

    vertices.reserve(vertices.size() + texturedVertexSize);
    vertices.insert(vertices.end(), texturedVertices.begin(), texturedVertices.end()); // Add all the textured vertices to the normal vertices

    texturedVertices.clear(); // Prevent duplicate data

    VAO = new VertexArray;
    VBO = new VertexBuffer(vertices.data(), vertices.size() * sizeof(float) + texturedVertexSize * sizeof(float));
    VAO->AddBuffer(*VBO, layout);
}

void FishBoat()
{
    if (playMode == PlayModes::MULTIPLAYER)
    {
        Packet packet;
        packet.requestType = RequestTypes::RequestType::SellFish;
        packet.val1 = 0;
        packet.val2 = 0;
        client->SendRequest(packet);
        return;
    }
    grid->ClaimMoney();
}

void EndTurn()
{
    if (playMode == PlayModes::MULTIPLAYER)
    {
        Packet packet;
        packet.requestType = RequestTypes::RequestType::EndTurn;
        packet.val1 = 0;
        packet.val2 = 0;
        client->SendRequest(packet);
        return;
    }
    grid->EndTurn();
    status.SetText(grid->GetLastStatus());
}

void MoveBoat()
{
    Button* buttonPtr = nullptr;
    for (Button& button : buttons)
    {
        if (button.GetText() == "Cancel Boat Transport" || button.GetText() == "Move Boat")
        {
            buttonPtr = &button;
            std::cout << "Got button\n";
        }
    }

    Player& player = grid->GetPlayer();
    // If player already did another action, return
    if (!player.CanMove)
    {
        status.SetText("Status: Player already did another action, cannot move boat.");
        buttonPtr->SetText("Move Boat");
        return; 
    }

    XY.Reset();
    if (!boatMove)
    {
        boatMove = true;
        buttonPtr->SetText("Cancel Boat Transport");
        status.SetText("Status: Select boat position...");
    }
    else if (boatMove)
    {
        boatMove = false;
        buttonPtr->SetText("Move Boat");
        status.SetText("Status: None");
    }
}

void BuyBoat()
{
    Button* buttonPtr = nullptr;
    for (Button& button : buttons)
    {
        if (button.GetText() == "Cancel Boat" || button.GetText() == "Buy Boat")
        {
            buttonPtr = &button;
        }
    }

    Player& player = grid->GetPlayer();
    // If player already did another action, return
    if (!player.CanBuyBoat)
    {
        status.SetText("Status: Player already did another action, cannot buy boat.");
        grid->SetLastStatus(status.text);
        buttonPtr->SetText("Buy Boat");
        return; 
    }

    if (player.money < (player.boatCount + 2))
    {
        status.SetText("Status: Player has insufficient funds, cannot buy boat.");
        grid->SetLastStatus(status.text);
        return;
    }

    if (!boatSelect)
    {
        boatSelect = true;
        buttonPtr->SetText("Cancel Boat");
        status.SetText("Status: Select boat position...");
        grid->SetLastStatus(status.text);
        return;
    }
    else if (boatSelect)
    {
        boatSelect = false;
        buttonPtr->SetText("Buy Boat");
        status.SetText("Status: None");
        grid->SetLastStatus(status.text);
    }
}

void SetEliminatedStats()
{
    if (status.text == "Status: Player has died.")
    {
        if (grid->GetPlayer().GetTeam() == Team::RED) { redStats.SetText("RED STATS - ELIMINATED"); }
        else if (grid->GetPlayer().GetTeam() == Team::YELLOW) { yellowStats.SetText("YELLOW STATS - ELIMINATED"); }
        else if (grid->GetPlayer().GetTeam() == Team::GREEN) { greenStats.SetText("GREEN STATS - ELIMINATED"); }
        else if (grid->GetPlayer().GetTeam() == Team::BLUE) { blueStats.SetText("BLUE STATS - ELIMINATED"); }
    }
}

void DoTreasureHunt(const uint8_t level)
{
    if (playMode == PlayModes::MULTIPLAYER /* && !isVerified */)
    {
        Packet packet;
        packet.requestType = RequestTypes::RequestType::TreasureHunt;
        packet.val1 = level;
        packet.val2 = 0;
        client->SendRequest(packet);
        return;
    }
    else
    {
        grid->TreasureHunt(level);
    }
    status.SetText(grid->GetLastStatus());

    SetEliminatedStats();
}

void TreasureHuntLvl3()
{
    DoTreasureHunt(3);
}

void TreasureHuntLvl2()
{
    DoTreasureHunt(2);
}

void TreasureHuntLvl1()
{
    DoTreasureHunt(1);
}

void BuyAttack()
{
    if (!grid->IsWar())
    {
        status.SetText("Status: Unable to buy attacks when it is not war.");
        grid->SetLastStatus(status.text);
        return;
    }
    Player* player = grid->GetWarPlayer();
    bool result;

    if (playMode == PlayModes::MULTIPLAYER)
    {
        Packet packet;
        packet.requestType = RequestTypes::RequestType::BuyAttackCard;
        client->SendRequest(packet);
        return;
    }
    else
    {
        result = player->BuyAttack(1, 2); // Buy one attack point for 2 money
    }

    if (result)
    {
        status.SetText("Status: Player bought an attack card.");
        grid->SetLastStatus(status.text);
    }
    else
    {
        status.SetText("Status: Insufficient funds, player failed to buy an attack card.");
        grid->SetLastStatus(status.text);
    }
}

void SelectWar()
{
    if (grid->IsWar())
    {
        status.SetText("Status: Unable to declare multiple wars...");
        return;
    }

    Button* buttonPtr = nullptr;
    for (Button& button : buttons)
    {
        if (button.GetText() == "Cancel War Declaration" || button.GetText() == "Declare War")
        {
            buttonPtr = &button;
            std::cout << "Got button\n";
        }
    }

    if (!warSelection)
    {
        warSelection = true;
        buttonPtr->SetText("Cancel War Declaration");
        status.SetText("Status: Select declaring province/boat...");
    }
    else if (warSelection)
    {
        warSelection = false;
        buttonPtr->SetText("Declare War");
        status.SetText("Status: None");
        XY2.Reset();
    }
}

void InitWarWidgets(const bool isStart)
{
    std::cout << "Initialising war widgets: ";
    if (isStart) { std::cout << "START\n"; } else { std::cout << "END\n"; }

    for (Button& button : buttons)
        {
            if (button.text == "Attack" || button.text == "Surrender" || button.text == "Buy Attack Card" || button.text == "+" || button.text == "-")
            {
                button.SetEnabled(isStart);
                if (!isStart) { button.hide(); }
                else { button.show(); }
            }
            else { button.SetDisabled(isStart); }
        }

        for (Button& button : buttons)
        {
            if (button.text == std::to_string(attacksUsed))
            {
                button.SetText("0");
                if (!isStart) { button.hide(); }
                else { button.show(); }
                break;
            }
        }
        if (isStart)
        {
            WarStats.show();
            WarTurn.show();
        }
        else
        {
            WarStats.hide();
            WarTurn.hide();
        }
        attacksUsed = 0; // Reset

        if (grid != nullptr && grid->IsWar())
        {
            WarTurn.SetText("War Turn: TEAM " + grid->GetWarPlayers().aggressor->GetTeamStr());
        }

        // Updates UI
        vertices.clear();
        texturedVertices.clear();
        BuildWidgets();
}

void DeclareWar(Player& aggressor, Player& defender)
{
    std::cout << "Declaring war with teams: " << aggressor.GetTeamStr() << " " << defender.GetTeamStr() << "\n";

    if (aggressor.GetTeam() == defender.GetTeam())
    {
        status.SetText("Status: Unable to declare war on own nation...");
        grid->SetLastStatus(status.text);
        XY2.Reset();
        return;
    }

    if (grid->IsWar())
    {
        status.SetText("Status: Unable to declare multiple wars...");
        grid->SetLastStatus(status.text);
        XY2.Reset();
        return;
    }

    if (playMode == PlayModes::MULTIPLAYER)
    {
        // Send War Declaration
        Packet packet;
        packet.requestType = RequestTypes::RequestType::DeclareWar;
        packet.targetPlayer = defender.GetTeam();

        packet.val1 = XY2.oldX;
        packet.val2 = XY2.oldY;
        client->SendRequest(packet);

        packet.val1 = XY2.newX;
        packet.val2 = XY2.newY;
        client->SendRequest(packet);

        XY2.Reset();
        return;
    }

    grid->DeclareWar(aggressor, defender, XY2.oldX, XY2.oldY, XY2.newX, XY2.newY);
    XY2.Reset();

    if (!grid->IsWar())
    {
        std::cerr << "Failed to declare war!\n";
        return;
    }

    for (Button& button : buttons)
    {
        if (button.text != "Attack" && button.text != "Surrender" && button.text != "Buy Attack Card" && button.text != "+" && button.text != "-" && button.text != "Declare War")
        {
            button.SetDisabled(true);
        }
        else { button.SetEnabled(true); button.show(); }
    }

    WarStats.show();
    WarTurn.show();

    WarTurn.SetText("War Turn: TEAM " + grid->GetWarPlayers().aggressor->GetTeamStr());

    status.SetText(grid->GetLastStatus());

    for (Button& button : buttons)
    {
        if (button.text == std::to_string(attacksUsed))
        {
            button.SetText("0");
            button.show();
            break;
        }
    }
    attacksUsed = 0; // Reset
}

void WarAttack()
{
    if (!grid->IsWar())
    {
        return;
    }

    if (playMode == PlayModes::MULTIPLAYER)
    {
        Packet packet;
        packet.targetPlayer = client->GetTeam();
        packet.requestType = RequestTypes::RequestType::WarAction;
        packet.val1 = 0; // Attack
        packet.val2 = attacksUsed;

        client->SendRequest(packet);
        return;
    }

    WarPlayers& warPlayers = grid->GetWarPlayers();
    if (grid->IsWar())
    {
        grid->Attack(attacksUsed);
    }

    // Attack amount selector reset
    for (Button& button : buttons)
    {
        if (button.text == std::to_string(attacksUsed))
        {
            button.SetText("0");
            break;
        }
    }
    attacksUsed = 0; // Reset

    if (warPlayers.aggressor != nullptr && warPlayers.enemy != nullptr)
    {
        if (grid->GetWarTurn() == 0)
        {
            WarTurn.SetText("War Turn: TEAM " + warPlayers.aggressor->GetTeamStr());
        }
        else if (grid->GetWarTurn() == 1)
        {
            WarTurn.SetText("War Turn: TEAM " + warPlayers.enemy->GetTeamStr());
        }
        WarStats.SetText("Attacks Used: " + std::to_string(warPlayers.attackUsedAggressor) + " - " + std::to_string(warPlayers.attackUsedEnemy));
    }
    else
    {
        WarTurn.SetText("War Turn: None");
        WarStats.SetText("Attacks Used: 0 - 0");
    }

    if (!grid->IsWar())
    {
        for (Button& button : buttons)
        {
            if (button.text == "Attack" || button.text == "Surrender" || button.text == "Buy Attack Card" || button.text == "+" || button.text == "-")
            {
                button.SetDisabled(true);
                button.hide();
            }
            else { button.SetEnabled(true); }
        }

        for (Button& button : buttons)
        {
            if (button.text == std::to_string(attacksUsed))
            {
                button.SetText("0");
                button.hide();
                break;
            }
        }
        WarStats.hide();
        WarTurn.hide();
        attacksUsed = 0; // Reset
    }
    status.SetText(grid->GetLastStatus());
}

void WarSurrender()
{
    if (!grid->IsWar())
    {
        return;
    }

    if (playMode == PlayModes::MULTIPLAYER)
    {
        Packet packet;
        packet.requestType = RequestTypes::RequestType::WarAction;
        packet.val1 = 1; // Surrender

        client->SendRequest(packet);
        return;
    }
    else
    {
        grid->Surrender();
    }

    for (Button& button : buttons)
    {
        if (button.text == "Attack" || button.text == "Surrender" || button.text == "Buy Attack Card" || button.text == "+" || button.text == "-")
        {
            button.hide();
            button.SetDisabled(true);
        }
        else { button.SetEnabled(true); }
    }

    WarStats.hide();
    WarTurn.hide();

    for (Button& button : buttons)
    {
        if (button.text == std::to_string(attacksUsed))
        {
            button.SetText("0");
            button.hide();
            break;
        }
    }
    attacksUsed = 0; // Reset

    WarTurn.SetText("War Turn: N/A");
    WarStats.SetText("Attacks Used: 0 - 0");

    status.SetText(grid->GetLastStatus());
    std::cout << status.text << "\n";
}

void BuildWidgets()
{
    if (frames.size() > 0)
    {
        FrameManager::BuildFrames(frames, vertices, SCR_WIDTH, SCR_HEIGHT);
    }
    if (buttonGroup != nullptr && buttons.size() > 0)
    {
        buttonGroup->Build(vertices, buttons);
    }
    if (grid != nullptr)
    {
        SetPlayerStatText();
        grid->Build(vertices);
    }
    if (checkboxes.size() > 0) {
        CheckBoxManager::BuildCheckBoxes(checkboxes, vertices, SCR_WIDTH, SCR_HEIGHT);
    }
    for (LineEdit& lineEdit : lineEdits)
    {
        lineEdit.Build(vertices);
    }
    BuildBuffers();
}

void StartGame()
{
    std::cout << "Entered StartGame()\n";
    //attacksUsed variable is used here to track player amount because it is not used before the game, meaning less variables and less memory used
    if (playMode == PlayModes::LOCAL)
    {
        if (attacksUsed > 4 || attacksUsed < 2)
        {
            std::cout << "Not enough players so returned from StartGame()!\n";
            client->Reset();
            return;
        }
    } // 2-4 players only

    renderer.SetBackgroundColour({1.0f, 1.0f, 1.0f, 1.0f});

    std::cout << "Cleared UI\n";
    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    if (playMode == PlayModes::LOCAL)
    {
        if (grid != nullptr) { delete grid; }
        grid = new Grid(attacksUsed, 5, 0);
    }
    attacksUsed = 0;

    constexpr float xPos = 1010.0f;
    constexpr float yPos = 90.0f;
    CallbackType array[] = {EndTurn, TreasureHuntLvl3, TreasureHuntLvl2, TreasureHuntLvl1, SelectWar, BuyBoat, MoveBoat, FishBoat};
    std::string text_array[] = {"End Turn", "Treasure Hunt Lvl 3", "Treasure Hunt Lvl 2", "Treasure Hunt Lvl 1", "Declare War", "Buy Boat", "Move Boat", "Sell Boat Fish"};

    std::cout << "Initialising buttons\n";
    PageHandler::StartGame(attacksUsed, buttons); // Initialise war buttons

    CallbackType callbacks[] = {WarAttack, WarSurrender, DecreaseAttack, IncreaseAttack, BuyAttack, InitMenu};
    for (uint8_t i = 0; i < sizeof(callbacks)/sizeof(CallbackType); i++)
    {
        buttons.at(i).whenClicked(callbacks[i]);
    }

    buttons.reserve(sizeof(text_array)/sizeof(std::string) + buttons.size());
    for (int i = 0; i < sizeof(text_array)/sizeof(std::string); i++)
    {
        Button button(xPos, yPos * (i+1), 250.0f, 50.0f);
        button.SetColour(0.82f, 0.82f, 0.82f);
        button.whenClicked(array[i]);
        button.SetText(text_array[i]);
        buttons.emplace_back(button);
    }

    std::cout << "Setting player stat text\n";
    SetPlayerStatText();

    WarStats.hide();
    WarTurn.hide();

    std::cout << "Label stuff\n";
    labels.emplace_back(&redStats);
    labels.emplace_back(&yellowStats);
    labels.emplace_back(&greenStats);
    labels.emplace_back(&blueStats);

    labels.emplace_back(&WarStats);
    labels.emplace_back(&WarTurn);
    labels.emplace_back(&status);
    labels.emplace_back(&currentTeamTxt);

    std::cout << "Building widgets\n";
    if (glfwGetCurrentContext() == 0 || glfwGetCurrentContext() == NULL || glfwGetCurrentContext() == nullptr)
    {
        rebuildVertices = true;
    }
    else
    {
        BuildWidgets();
    }
    std::cout << "Built widgets\n";
    page = 2;
    std::cout << "Exited\n";
}

bool CheckClientValidity(ClientManager* client)
{
    if (client == nullptr)
    {
        std::cerr << "Client object is invalid (nullptr)!\n";
        return false;
    }
    else if (!client->is_valid())
    {
        std::cerr << "Connection closed unexpectedly.\n";
        client->Reset();
        return false;
    }
    return true;
}

void WaitForServerStart()
{
    Settings gameSettings;
    std::cout << "Waiting for server requests...\n";
    if (!CheckClientValidity(client)) { std::cerr << "Invalid client, returning!\n"; return; }
    for (int i = 0; i < 4; i++)
    {
        Packet packet = client->ReceiveRequest(); // Waiting for matchmaking
        if (!CheckClientValidity(client)) { return; }

        if (packet.requestType == RequestTypes::RequestType::AssignPlayer) // Packet 1
        {
            if (!CheckClientValidity(client)) { return; }
            client->SetTeam((Team)packet.val1);
            gameSettings.playersPerGame = packet.val2;
        }
        else if (packet.requestType == RequestTypes::RequestType::SetStats)
        {
            StatsType statType = (StatsType)packet.val1;
            if (statType == StatsType::SetMoney) // Packet 2
            {
                gameSettings.startMoney = packet.val2;
                std::cout << "Set game money: " << packet.val2 << "\n";
            }
            else if (statType == StatsType::SetAttackPoints) // Packet 3
            {
                gameSettings.attackPoints = packet.val2;
                std::cout << "Set attackPoints: " << packet.val2 << "\n";
            }
            else if (statType == StatsType::SetHP) // Packet 4
            {
                gameSettings.HP = packet.val2;
                std::cout << "Set HP: " << packet.val2 << "\n";
            }
        }
        else if (packet.requestType == RequestTypes::RequestType::InvalidPacket)
        {
            std::cerr << "Invalid packet received, unable to start the game.\n";
            if (!CheckClientValidity(client)) { return; }
            client->Reset();
            return;
        }
        else
        {
            std::cout << "Unexpected packet type: " << (int)packet.requestType << "\n";
        }
    }
    std::cout << "Received server requests.\n";
    if (grid != nullptr) { delete grid; }
    grid = new Grid(gameSettings.playersPerGame, gameSettings.startMoney, gameSettings.attackPoints, gameSettings.HP);
    client->SetGrid(grid);
    pauseMainLoop = true;
    std::cout << "Main loop paused\n";
    StartGame();
    client->ListenForPackets();
    pauseMainLoop = false;
    std::cout << "Main loop unpaused\n";
}

void WaitInMatchmaking()
{
    client->SetWarLabels(&WarStats, &WarTurn);
    Packet packet = client->ReceiveRequest();
    int playersPerGame, peopleLeft;
    if (packet.requestType == RequestTypes::RequestType::EnterMatchmaking)
    {
        playersPerGame = packet.val1;
        peopleLeft = packet.val2;
    }
    else
    {
        std::cout << "Unexpected request type: " << (int)packet.requestType << "\n";
    }
    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);
    labels.emplace_back(&matchmakingTitle);
    labels.emplace_back(&description);
    labels.at(0)->SetFont("res/fonts/LiberationSans.ttf");
    labels.at(1)->SetText(std::to_string(playersPerGame) + " players per game. " + std::to_string(peopleLeft) + " more player(s) needed.");

    BuildWidgets();

    std::thread stayInMatchmaking(WaitForServerStart); // Creates thread which waits for server to start game, may not be safe but OK for now
    stayInMatchmaking.detach();
}

void StartMultiGame()
{
    client = new ClientManager;
    const std::string ipAddress = lineEdits[0].GetText();
    const int port = std::stoi(lineEdits[1].GetText()); // With std::stoi make sure it is only numbers and not empty

    bool isConnected = client->connect(ipAddress.c_str(), port, true);

    if (!isConnected)
    {
        std::cout << "Client not connected to server! Unable to start game.\n";
        return;
    }
    playMode = PlayModes::MULTIPLAYER;
    WaitInMatchmaking();
}

void InitJoinGame()
{
    playMode = PlayModes::MULTIPLAYER;
    renderer.SetBackgroundColour({0.0f, 0.73f, 0.96f, 1.0f});

    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    PageHandler::InitJoinGame(buttons, lineEdits, SCR_WIDTH, SCR_HEIGHT);
    buttons.at(0).whenClicked(StartMultiGame);
    buttons.at(1).whenClicked(InitMenu);

    BuildWidgets();
}

void StartServer()
{
    if (server != nullptr) { delete server; }
    if (lineEdits[0].GetText().empty())
    {
        lineEdits[0].SetText("5");
    }
    if (lineEdits[1].GetText().empty())
    {
        lineEdits[1].SetText("0");
    }

    for (int i = 0; i < 3; i++)
    {
        if (std::all_of(lineEdits[i].GetText().begin(), lineEdits[i].GetText().end(), ::isdigit))
        {
            std::cerr << "Invalid number!\n";
            return;
        }
    }

    server = new Server(std::stoi(lineEdits[2].GetText()), std::stoi(lineEdits[0].GetText()), std::stoi(lineEdits[1].GetText()));

    const std::string ipAddress = lineEdits[3].GetText();
    std::string portStr = lineEdits[4].GetText();

    if (!std::all_of(portStr.begin(), portStr.end(), ::isdigit))
    {
        std::cerr << "Invalid port number!\n";
        return;
    }
    const int port = std::stoi(portStr);

    if (!server->isInitialised())
    {
        std::cerr << "Server not initialised!\n";
        return;
    }
    bool hasStarted = server->BindServer(ipAddress.c_str(), port);
    serverAddr.SetText("Server Address: " + ipAddress + ":" + std::to_string(port));

    if (!hasStarted)
    {
        std::cerr << "Failed to bind server!\n";
        return;
    }
    server->AcceptNewClients();
    server->StartGames();
    std::cout << "Server running!\n";
    page = 5;

    // Init Server Panel
    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    Button shutdownServer(500, 800, 300, 60);
    shutdownServer.SetText("Shutdown Server");
    shutdownServer.whenClicked(InitMenu);

    labels.emplace_back(&serverAddr);
    labels.emplace_back(&playersWaiting);
    labels.emplace_back(&playersInGame);

    buttons.emplace_back(shutdownServer);
}

void InitHostServer()
{
    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    PageHandler::InitHostServer(buttons, lineEdits, SCR_WIDTH, SCR_HEIGHT);
    buttons.at(0).whenClicked(StartServer);
    buttons.at(1).whenClicked(InitMenu);

    BuildWidgets();
}

void InitMultiplayer()
{
    renderer.SetBackgroundColour({0.0f, 0.73f, 0.96f, 1.0f});

    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    PageHandler::InitMultiplayer(buttons);
    buttons.at(0).whenClicked(InitJoinGame);
    buttons.at(1).whenClicked(InitHostServer);

    BuildWidgets();
}

void InitMenu()
{
    page = 1;

    // Important order
    if (server != nullptr) { delete server; }
    server = nullptr;

    if (client != nullptr) { delete client; }
    client = nullptr;

    if (grid != nullptr) { delete grid; }
    grid = nullptr;

    playMode = PlayModes::LOCAL;

    renderer.SetBackgroundColour({0.0f, 0.73f, 0.96f, 1.0f});

    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    gameTitle.hide();

    gameMenu2.SetFont("res/fonts/Fredoka-Bold.ttf");
    gameMenu2.SetTextScale(2.0f);
    labels.emplace_back(&gameMenu2);

    gameMenu.SetFont("res/fonts/Fredoka-Bold.ttf");
    gameMenu.SetTextScale(2.0f);
    labels.emplace_back(&gameMenu);

    Frame frame(75, 175, 370, 650);
    frame.SetColour(0.7f, 0.7f, 0.7f);
    frames.emplace_back(frame);

    PageHandler::InitMenu(buttons, labels, SCR_WIDTH, gameTitle, attacksUsed);

    buttons.at(0).whenClicked(InitStartMenu); // "Local" button (start game)
    buttons.at(1).whenClicked(InitMultiplayer); // "Multiplayer" button (multiplayer game)
    buttons.at(2).whenClicked(InitSettings); // "Settings" button (settings)

    BuildWidgets();
}

void InitStartMenu()
{
    renderer.SetBackgroundColour({0.0f, 0.73f, 0.96f, 1.0f});

    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    gameTitle.show();

    CallbackType callbacks[] = {DecreaseAttack, IncreaseAttack, StartGame, InitMenu};

    PageHandler::InitStartMenu(buttons, labels, SCR_WIDTH, gameTitle, attacksUsed);

    for (uint8_t i = 0; i < sizeof(callbacks)/sizeof(CallbackType); i++)
    {
        buttons.at(i).whenClicked(callbacks[i]);
    }

    BuildWidgets();
    page = 4;
}

void InitEndMenu()
{
    Team winner = Team::WHITE;
    if (grid != nullptr && grid->GetPlayers().size() > 0)
    {
        winner = grid->GetPlayers().at(0).GetTeam();
    }

    renderer.SetBackgroundColour({1.0f, 1.0f, 1.0f, 1.0f});

    if (grid != nullptr) { delete grid; }
    grid = nullptr;

    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    PageHandler::InitEndMenu(buttons, labels, winner, SCR_WIDTH, SCR_HEIGHT, gameOver);

    buttons.at(0).whenClicked(InitMenu);

    BuildWidgets();
    page = 3;
}

void ToggleVSYNC()
{
    CheckBox& checkBox = checkboxes.at(0);
    if (!checkBox.isChecked)
    {
        VSYNC = false;
        glfwSwapInterval(0);
    }
    else
    {
        VSYNC = true;
        glfwSwapInterval(1);
    }

    vertices.clear();
    texturedVertices.clear();
    BuildWidgets();
}

void InitSettings()
{
    PageHandler::ClearUI(labels, buttons, vertices, checkboxes, frames, texturedVertices, lineEdits);

    PageHandler::InitSettings(checkboxes, buttons);

    if (VSYNC)
    {
        checkboxes.at(0).SetChecked(true);
    }

    checkboxes.at(0).whenClicked(ToggleVSYNC);
    buttons.at(0).whenClicked(InitMenu);

    BuildWidgets();
}

void character_callback(GLFWwindow* window, unsigned int codepoint)
{
    for (LineEdit& lineEdit : lineEdits)
    {
        if (lineEdit.isSelected())
        {
            lineEdit.AddChar(codepoint);
        }
    }
}

void SetPlayerStatText()
{
    if (grid == nullptr) { return; }
    std::vector<Player> players = grid->GetPlayers();
    for (int i = 0; i < grid->GetPlayerCount(); i++)
    {
        Player& player = players.at(i);
        std::string playerIdentifier = "";

        Team playerTeam = player.GetTeam();
        if (playMode == PlayModes::MULTIPLAYER && client->GetTeam() == playerTeam)
        {
            playerIdentifier = "(YOU) ";
        }

        if (playerTeam == Team::RED)
        {
            redStats.SetText(playerIdentifier + "RED STATS - HP: " + std::to_string(player.HP) + " | Money: " + std::to_string(player.money) + " | Attack Points: " + std::to_string(player.attackAmount));
        }
        else if (playerTeam == Team::YELLOW)
        {
            yellowStats.SetText(playerIdentifier + "YELLOW STATS - HP: " + std::to_string(player.HP) + " | Money: " + std::to_string(player.money) + " | Attack Points: " + std::to_string(player.attackAmount));
        }
        else if (playerTeam == Team::GREEN)
        {
            greenStats.SetText(playerIdentifier + "GREEN STATS - HP: " + std::to_string(player.HP) + " | Money: " + std::to_string(player.money) + " | Attack Points: " + std::to_string(player.attackAmount));
        }
        else if (playerTeam == Team::BLUE)
        {
            blueStats.SetText(playerIdentifier + "BLUE STATS - HP: " + std::to_string(player.HP) + " | Money: " + std::to_string(player.money) + " | Attack Points: " + std::to_string(player.attackAmount));
        }
    }
}