#include <cstdio>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include "../include/RenderBackend/OpenGL/VertexShader.hpp"
#include "../include/RenderBackend/OpenGL/PixelShader.hpp"
#include "../include/RenderBackend/OpenGL/ShaderProgram.hpp"
#include "../include/RenderBackend/OpenGL/DeviceMemory.hpp"

using namespace amalgine;
using namespace std;

void initGlfw();
void initGlew();
GLFWwindow *createWindow();

CompiledVertexShader* createVertexShader();
CompiledPixelShader* createPixelShader();

int main()
{
    initGlfw();
    GLFWwindow *window = createWindow();
    
    f32 verticesRaw[] = 
    {
        0.0f, 0.5f,
        0.5f, -0.5f,
        -0.5f, -0.5f
    };
    DataView<f32> vertices(verticesRaw, 6);
    DeviceMemory triangle;
    triangle.copyAsStatic(vertices);
    
    CompiledVertexShader *vertexShader = createVertexShader();
    CompiledPixelShader *pixelShader = createPixelShader();
    
    ShaderProgram shaderProgram;
    shaderProgram.addVertexShader(vertexShader);
    shaderProgram.addPixelShader(pixelShader);
    Result<bool> shaderBuildResult = shaderProgram.build();
    if(!shaderBuildResult)
    {
        fprintf(stderr, "Failed to build shader program: %s\n", shaderBuildResult.getErrorMsg().c_str());
        exit(20);
    }
    
    while(!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
        if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            glfwSetWindowShouldClose(window, GL_TRUE);

        shaderProgram.use();
        glfwSwapBuffers(window);
    }

    glfwTerminate();
    return 0;
}

void initGlfw()
{
    if(!glfwInit())
    {
        fprintf(stderr, "Failed to initialize GLFW\n");
        exit(-1);
    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
}

void initGlew()
{
    glewExperimental = true;
    if(glewInit() != GLEW_OK)
    {
        fprintf(stderr, "Failed to initialize GLEW\n");
        glfwTerminate();
        exit(-1);
    }
}

GLFWwindow* createWindow()
{
    GLFWwindow *window = glfwCreateWindow(1280, 720, "Amalgine", nullptr, nullptr);
    if(!window)
    {
        fprintf(stderr, "Failed to open GLFW window\n");
        glfwTerminate();
        exit(10);
    }

    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
    glfwMakeContextCurrent(window);
    initGlew();
    return window;
}

CompiledVertexShader* createVertexShader()
{
    VertexShader vertexShader;
    ShaderInputVec2 inputPosition = vertexShader.defineInputVec2("position");
    
    vertexShader.defineMain([&inputPosition]()
    {
        return ShaderVec4(inputPosition, 0.0f, 1.0f);
    });
    
    Result<CompiledVertexShader*> compiledVertexShader = vertexShader.compile();
    if(!compiledVertexShader)
    {
        fprintf(stderr, "Failed to compile vertex shader:\n%s", compiledVertexShader.getErrorMsg().c_str());
        exit(2);
    }
    
    return compiledVertexShader.unwrap();
}

CompiledPixelShader* createPixelShader()
{
    PixelShader pixelShader;
    ShaderOutputVec4 outColor = pixelShader.defineOutputVec4("outColor");
    
    pixelShader.defineMain([&outColor]()
    {
        outColor = ShaderVec4(1.0f, 1.0f, 1.0f, 1.0f);
    });
    
    Result<CompiledPixelShader*> compiledPixelShader = pixelShader.compile();
    if(!compiledPixelShader)
    {
        fprintf(stderr, "Failed to compile pixel shader:\n%s", compiledPixelShader.getErrorMsg().c_str());
        exit(2);
    }
    
    return compiledPixelShader.unwrap();
}