Application.cpp

#include "Application.h"
#include <iostream>
#include <vector>
#include <glad/glad.h>
#include <glm/gtc/matrix_transform.hpp>

#include "constants.h"
#include "Cuboid.h"

Application::Application(const int w, const int h, const char *title, DeepCube deep_cube) :
window(nullptr), width(w), height(h), cube(*deep_cube.cube), ai(*deep_cube.ai), solver(*deep_cube.solver) {
    if (initWindow(title)) renderer = new Renderer();
}

Application::~Application() {
    delete renderer;
    glfwTerminate();
}

bool Application::initWindow(const char *title) {glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    window = glfwCreateWindow(width, height, title, NULL, NULL);
    if (!window) return false;

    glfwMakeContextCurrent(window);

    glfwSetWindowUserPointer(window, this);
    glfwSetScrollCallback(window, scrollCallback);
    glfwSetFramebufferSizeCallback(window, framebufferSizeCallback);
    glfwSetKeyCallback(window, keyCallback);

    gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
    glEnable(GL_DEPTH_TEST);
    return true;
}

void Application::processInput() {
    // Close window on Escape
    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }

    // Mouse Drag Logic
    if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS) {
        if (!isDragging) {
            // We JUST clicked. Store the starting position.
            isDragging = true;
            glfwGetCursorPos(window, &lastMouseX, &lastMouseY);
        } else {
            // We are actively dragging. Calculate how far the mouse moved.
            double currentX, currentY;
            glfwGetCursorPos(window, &currentX, &currentY);

            double deltaX = currentX - lastMouseX;
            double deltaY = currentY - lastMouseY;

            // Update camera angles (multiplied by a sensitivity factor)
            cameraYaw += (float)deltaX * 0.5f;
            cameraPitch += (float)deltaY * 0.5f;

            // Clamp the pitch so we don't break our neck (Gimbal Lock)
            if (cameraPitch > 89.0f) cameraPitch = 89.0f;
            if (cameraPitch < -89.0f) cameraPitch = -89.0f;

            // Update last positions for the next frame
            lastMouseX = currentX;
            lastMouseY = currentY;
        }
    } else {
        // Mouse button was released
        isDragging = false;
    }
}

void Application::scrollCallback(GLFWwindow *window, double x_offset, double y_offset) {
    Application* app = static_cast<Application*>(glfwGetWindowUserPointer(window));

    if (app) {
        // y_offset is usually +1 for scrolling up, and -1 for scrolling down
        app->cameraDistance -= (float)y_offset * 0.5f; // The 0.5f is scroll sensitivity

        // Clamp the distance so you can't zoom completely inside the cube or fly into the void
        if (app->cameraDistance < 3.0f) app->cameraDistance = 3.0f;
    }
}

void Application::framebufferSizeCallback(GLFWwindow *window, int width, int height) {
    // 1. Tell OpenGL to adjust its drawing canvas to the new window size
    glViewport(0, 0, width, height);

    // 2. Update our Application's internal variables so the Camera matrix adapts
    if (const auto app = static_cast<Application*>(glfwGetWindowUserPointer(window))) {
        app->width = width;
        app->height = height;
    }
}

void Application::keyCallback(GLFWwindow *window, int key, int scancode, int action, int mods) {
    if (action != GLFW_PRESS) return;

    const auto app = static_cast<Application*>(glfwGetWindowUserPointer(window));
    if (!app) return;
    if (app->is_solving) return;

    switch (key) {
        case GLFW_KEY_SPACE: {
            Move move = app->cube.getRandomMove();
            std::cout << ">> Performing a random move: " << move.toString() << std::endl;
            app->moveQueue.push(move);
            break;
        }
        case GLFW_KEY_R: {
            std::cout << ">> Scrambling the cube" << std::endl;
            app->animationSpeed = SCRAMBLE_SPEED;
            for (int i = 0; i < 20; ++i) {
                app->moveQueue.push(app->cube.getRandomMove());
            }
            break;
        }
        case GLFW_KEY_S: {
            std::cout << ">> Solving with A* search" << std::endl;
            app->is_solving = true;

            std::shared_ptr thread_safe_cube = app->cube.clone();
            app->solution_future = std::async(std::launch::async, [thread_safe_cube, app]() {
                return app->solver.solve(*thread_safe_cube, app->ai);
            });
            break;
        }
        default: break;
    }
}

void Application::run() {
    if (!window || !renderer) return;

    while (!glfwWindowShouldClose(window)) {
        processInput();

        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 1. Setup Camera (Orbit logic)
        glm::mat4 view = glm::mat4(1.0f);

        // Step B: Push the whole world away from the camera
        view = glm::translate(view, glm::vec3(0.0f, 0.0f, -cameraDistance));

        // Step A: Rotate the world based on our mouse angles
        view = glm::rotate(view, glm::radians(cameraPitch), glm::vec3(1.0f, 0.0f, 0.0f));
        view = glm::rotate(view, glm::radians(cameraYaw),   glm::vec3(0.0f, 1.0f, 0.0f));

        glm::mat4 projection = glm::perspective(glm::radians(45.0f), (float)width / (float)height, 0.1f, 100.0f);

        // --- TIME TRACKING ---
        float currentFrame = (float)glfwGetTime();
        float deltaTime = currentFrame - lastFrameTime;
        lastFrameTime = currentFrame;

        // --- CHECK BACKGROUND SOLVER ---
        if (is_solving && solution_future.valid()) {
            if (solution_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
                std::vector<int> solution_path = solution_future.get();
                is_solving = false;

                if (!solution_path.empty()) {
                    for (int move_id : solution_path) {
                        moveQueue.push(cube.getMove(move_id));
                    }
                    animationSpeed = SOLVE_SPEED;
                }
            }
        }

        // --- QUEUE PROCESSING ---
        if (!isAnimating && !moveQueue.empty()) {
            Move nextMove = moveQueue.front();
            moveQueue.pop();
            triggerMove(nextMove);
        }

        // --- ANIMATION UPDATE ---
        if (isAnimating) {
            float step = animationSpeed * deltaTime;

            if (std::abs(targetAngle - currentAngle) <= step) {
                currentAngle = targetAngle;
                isAnimating = false;
                cube.applyMove(currentMove);
                if (moveQueue.empty())
                    animationSpeed = ANIMATION_SPEED;
            } else {
                currentAngle += (targetAngle > currentAngle) ? step : -step;
            }
        }

        // --- FETCH & RENDER ---
        std::vector<Cubelet> active_state = cube.getRenderState();

        for (Cubelet& c : active_state) {
            if (isAnimating) {
                bool inActiveSlice = false;
                glm::vec3 rotAxis;

                if (currentMove.axis == X && c.x == currentMove.slice_index) {
                    inActiveSlice = true; rotAxis = glm::vec3(1.0f, 0.0f, 0.0f);
                }
                else if (currentMove.axis == Y && c.y == currentMove.slice_index) {
                    inActiveSlice = true; rotAxis = glm::vec3(0.0f, 1.0f, 0.0f);
                }
                else if (currentMove.axis == Z && c.z == currentMove.slice_index) {
                    inActiveSlice = true; rotAxis = glm::vec3(0.0f, 0.0f, 1.0f);
                }

                if (inActiveSlice) {
                    glm::mat4 rotMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(currentAngle), rotAxis);
                    c.transform = rotMatrix * c.transform;
                }
            }

            renderer->draw(c, view, projection);
        }

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
}

void Application::triggerMove(const Move &move) {
    if (isAnimating) return;

    isAnimating = true;
    currentMove = move;
    currentAngle = 0.0f;

    switch (move.rotation) {
        case CW:     targetAngle =  90.0f; break;
        case CCW:    targetAngle = -90.0f; break;
        case Double: targetAngle = 180.0f; break;
        default: break;
    }
}