#include "shader.h"
#include "debug.h"
#include <fstream>
#include <sstream>
#include <stdexcept>

#include <iostream>

namespace {
    std::string loadFileContents(const char* path)
    {
        std::ifstream inFile(path);
        if (!inFile.is_open()) {
            std::cout << "Could not open file " << path << std::endl;
            return "";
        }
        std::stringstream stream;
        stream << inFile.rdbuf();
        return stream.str();
    }

    GLuint compileShader(const std::string_view source, GLenum shaderType)
    {
        auto shaderID = glCheck(glCreateShader(shaderType));

        const GLchar* const shaderSourcePtr = source.data();
        const GLint shaderSourceLength = source.length();
        glCheck(glShaderSource(shaderID, 1, &shaderSourcePtr, &shaderSourceLength));
        glCheck(glCompileShader(shaderID));

        GLint logLength;
        glCheck(glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLength));
        if (logLength) {
            std::string infoLog(logLength, 0);
            glCheck(glGetShaderInfoLog(shaderID, logLength, nullptr, infoLog.data()));

            throw std::runtime_error(infoLog);
        }

        return shaderID;
    }

    GLuint linkProgram(GLuint vertexShaderID, GLuint fragmentShaderID)
    {
        auto id = glCheck(glCreateProgram());

        glCheck(glAttachShader(id, vertexShaderID));
        glCheck(glAttachShader(id, fragmentShaderID));

        glCheck(glLinkProgram(id));

        glCheck(glDetachShader(id, fragmentShaderID));
        glCheck(glDetachShader(id, vertexShaderID));

        GLint logLength;
        glCheck(glGetProgramiv(id, GL_INFO_LOG_LENGTH, &logLength));
        if (logLength) {
            std::string infoLog(logLength, 0);
            glCheck(glGetProgramInfoLog(id, logLength, nullptr, infoLog.data()));
            throw std::runtime_error(infoLog);
        }

        return id;
    }
} // namespace

namespace mus {
    Shader createShader(const char* vertexShaderFile, const char* fragmentShaderFile)
    {
        Shader shader;
        std::string vertexShader = loadFileContents(vertexShaderFile);
        std::string fragmentShader = loadFileContents(fragmentShaderFile);

        GLuint vertexProgram = compileShader(vertexShader, GL_VERTEX_SHADER);
        GLuint fragmentProgram = compileShader(fragmentShader, GL_FRAGMENT_SHADER);

        shader.program = linkProgram(vertexProgram, fragmentProgram);

        glCheck(glDetachShader(shader.program, vertexProgram));
        glCheck(glDetachShader(shader.program, fragmentProgram));

        glCheck(glDeleteShader(vertexProgram));
        glCheck(glDeleteShader(fragmentProgram));

        return shader;
    }
} // namespace mus