#version 330 core

struct Attenuation
{
    int constant;
    int linear;
    int exponential;
};

struct BaseLight
{
	vec4 colour;
    float ambientIntensity;
    float diffuseIntensity;
};

struct DirectionalLight
{
    BaseLight base;
    vec3 direction;
};

struct PointLight
{
	BaseLight base;
    vec3 position;
	Attenuation attenuation;
};

vec3 CalcLightInternal(BaseLight _light, vec3 _lightDirection, vec3 _normal);
vec3 CalcDirectionalLight(vec3 _normal);
vec3 CalcPointLight(int _index, vec3 _normal);

const int MAX_POINT_LIGHTS = 5;

in vec2 uv0;
in vec3 normal0;
in vec3 worldPos0;

out vec3 finalColor;

uniform DirectionalLight directionalLight;
uniform PointLight pointLights[MAX_POINT_LIGHTS];

uniform int numPointLights;

uniform int lightingEnabled;

uniform vec3 cameraEyeWorldPosition;

uniform float specularIntensity;
uniform float specularPower;

uniform sampler2D diffusetexture;

void main()
{
	vec3 MaterialDiffuseColor = texture2D(diffusetexture, uv0).rgb;

	vec3 Normal = normalize(normal0);

	if(lightingEnabled == 1)
	{
		vec3 TotalLight = CalcDirectionalLight(Normal);

		for (int i = 0; i < numPointLights; i++)
		{
			TotalLight += CalcPointLight(i, Normal);
		}

		finalColor = MaterialDiffuseColor * TotalLight;
	}
	else
	{
		finalColor = MaterialDiffuseColor;
	}
}

vec3 CalcLightInternal(BaseLight _light, vec3 _lightDirection, vec3 _normal)
{
	vec3 AmbientColor = _light.colour.rgb * _light.ambientIntensity;

	float DiffuseFactor = dot(normalize(_normal), _lightDirection);

	vec3 DiffuseColor = vec3(0, 0, 0);
	vec3 SpecularColor  = vec3(0, 0, 0);

	if (DiffuseFactor > 0)
	{
        DiffuseColor = _light.colour.rgb * _light.diffuseIntensity * DiffuseFactor;

		vec3 VertexToEye = normalize(cameraEyeWorldPosition - worldPos0);
		vec3 LightReflect = normalize(reflect(_lightDirection, _normal));
		float SpecularFactor = dot(VertexToEye, LightReflect);
		SpecularFactor = pow(SpecularFactor, specularPower);

		if (SpecularFactor > 0)
		{
			SpecularColor = _light.colour.rgb * specularIntensity * SpecularFactor;
		}
    }

	return (AmbientColor + DiffuseColor + SpecularColor);
}

vec3 CalcDirectionalLight(vec3 _normal)
{
    return CalcLightInternal(directionalLight.base, directionalLight.direction, _normal);
}

vec3 CalcPointLight(int _index, vec3 _normal)
{
    vec3 LightDirection = worldPos0 - pointLights[_index].position;
    float Distance = length(LightDirection);
    LightDirection = normalize(LightDirection);

    vec3 Color = CalcLightInternal(pointLights[_index].base, LightDirection, _normal);
    float Attenuation =  pointLights[_index].attenuation.constant +
                         pointLights[_index].attenuation.linear * Distance +
                         pointLights[_index].attenuation.exponential * Distance * Distance;

    return Color / Attenuation;
}