#include <getopt.h>

#include "Engine.h"
#include "Game.h"
#include "input/Controller.h"
#include "rendering/Shader.h"
#include "rendering/Window.h"

static Shader shader;
static Renderer renderer{shader};

static bool parseArgs(int argAmount, char* const* args,
                      Window::Options& options) {
    while(true) {
        switch(getopt(argAmount, args, "fv")) {
            case '?': return true;
            case 'f': options.fullscreen = true; break;
            case 'v': options.vsync = true; break;
            case -1: return false;
        }
    }
}

bool Engine::init(int argAmount, char* const* args) {
    Window::Options options(3, 0, {800, 480}, true, "Pigine");
    if(parseArgs(argAmount, args, options)) {
        return true;
    }
    Error error = Window::open(options);
    if(error.has()) {
        error.message.printLine();
        return true;
    }
    error = shader.compile("resources/shader/vertex.vs",
                           "resources/shader/fragment.fs");
    if(error.has()) {
        error.message.printLine();
        return true;
    }
    Controller::init();
    return false;
}

static void tick() {
    Game::tick();
}

static void render(float lag) {
    GL::clear();
    const IntVector2& size = Window::getSize();
    GL::setViewport(size[0], size[1]);

    Matrix view;
    view.scale(Vector3(2.0f / size[0], -2.0f / size[1], 1.0f));
    view.translate(Vector3(-1.0f, 1.0f, 0.0f));
    shader.setMatrix("view", view.getValues());

    Game::render(lag, renderer);
    GL::printError("GL-Error");
}

static bool isRunning() {
    return Game::isRunning();
}

void Engine::start() {
    renderer.init();
    Window::show();
    Window::run<isRunning, tick, render>(10'000'000);
}

const IntVector2& Engine::getSize() {
    return Window::getSize();
}