#version 430 core

out vec4 FragColor;

in VS_OUT {
    vec3 FragPos;
    vec2 TexCoords;
    vec3 TangentLightPos;
    vec3 TangentViewPos;
    vec3 TangentFragPos;
} fs_in;

layout (binding = 0) uniform sampler2D albedoMap;
layout (binding = 1) uniform sampler2D normalMap;
layout (binding = 2) uniform sampler2D depthMap;

uniform float bump_depth;
uniform float number_of_steps;
uniform float number_of_refinement_steps;

vec2 get_parallax_offset_uv(vec2 uv, vec3 view_direction) {
    float layer_depth = 1.0 / number_of_steps;
    float refinement_layer_depth = layer_depth / number_of_refinement_steps;

    float current_layer_depth = 0.0;

    // the amount to shift the texture coordinates per layer (from vector total_uv_shift)
    vec2 total_uv_shift = view_direction.xy / view_direction.z * bump_depth; 
    vec2 uv_shift_per_layer = total_uv_shift / number_of_steps;
    vec2 uv_refine_shift_per_layer = total_uv_shift / (number_of_steps * number_of_refinement_steps);
  
    // Initial values
    vec2  current_uv     = uv;
    float current_bump_value = 1.0 - texture(depthMap, current_uv).r;
    
    // Loop until our depth is greater than the value in the bump map, meaning our ray collided
    while(current_layer_depth < current_bump_value) {
        current_uv -= uv_shift_per_layer;
        current_bump_value = 1.0 - texture(depthMap, current_uv).r;
        current_layer_depth += layer_depth;  
    }
    
    // Reverse the last operations so we're at the point before the collision
    current_uv += uv_shift_per_layer;
    current_bump_value = 1.0 - texture(depthMap, current_uv).r;

    // Loop again for the refinement steps
    while(current_layer_depth < current_bump_value) {
        current_uv -= uv_refine_shift_per_layer;
        current_bump_value = 1.0 - texture(depthMap, current_uv).r;
        current_layer_depth += refinement_layer_depth;  
    }

    // Referse the UV operation again and return the result
    current_uv += uv_refine_shift_per_layer;

    return current_uv;
}

void main() {           
    // Offset texture coordinates with Parallax Mapping
    vec3 view_direction = normalize(fs_in.TangentViewPos - fs_in.TangentFragPos);
    vec2 uv = fs_in.TexCoords;
    
    uv = get_parallax_offset_uv(uv,  view_direction);

    // Discard if the parallax offset moved us outside of the texture
    // TODO: Do this only if the mode is not REPEAT
    //if (uv.x > 1.0 || uv.y > 1.0 || uv.x < 0.0 || uv.y < 0.0)
    //    discard;

    // Get normal from normal map and scale it to -1..1
    vec3 normal = texture(normalMap, uv).rgb;
    normal = normalize(normal * 2.0 - 1.0);   
   
    // Get albedo color
    vec3 color = texture(albedoMap, uv).rgb;

    // Ambient lighting
    vec3 ambient = 0.1 * color;

    // Apply albedo with intensity based on the dot product between the light direction and the normal here
    vec3 light_direction = normalize(fs_in.TangentLightPos - fs_in.TangentFragPos);
    float light_normal_dot = max(dot(light_direction, normal), 0.0);
    vec3 albedo = light_normal_dot * color;

    // Specular lighting
    vec3 halfway_reflected_light_direction = normalize(light_direction + view_direction);  
    float spec = pow(max(dot(normal, halfway_reflected_light_direction), 0.0), 32.0);

    vec3 specular = vec3(0.2) * spec;

    // Apply
    FragColor = vec4(ambient + albedo + specular, 1.0);
}