#version 300 es
precision mediump float;
const int MAX_LIGHTS = 128;
const int MAX_TEX_UNITS = 12;

/* Material */
struct Material {
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
    float shininess;
};
uniform Material material;

/* Lights */
struct Light {
    vec3 position;
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
    float constantPower;
    float linearPower;
    float quadraticPower;
};
uniform int LIGHTS_SIZE;
uniform Light lights[MAX_LIGHTS];

/* Textures */
/**
 * TexUnit 0 (TEXTURE0) - Diffuse map
 * TexUnit 1 (TEXTURE1) - Specular map
 * ---
 * TexUnit 10 (TEXTURE10) - Environment Map
 */
uniform sampler2D texUnit[MAX_TEX_UNITS];
uniform int TEX_UNITS_SIZE; //Actually bound tex units

/* Cube map Texture - Environment mapping */
uniform int genEnvMap; //Boolean
uniform samplerCube eMap_texUnit;
uniform float reflectance;

uniform vec3 camPos;

in vec3 norm;
in vec3 fragPos;
in vec2 uv;

/* Fog attributes */
in vec3 fogPosition;
uniform int useFog; // Boolean
uniform vec4 background_color;
uniform float render_distance;

/* OUTPUT */
out vec4 FragColor;

vec4 computeLight(Light light){
    float fragDistance = length(light.position - fragPos);
    float attenuation = 1.0f / (light.constantPower + light.linearPower * fragDistance + light.quadraticPower * pow(fragDistance, 2.0f));

    /* Ambient color base */
    vec4 Ambient;
    if(TEX_UNITS_SIZE > 0){
        vec4 sampledColor = texture(texUnit[0], uv.xy);
        vec4 Ambient = sampledColor * vec4(light.ambient, 1.0f);
    }else{
        vec4 Ambient = vec4(material.ambient * light.ambient, 1.0f);
    }

    vec3 Ldir = normalize(light.position - fragPos);
    float diffuseAngle = max(dot(normalize(norm), Ldir), 0.0f);

    /* Diffuse color adittion */
    vec4 Diffuse = vec4(0.0, 0.0, 0.0, 1.0);
    if(TEX_UNITS_SIZE > 0){
        vec4 sampledColor = texture(texUnit[0], uv.xy);
        Diffuse = vec4(light.diffuse, 1.0f) * diffuseAngle * sampledColor;
    }else{
        Diffuse = vec4(light.diffuse, 1.0f) * diffuseAngle * vec4(material.diffuse, 1.0f);
    }

    vec3 reflectDir = reflect(-Ldir, norm);
    vec3 viewDir = normalize(camPos - fragPos);
    float specularAngle = pow(max(dot(viewDir, reflectDir), 0.0f), material.shininess + 30.0f);

    /* Specular color addition */
    vec4 Specular;
    if(TEX_UNITS_SIZE > 1){
        vec4 sampledColor = texture(texUnit[1], uv.xy);
        Specular = vec4(light.specular, 1.0f) * specularAngle * sampledColor;
    }else{
        Specular = vec4(light.specular, 1.0f) * specularAngle * vec4(material.specular, 1.0f);    
    }
    vec4 colorIncrement = Ambient + Diffuse + Specular;
    return colorIncrement;
}

/* temporary, uniform needed*/
float fogNear = 10.1f;
float fogFar = 20.9f;
//vec4 fogColor = background_color;
float fogDensity = 0.05f;
bool useExp = false;

/*
* Fog defined by Near & Far
* More approaches to calculate the result fogFactor
* @return {Float} fogFactor - value between 0.0f & 1.0f
*/
float linearDepth(){
    fogFar = render_distance; // Uniform value fro RenderSettings

    /* [OLD - bad result] 1. We need to transform zIndex from range [0.0, 1.0] to range [-1.0, 1.0],
     * which stands for Normalized Device Coordinates (NDC space after Projection)
    */
    float zIndex = gl_FragCoord.x;
    float z_NDC = zIndex * 2.0f - 1.0f;

    /* Approach I
     * - Fog factor defined by equation:
     *      f = (end - z) / (end - start)
     * - Resutls in really dense fog beacuse depth buffer is not linear
     * - Used with blending function: 
     *      color = f * obj_Color + (1.0 - f) * fog_Color
     */
     /* We need to simulate the fragment distance in eye space by multiplying the fragment NDC Z coordinate
      * by range [near, far] --> z = z_NDC * (far - near)
      * ~~ "inverse Projection of Z coordinate to Camera (Eye) space"
      * It's because of the 'start' (near) and 'end' (far) are defined in Camera space too
     */
     //float z = z_NDC * (far - near);

    /* Instead of using depth buffer to calculate the Fragment distance
     *  we use distance between Camera and Vertex (lenght())
     */
     float z = length(camPos - fragPos);

    /* Then we need to translate the value from range [near, far] into range [0.0f, 1.0f] 
     * This can be done by dividng the value (far - z) by size of the range [far, near] = (far - near)
    */
     float fogFactor = (fogFar - z) / (fogFar - fogNear); 

     /* [OLD] Dividing the result by range [near, far] clamps the value between 0.0f & 1.0f
      * That means that we can ignore the [near, far] range (it's redundant)
      * => (fogFactor = 1.0f - z_NDC) will give us the same result 
      * That's because of the 1.0f stands for 'far' and 0.0f stands for 'near'
    */

    /* Approach II
     * https://learnopengl.com/Advanced-OpenGL/Depth-testing
    */
    float fogFactor2 = ((2.0 * fogNear * fogFar) / (fogFar + fogNear - z));


    return clamp(fogFactor, 0.0f, 1.0f);
}

float exponencialDepth(){
    /*
    * Fog defined by fog density
    * Doesn't work with Depth buffer
    */
    /* Approach I 
     * Z is defined by distance between Camera and Fragment
    */
    float f = exp(-fogDensity * length(camPos - fragPos));
    return f;

    /* Approach II */
    #define LOG2 1.442695
    float inRange = length(camPos - fragPos);
    float fogAmount = 1. - exp2(-fogDensity * fogDensity * inRange * inRange * LOG2);
    fogAmount = clamp(fogAmount, 0.0f, 1.0f);
    //return fogAmount;
}

void main(){
    vec4 fogColor = background_color;
    vec4 colorOut = vec4(0.0f, 0.0f, 0.0f, 1.0f);

    for(int i = 0; i < LIGHTS_SIZE; i++){
        colorOut += computeLight(lights[i]);
    }
    if(length(colorOut.xyz) == 0.0f){colorOut = vec4(material.ambient, 1.0f);}
     

    /*  --== Mix the final color ==-- 
     *
     * I) ENVIRONMENT MAPPING
     *  - adds color contribution of reflected environment (skybox)
     *  - can be adjusted by reflectance
    */
    if(genEnvMap == 1){
        /* Calculate distance between fragment and camera */
        vec3 camFragDir = normalize(fragPos - camPos); //(camPos - fragPos)
        /* Calculate the reflected direction */
        vec3 reflectDir = reflect(vec3(camFragDir.x, -camFragDir.y, camFragDir.z), norm); // (camFragDir, norm);
        /* Get texel from cube map */
        vec4 envMapColor = texture(eMap_texUnit, reflectDir);
        /* Combine texel color with already computed color */
        colorOut = mix(envMapColor, colorOut, 1.0 - reflectance);
    }

    /* II) FOG 
     *
     * This needs to be done after all color operations (Lights etc.)
     * Otherwise the lights could affect objects in the fog
    */

    /* The are many ways how to mix the final color
     * It depends on which function We have used to get the fog color contribution
     * Only one of the methods can be used at a time
     */
    if(useFog == 1){
        if(!useExp){
        /* I) Linear FOG */

            /* Calculates linear depth of the fragment in the View frustum 
             *    which represents the linear Fog Factor 
             * In respect to: FragColor = f * ObjectColor + (1 - f) * FogColor 
             */
            float depth = linearDepth(); // Values between [near, far]

            colorOut = mix(fogColor, colorOut, depth); // For Linear Fog I)
            //colorOut = mix(colorOut, fogColor, depth); // For Linear Fog II)
            //colorOut = depth * colorOut + (1.0 - depth) * fogColor; // For Linear Fog I)
            //colorOut = (1.0 - depth) * colorOut + depth * fogColor; // For Linear Fog II)
        }else{
        /* II) Exponencial FOG */

            /* Calculates exponencial Fog Factor */
            float depth = exponencialDepth();

            colorOut = mix(fogColor, colorOut, depth); // For Exponencial Fog I)
            //colorOut = depth2 * colorOut + (1.0 - depth2) * fogColor; // For Exponencial Fog I)
            //colorOut = mix(colorOut, fogColor, depth2); // For Exponencial Fog II)
            //colorOut = (1.0 - depth2) * colorOut + depth2 * fogColor; // For Exponencial Fog II)
        }
    }
    FragColor = colorOut;
}