#pragma once
#include "commons.h"


class Technique
{
public:
    Technique();
    ~Technique();

    virtual bool Init();

    void Enable();

protected:
    bool AddShader(GLenum ShaderType, const char* pShaderText);
    bool Finalize();

    GLint GetUniformLocation(const char* pUniformName);
    GLint GetProgramParam(GLint param);

    GLuint m_shaderProg;

private:
    typedef std::list<GLuint> ShaderObjList;
    ShaderObjList m_shaderObjList;
};

////////////////////////////////////////////////////////

#include "Technique.h"

static const char* pVSName = "VS";
static const char* pTessCSName = "TessCS";
static const char* pTessESName = "TessES";
static const char* pGSName = "GS";
static const char* pFSName = "FS";

const char* ShaderType2ShaderName(GLuint Type)
{
    switch (Type)
    {
    case GL_VERTEX_SHADER :
        return pVSName;
    case GL_TESS_CONTROL_SHADER :
        return pTessCSName;
    case GL_TESS_EVALUATION_SHADER :
        return pTessESName;
    case GL_GEOMETRY_SHADER :
        return pGSName;
    case GL_FRAGMENT_SHADER :
        return pFSName;
    default :
        assert(0);
    }

    return NULL;
}


Technique::Technique()
{
    m_shaderProg = 0;
}


Technique::~Technique()
{
    for (ShaderObjList::iterator it = m_shaderObjList.begin(); it != m_shaderObjList.end(); it++)
    {
        glDeleteShader(*it);
    }

    if (m_shaderProg != 0)
    {
        glDeleteProgram(m_shaderProg);
        m_shaderProg = 0;
    }
}


bool Technique::Init()
{
    m_shaderProg = glCreateProgram();

    if (m_shaderProg == 0)
    {
        std::cout << "Error creating shader program" << std::endl;
        return false;
    }

    return true;
}


bool Technique::AddShader(GLenum ShaderType, const char* pShaderText)
{
    GLuint ShaderObj = glCreateShader(ShaderType);

    if (ShaderObj == 0)
    {
        std::cout << "Error creating shader type" << std::endl;
        return false;
    }

    m_shaderObjList.push_back(ShaderObj);

    const GLchar* p[1];
    p[0] = pShaderText;
    GLint Lengths[1];
    Lengths[0] = strlen(pShaderText);
    glShaderSource(ShaderObj, 1, p, Lengths);

    glCompileShader(ShaderObj);

    GLint success;
    glGetShaderiv(ShaderObj, GL_COMPILE_STATUS, &success);

    if (!success)
    {
        GLchar InfoLog[1024];
        glGetShaderInfoLog(ShaderObj, 1024, NULL, InfoLog);
        std::cout << "Error compiling " << ShaderType2ShaderName(ShaderType) << ": " << InfoLog << std::endl;
        return false;
    }

    glAttachShader(m_shaderProg, ShaderObj);

    return GLCheckError();
}


bool Technique::Finalize()
{
    GLint Success = 0;
    GLchar ErrorLog[1024] = { 0 };

    glLinkProgram(m_shaderProg);

    glGetProgramiv(m_shaderProg, GL_LINK_STATUS, &Success);
    if (Success == 0)
    {
        glGetProgramInfoLog(m_shaderProg, sizeof(ErrorLog), NULL, ErrorLog);
        std::cout << "Error linking shader program: " << ErrorLog << std::endl;
        return false;
    }

    glValidateProgram(m_shaderProg);
    glGetProgramiv(m_shaderProg, GL_VALIDATE_STATUS, &Success);
    if (!Success)
    {
        glGetProgramInfoLog(m_shaderProg, sizeof(ErrorLog), NULL, ErrorLog);
        std::cout << "Invalid shader program: " << ErrorLog << std::endl;
        return false;
    }

    for (ShaderObjList::iterator it = m_shaderObjList.begin(); it != m_shaderObjList.end(); it++)
    {
        glDeleteShader(*it);
    }

    m_shaderObjList.clear();

    return GLCheckError();
}


void Technique::Enable()
{
    glUseProgram(m_shaderProg);
}


GLint Technique::GetUniformLocation(const char* pUniformName)
{
    GLuint Location = glGetUniformLocation(m_shaderProg, pUniformName);

    if (Location == INVALID_OGL_VALUE)
    {
        std::cout << "#####Warning!##### Unable to locate of uniform " << pUniformName << std::endl;
        return false;
    }

    std::cout << "Location of uniform '" << pUniformName << "' found" << std::endl;

    return Location;
}


GLint Technique::GetProgramParam(GLint param)
{
    GLint ret;
    glGetProgramiv(m_shaderProg, param, &ret);
    return ret;
}