#pragma once
#include "commons.h"
#include "Technique.h"
#include "Math3D.h"

struct BaseLight
{
    glm::vec3 Color;
    float AmbientIntensity;
    float DiffuseIntensity;

    BaseLight()
    {
        Color = glm::vec3(0.f, 0.f, 0.f);
        AmbientIntensity = 0.f;
        DiffuseIntensity = 0.f;
    }
};


struct DirectionalLight : public BaseLight
{
    glm::vec3 Direction;

    DirectionalLight()
    {
        Direction = glm::vec3(0.f, 0.f, 0.f);
    }
};


struct PointLight : public BaseLight
{
    glm::vec3 Position;

    struct
    {
        float Constant;
        float Linear;
        float Exp;
    } Attenuation;

    PointLight()
    {
        Position = glm::vec3(0.f, 0.f, 0.f);
        Attenuation.Constant = 1.f;
        Attenuation.Linear = 0.f;
        Attenuation.Exp = 0.f;
    }
};


struct SpotLight : public PointLight
{
    glm::vec3 Direction;
    float Cutoff;

    SpotLight()
    {
        Direction = glm::vec3(0.f, 0.f, 0.f);
        Cutoff = 0.f;
    }
};


class Lighting : public Technique
{
public:
    static const unsigned int MAX_POINT_LIGHTS = 2;
    static const unsigned int MAX_SPOT_LIGHTS = 2;

    Lighting();

    virtual bool Init();

    void SetWVP(const Mat4f &WVP);
    void SetWorldMatrix(const Mat4f &WorldInverse);
    void SetColorTextureUnit(unsigned int TextureUnit);
    void setDirectionalLight(const DirectionalLight &Light);
    void setPointLights(unsigned int NumLights, const PointLight *pLights);
    void setSpotLights(unsigned int NumLights, const SpotLight *pLights);
    void setEyeWorldPos(const glm::vec3 &EyeWorldPos);
    void setMatSpecularIntensity(float Intensity);
    void setMatSpecularPower(float Power);

private:
    GLuint m_WVPLocation;
    GLuint m_WorldMatrixLocation;
    GLuint m_colorTextureLocation;
    GLuint m_eyeWorldPosLocation;
    GLuint m_matSpecularIntensityLocation;
    GLuint m_matSpecularPowerLocation;
    GLuint m_numPointLightsLocation;
    GLuint m_numSpotLightsLocation;

    struct
    {
        GLuint Color;
        GLuint AmbientIntensity;
        GLuint DiffuseIntensity;
        GLuint Direction;
    } m_dirLightLocation;

    struct
    {
        GLuint Color;
        GLuint AmbientIntensity;
        GLuint DiffuseIntensity;
        GLuint Position;
        struct
        {
            GLuint Constant;
            GLuint Linear;
            GLuint Exp;
        } Atten;
    } m_pointLightsLocation[MAX_POINT_LIGHTS];

    struct
    {
        GLuint Color;
        GLuint AmbientIntensity;
        GLuint DiffuseIntensity;
        GLuint Position;
        GLuint Direction;
        GLuint Cutoff;
        struct
        {
            GLuint Constant;
            GLuint Linear;
            GLuint Exp;
        } Atten;
    } m_spotLightsLocation[MAX_SPOT_LIGHTS];
};

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

#include "Lighting.h"

static const char* pVS =
"#version 330 \n\
\n\
layout(location = 0) in vec3 Position;\n\
layout(location = 1) in vec2 TexCoord;\n\
layout(location = 2) in vec3 Normal;\n\
\n\
uniform mat4 gWVP;\n\
uniform mat4 gWorld;\n\
\n\
out vec2 TexCoord0; \n\
out vec3 Normal0;\n\
out vec3 WorldPos0;\n\
\n\
void main()\n\
{\n\
    gl_Position = gWVP * vec4(Position, 1.0);\n\
    TexCoord0 = TexCoord;\n\
    Normal0 = (gWorld * vec4(Normal, 0.0)).xyz;\n\
    WorldPos0 = (gWorld * vec4(Position, 1.0)).xyz;\n\
}";

static const char* pFS =
"#version 330\n\
\n\
const int MAX_POINT_LIGHTS = 2;\n\
const int MAX_SPOT_LIGHTS = 2;\n\
\n\
in vec2 TexCoord0;\n\
in vec3 Normal0;\n\
in vec3 WorldPos0;\n\
\n\
out vec4 FragColor;\n\
\n\
struct BaseLight\n\
{\n\
    vec3 Color;\n\
    float AmbientIntensity;\n\
    float DiffuseIntensity;\n\
};\n\
\n\
struct DirectionalLight\n\
{\n\
    BaseLight Base;\n\
    vec3 Direction;\n\
};\n\
\n\
struct Attenuation\n\
{\n\
    float Constant; \n\
    float Linear;\n\
    float Exp;\n\
};\n\
\n\
struct PointLight\n\
{\n\
    BaseLight Base; \n\
    vec3 Position;\n\
    Attenuation Atten;\n\
};\n\
\n\
struct SpotLight\n\
{\n\
    PointLight Base;\n\
    vec3 Direction;\n\
    float Cutoff;\n\
};\n\
\n\
uniform int gNumPointLights;\n\
uniform int gNumSpotLights;\n\
uniform DirectionalLight gDirectionalLight;\n\
uniform PointLight gPointLights[MAX_POINT_LIGHTS];\n\
uniform SpotLight gSpotLights[MAX_SPOT_LIGHTS];\n\
uniform sampler2D gColorMap;\n\
uniform vec3 gEyeWorldPos;\n\
uniform float gMatSpecularIntensity;\n\
uniform float gSpecularPower;\n\
\n\
vec4 CalcLightInternal(BaseLight Light, vec3 LightDirection, vec3 Normal)\n\
{\n\
    vec4 AmbientColor = vec4(Light.Color, 1.0f) * Light.AmbientIntensity;\n\
    float DiffuseFactor = dot(Normal, -LightDirection);\n\
        \n\
    vec4 DiffuseColor = vec4(0, 0, 0, 0); \n\
    vec4 SpecularColor = vec4(0, 0, 0, 0); \n\
    \n\
    if (DiffuseFactor > 0) {\n\
        DiffuseColor = vec4(Light.Color, 1.0f) * Light.DiffuseIntensity * DiffuseFactor;\n\
                \n\
        vec3 VertexToEye = normalize(gEyeWorldPos - WorldPos0); \n\
        vec3 LightReflect = normalize(reflect(LightDirection, Normal)); \n\
        float SpecularFactor = dot(VertexToEye, LightReflect); \n\
        SpecularFactor = pow(SpecularFactor, gSpecularPower); \n\
        if (SpecularFactor > 0) {\n\
            SpecularColor = vec4(Light.Color, 1.0f) *\n\
                gMatSpecularIntensity * SpecularFactor;\n\
        }\n\
    }\n\
        \n\
    return (AmbientColor + DiffuseColor + SpecularColor);\n\
}\n\
\n\
vec4 CalcDirectionalLight(vec3 Normal)\n\
{\n\
    return CalcLightInternal(gDirectionalLight.Base, gDirectionalLight.Direction, Normal);\n\
}\n\
\n\
vec4 CalcPointLight(PointLight l, vec3 Normal)\n\
{\n\
    vec3 LightDirection = WorldPos0 - l.Position;\n\
    float Distance = length(LightDirection);\n\
    LightDirection = normalize(LightDirection);\n\
        \n\
    vec4 Color = CalcLightInternal(l.Base, LightDirection, Normal);\n\
    float Attenuation = l.Atten.Constant +\n\
        l.Atten.Linear * Distance +\n\
        l.Atten.Exp * Distance * Distance;\n\
                \n\
    return Color / Attenuation;\n\
}\n\
\n\
vec4 CalcSpotLight(SpotLight l, vec3 Normal)\n\
{\n\
    vec3 LightToPixel = normalize(WorldPos0 - l.Base.Position);\n\
    float SpotFactor = dot(LightToPixel, l.Direction);\n\
        \n\
    if (SpotFactor > l.Cutoff) {\n\
        vec4 Color = CalcPointLight(l.Base, Normal);\n\
        return Color * (1.0 - (1.0 - SpotFactor) * 1.0 / (1.0 - l.Cutoff));\n\
    }\n\
    else {\n\
        return vec4(0, 0, 0, 0);\n\
    }\n\
}\n\
\n\
void main()\n\
{\n\
    vec3 Normal = normalize(Normal0);\n\
    vec4 TotalLight = CalcDirectionalLight(Normal);\n\
        \n\
    for (int i = 0; i < gNumPointLights; i++) {\n\
        TotalLight += CalcPointLight(gPointLights[i], Normal);\n\
    }\n\
        \n\
    for (int i = 0; i < gNumSpotLights; i++) {\n\
        TotalLight += CalcSpotLight(gSpotLights[i], Normal);\n\
    }\n\
        \n\
    FragColor = texture(gColorMap, TexCoord0.xy) * TotalLight;\n\
}";

Lighting::Lighting()
{
}


bool Lighting::Init()
{
    if (!Technique::Init())
        return false;

    if (!AddShader(GL_VERTEX_SHADER, pVS))
        return false;

    if (!AddShader(GL_FRAGMENT_SHADER, pFS))
        return false;

    if (!Finalize())
        return false;

    std::cout << "\n-------------------------" << std::endl;
    std::cout << "LOCATIONS" << std::endl;
    std::cout << "-------------------------" << std::endl;

    m_WVPLocation = GetUniformLocation("gWVP");
    m_WorldMatrixLocation = GetUniformLocation("gWorld");
    m_colorTextureLocation = GetUniformLocation("gColorMap");
    m_eyeWorldPosLocation = GetUniformLocation("gEyeWorldPos");
    m_dirLightLocation.Color = GetUniformLocation("gDirectionalLight.Base.Color");
    m_dirLightLocation.AmbientIntensity = GetUniformLocation("gDirectionalLight.Base.AmbientIntensity");
    m_dirLightLocation.Direction = GetUniformLocation("gDirectionalLight.Direction");
    m_dirLightLocation.DiffuseIntensity = GetUniformLocation("gDirectionalLight.Base.DiffuseIntensity");
    m_matSpecularIntensityLocation = GetUniformLocation("gMatSpecularIntensity");
    m_matSpecularPowerLocation = GetUniformLocation("gSpecularPower");
    m_numPointLightsLocation = GetUniformLocation("gNumPointLights");
    m_numSpotLightsLocation = GetUniformLocation("gNumSpotLights");

    if (m_dirLightLocation.AmbientIntensity == INVALID_UNIFORM_LOCATION ||
        m_WVPLocation == INVALID_UNIFORM_LOCATION ||
        m_colorTextureLocation == INVALID_UNIFORM_LOCATION ||
        m_WorldMatrixLocation == INVALID_UNIFORM_LOCATION ||
        m_eyeWorldPosLocation == INVALID_UNIFORM_LOCATION ||
        m_dirLightLocation.Color == INVALID_UNIFORM_LOCATION ||
        m_dirLightLocation.AmbientIntensity == INVALID_UNIFORM_LOCATION ||
        m_dirLightLocation.Direction == INVALID_UNIFORM_LOCATION ||
        m_dirLightLocation.DiffuseIntensity == INVALID_UNIFORM_LOCATION ||
        m_matSpecularIntensityLocation == INVALID_UNIFORM_LOCATION ||
        m_matSpecularPowerLocation == INVALID_UNIFORM_LOCATION ||
        m_numPointLightsLocation == INVALID_UNIFORM_LOCATION ||
        m_numSpotLightsLocation == INVALID_UNIFORM_LOCATION)
    {
        std::cout << "\nLighting-ERROR: problem here init-Invalid uniform location\n" << std::endl;
        //return false;
    }

    std::cout << "\n" << std::endl;
    for (unsigned int i = 0; i < ARRAY_SIZE_IN_ELEMENTS(m_pointLightsLocation); i++)
    {
        char name[128];
        memset(name, 0, sizeof(name));

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Base.Color", i);
        m_pointLightsLocation[i].Color = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Base.AmbientIntensity", i);
        m_pointLightsLocation[i].AmbientIntensity = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Position", i);
        m_pointLightsLocation[i].Position = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Base.DiffuseIntensity", i);
        m_pointLightsLocation[i].DiffuseIntensity = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Atten.Constant", i);
        m_pointLightsLocation[i].Atten.Constant = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Atten.Linear", i);
        m_pointLightsLocation[i].Atten.Linear = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gPointLights[%d].Atten.Exp", i);
        m_pointLightsLocation[i].Atten.Exp = GetUniformLocation(name);

        if (m_pointLightsLocation[i].Color == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].AmbientIntensity == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].Position == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].DiffuseIntensity == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].Atten.Constant == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].Atten.Linear == INVALID_UNIFORM_LOCATION ||
            m_pointLightsLocation[i].Atten.Exp == INVALID_UNIFORM_LOCATION)
        {
            std::cout << "\nLighting-ERROR: problem here init-point light\n" << std::endl;
            return false;
        }
    }

    std::cout << "\n" << std::endl;
    for (unsigned int i = 0; i < ARRAY_SIZE_IN_ELEMENTS(m_spotLightsLocation); i++)
    {
        char name[128];
        memset(name, 0, sizeof(name));

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Base.Color", i);
        m_spotLightsLocation[i].Color = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Base.AmbientIntensity", i);
        m_spotLightsLocation[i].AmbientIntensity = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Position", i);
        m_spotLightsLocation[i].Position = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Direction", i);
        m_spotLightsLocation[i].Direction = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Cutoff", i);
        m_spotLightsLocation[i].Cutoff = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Base.DiffuseIntensity", i);
        m_spotLightsLocation[i].DiffuseIntensity = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Atten.Constant", i);
        m_spotLightsLocation[i].Atten.Constant = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Atten.Linear", i);
        m_spotLightsLocation[i].Atten.Linear = GetUniformLocation(name);

        SNPRINTF(name, sizeof(name), "gSpotLights[%d].Base.Atten.Exp", i);
        m_spotLightsLocation[i].Atten.Exp = GetUniformLocation(name);

        if (m_spotLightsLocation[i].Color == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].AmbientIntensity == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Position == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Direction == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Cutoff == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].DiffuseIntensity == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Atten.Constant == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Atten.Linear == INVALID_UNIFORM_LOCATION ||
            m_spotLightsLocation[i].Atten.Exp == INVALID_UNIFORM_LOCATION)
        {
            return false;
        }
    }
    std::cout << "\n" << std::endl;
}


void Lighting::SetWVP(const Mat4f &WVP)
{
    glUniformMatrix4fv(m_WVPLocation, 1, GL_TRUE, (const GLfloat*) WVP.m);
}


void Lighting::SetWorldMatrix(const Mat4f &WorldInverse)
{
    glUniformMatrix4fv(m_WorldMatrixLocation, 1, GL_TRUE, (const GLfloat*) WorldInverse.m);
}


void Lighting::SetColorTextureUnit(unsigned int TextureUnit)
{
    glUniform1i(m_colorTextureLocation, TextureUnit);
}


void Lighting::setDirectionalLight(const DirectionalLight &Light)
{
    glUniform3f(m_dirLightLocation.Color, Light.Color.x, Light.Color.y, Light.Color.z);
    glUniform1f(m_dirLightLocation.AmbientIntensity, Light.AmbientIntensity);
    glm::vec3 Direction = Light.Direction;
    glUniform3f(m_dirLightLocation.Direction, Direction.x, Direction.y, Direction.z);
    glUniform1f(m_dirLightLocation.DiffuseIntensity, Light.DiffuseIntensity);
}


void Lighting::setEyeWorldPos(const glm::vec3 &EyeWorldPos)
{
    glUniform3f(m_eyeWorldPosLocation, EyeWorldPos.x, EyeWorldPos.y, EyeWorldPos.z);
}


void Lighting::setMatSpecularIntensity(float Intensity)
{
    glUniform1f(m_matSpecularIntensityLocation, Intensity);
}


void Lighting::setMatSpecularPower(float Power)
{
    glUniform1f(m_matSpecularPowerLocation, Power);
}


void Lighting::setPointLights(unsigned int NumLights, const PointLight *pLights)
{
    glUniform1i(m_numPointLightsLocation, NumLights);

    for (unsigned int i = 0; i < NumLights; i++)
    {
        glUniform3f(m_pointLightsLocation[i].Color, pLights[i].Color.x, pLights[i].Color.y, pLights[i].Color.z);
        glUniform1f(m_pointLightsLocation[i].AmbientIntensity, pLights[i].AmbientIntensity);
        glUniform1f(m_pointLightsLocation[i].DiffuseIntensity, pLights[i].DiffuseIntensity);
        glUniform3f(m_pointLightsLocation[i].Position, pLights[i].Position.x, pLights[i].Position.y, pLights[i].Position.z);
        glUniform1f(m_pointLightsLocation[i].Atten.Constant, pLights[i].Attenuation.Constant);
        glUniform1f(m_pointLightsLocation[i].Atten.Linear, pLights[i].Attenuation.Linear);
        glUniform1f(m_pointLightsLocation[i].Atten.Exp, pLights[i].Attenuation.Exp);
    }
}

void Lighting::setSpotLights(unsigned int NumLights, const SpotLight *pLights)
{
    glUniform1i(m_numSpotLightsLocation, NumLights);

    for (unsigned int i = 0; i < NumLights; i++)
    {
        glUniform3f(m_spotLightsLocation[i].Color, pLights[i].Color.x, pLights[i].Color.y, pLights[i].Color.z);
        glUniform1f(m_spotLightsLocation[i].AmbientIntensity, pLights[i].AmbientIntensity);
        glUniform1f(m_spotLightsLocation[i].DiffuseIntensity, pLights[i].DiffuseIntensity);
        glUniform3f(m_spotLightsLocation[i].Position, pLights[i].Position.x, pLights[i].Position.y, pLights[i].Position.z);
        glm::vec3 Direction = pLights[i].Direction;
        glm::normalize(Direction);
        glUniform3f(m_spotLightsLocation[i].Direction, pLights[i].Direction.x, pLights[i].Direction.y, pLights[i].Direction.z);
        glUniform1f(m_spotLightsLocation[i].Cutoff, cosf(toRadian(pLights[i].Cutoff)));
        glUniform1f(m_spotLightsLocation[i].Atten.Constant, pLights[i].Attenuation.Constant);
        glUniform1f(m_spotLightsLocation[i].Atten.Linear, pLights[i].Attenuation.Linear);
        glUniform1f(m_spotLightsLocation[i].Atten.Exp, pLights[i].Attenuation.Exp);
    }
}