#version 430
layout(local_size_x = 1, local_size_y = 1) in;

#include <sdf>
#include <utils>
#include <noise>

#define PI 3.14159265358979323

uniform float hours = 0;
uniform float minutes = 0;
uniform float seconds = 0;
uniform float time = 0;
layout(rgba8) uniform readonly image2D noise_texture;
layout(rgba8) uniform readonly image2D text_texture;
layout(rgba8) uniform writeonly image2D output_image;

uniform float antialiasing = 0.28;
uniform bool enable_antialiasing = false;

float sample_noise(in vec2 p) {
  vec4 noise = imageLoad(noise_texture, ivec2((p + 0.5) * imageSize(noise_texture)));
  return noise.x;
}

float digit(in vec2 uv, in int dig, in float size) {
  vec2 p = uv * 5000 / size;
  float digitSize = imageSize(text_texture).x / 10.;
  float digitOffset = digitSize * dig;
  p.x = clamp(p.x + digitOffset, digitOffset, digitOffset + digitSize);
  vec4 s = imageLoad(text_texture, ivec2(p));
  return s.w;
}

vec3 image(in vec2 uv) {
  const vec3 eye_color = srgb(1, 0.99, 0.91);
  const vec3 iris_color = srgb(0.15, 0.18, 0.29);
  const vec3 irispat1_color = srgb(0.02);
  const vec3 irispat2_color = srgb(0.21, 0.27, 0.24);
  const vec3 pupil_color = srgb(0.08);
  const vec3 background_color = srgb(0.15, 0.18, 0.29);
  const vec3 bloodvessel_color = srgb(0.81, 0.40, 0.21);
  const vec3 caruncle_color = srgb(0.81, 0.40, 0.21);
  const vec3 clockdigit_color = mix(bloodvessel_color, vec3(0), 0.3);
  const vec3 eyeoutline_color = mix(bloodvessel_color, vec3(0), 0.8);
  const vec3 pat1_color = srgb(0.81, 0.40, 0.21);
  const vec3 pat2_color = srgb(0.95, 0.76, 0.36);

  vec3 color = caruncle_color;
  float theta = atan(uv.y, uv.x);

  {
    float eye = sdf_circle(uv, 0.41 * (1 - 0.08 * fbm(100 * uv)));
    vec3 eyeball_color = eye_color;
    float veins = sin((uv.y + 1) * 260 * sin((uv.x + 1) * 0.1) * fbm(uv * 20)) + 0.97;
    eyeball_color = mix(eyeball_color, bloodvessel_color,
        mix(0, step(veins, 0), clamp(ease_in_out_quart(fbm(vec3(uv * 10, 28), 8)) - 0.3, 0, 1)));
    color = mix(color, eyeball_color, step(eye, 0));
    float caruncle_shine = sdf_circle(uv - vec2(0.44, 0), 0.02);
    caruncle_shine = min(caruncle_shine, sdf_circle(uv + vec2(0.44, 0), 0.02));
    color = mix(color, mix(color, vec3(1), 0.3), 1 - smoothstep(-0.01, 0.01, caruncle_shine));
    color = mix(color, mix(color, vec3(0), 0.5), smoothstep(0, 0.12, eye + 0.20));
  }

  {
    // minutes
    float angle = PI / 2 - minutes * PI / 30;
    vec2 offset = 0.148 * vec2(cos(angle), sin(angle));
    float iris_bounds = sdf_circle((uv - offset) * vec2(0.5, 1), 0.012);
    color = mix(color, bloodvessel_color, step(iris_bounds + 0.01 * fbm(uv * 200), 0));
  }

  {
    float iris = sdf_circle(uv, 0.144);
    color = mix(color, iris_color, step(iris, 0));
    float floral = uv.x * 8 / cos(theta) - sin(15 * theta) * cos(12 * theta);
    float irispatangle = 50 * theta + 10.0 * fbm(uv * 100);
    color = mix(color, irispat1_color, 0.8 * step(max(iris, sin(irispatangle)), 0));
    color = mix(color, irispat1_color, clamp(step(floral, 0.12) * floral * 8, 0, 1));
    color = mix(color, irispat2_color, step(floral, 0));
    color = mix(color, irispat1_color, clamp(step(iris, 0) * (iris + 0.1) * 8, 0, 1));
  }

  {
    // hours
    float angle = PI / 2 - hours * PI / 6 - minutes * PI / (12 * 60);
    vec2 offset = 0.10 * vec2(cos(angle), sin(angle));
    float iris_spec = sdf_circle((uv - offset) * vec2(0.8, 1.0), 0.010);
    color = mix(color, mix(color, vec3(1), 0.8), step(iris_spec, 0));
  }

  {
    float pupil = sdf_circle(uv, 0.04);
    vec3 shaded_pupil_color = pupil_color;
    shaded_pupil_color = mix(shaded_pupil_color, background_color, clamp(step(pupil, 0) * (pupil + 0.02) * 6, 0, 1));
    color = mix(color, shaded_pupil_color, step(pupil, 0));

    {
      float eyeball = sdf_circle(uv, 0.03);
      color = mix(color, vec3(1), step(eyeball, 0.));

      float t = time / 2;
      vec2 offset = ease_in_out_quart(vec2(fbm(vec2(t)), fbm(vec2(t / 2)))) - 0.40;
      vec2 eyeirisp = uv - offset * 0.004 * 4;
      float pupil = sdf_circle(eyeirisp, 0.009);
      color = mix(color, mix(iris_color, pupil_color, smoothstep(pupil, 0.0068, 0)), step(pupil, 0));

      vec2 eyep = uv;
      float eye_open_factor = 0.008;
      float blinkduration = 0.6;
      float blink_every = 1;
      float blinkt = mod(time, blink_every) * 2 / blinkduration;
      int should_blink = int(mod(time, blink_every) < blinkduration);
      float blink = ease_in_out_quart(mod(blinkt, 1));
      blink = mix(1 - blink, blink, clamp(int(blinkt) % 2, 0., 1.));
      float a = mix(0, eye_open_factor, mix(1, blink, should_blink));
      float eyelid_size = 60;
      float eyelid = a * cos(eyelid_size * eyep.x / 2 * PI) - abs(eyep.y) + a;
      eyelid = max(eyelid, sdf_circle(eyep, 0.03));
      color = mix(color, shaded_pupil_color, step(eyelid, 0.005));
    }
  }

  {
    // TODO: Switch to domain repetition
    for (int i = 0; i < 12; i++) {
      float angle = PI / 6.;
      float r = 0.17;
      vec2 digitpos = uv + vec2(0.011, 0.036) - r * vec2(cos(-i * angle + PI / 3), sin(-i * angle + PI / 3));
      digitpos *= (1 + 0.8 * fbm(60 * uv));
      float digit_size = 1.6;
      float s = 0;
      if (i + 1 >= 10) {
        s = digit(digitpos + vec2(0.01, 0), 1, digit_size);
        digitpos.x -= 0.01;
      }
      s = max(s, digit(digitpos, (i + 1) % 10, digit_size));
      color = mix(color, clockdigit_color, s);
    }
  }

  float eye_open_factor = 0.092;
  float eyelid_size = 4;

  {
    vec2 eyep = uv;
    float blinkduration = 0.6;
    float blink_every = 8;
    float blinkt = mod(time, blink_every) * 2 / blinkduration;
    int should_blink = int(mod(time, blink_every) < blinkduration);
    float blink = ease_in_out_quart(mod(blinkt, 1));
    blink = mix(1 - blink, blink, clamp(int(blinkt) % 2, 0., 1.));
    float a = mix(0, eye_open_factor, mix(1, blink, should_blink));
    float eyelid = a * cos(eyelid_size * eyep.x / 2 * PI) - abs(eyep.y) + a;
    vec3 eyelid_color = background_color;
    vec3 patterning = mix(pat1_color, pat2_color, pow(sin(eyep.x * 16 + 100 * fbm(vec3(eyep * 10, time / 20), 3)), 2));
    float patnoise = smoothstep(-eyelid, 0, 0.028 * fbm(eyep * 100));
    eyelid_color = mix(eyelid_color, patterning, 1 - clamp(patnoise, 0, 1));
    float shadow = 1 - smoothstep(-0.01, 0.03, eyelid);
    color = mix(eyelid_color, mix(color, eyeoutline_color, shadow), 1 - step(eyelid, 0));
  }

  return color;
}

vec3 antialiased_image(vec2 uv) {
  vec2 resolution = vec2(imageSize(output_image).xy);
  float s = antialiasing / max(resolution.x, resolution.y);
  vec3 sum = vec3(0);
  int count = 0;
  for (int i = -2; i < 2; i++)
    for (int j = -2; j < 2; j++, count++)
      sum += image(uv + vec2(i, j) * s);
  return sum / count;
}

void main() {
  vec2 resolution = vec2(imageSize(output_image).xy);
  float aspect_ratio = resolution.y / resolution.x;
  vec2 uv = (gl_GlobalInvocationID.xy - resolution / 2) * vec2(1.0, aspect_ratio) / resolution;

  vec3 color = enable_antialiasing ? antialiased_image(uv) : image(uv);
  // color = saturation(color, 0.2);

  imageStore(output_image, ivec2(gl_GlobalInvocationID.xy), vec4(color, 1));
}