// This file is part of the 64k demo project.
// It implements basic procedural texture generators.

#include "procedural/generator.h"
#include <cmath>
#include <cstdlib>

namespace procedural {

// Smoothstep
constexpr float smooth(float x) {
  return x * x * (3.f - 2.f * x);
}
constexpr float mix(float a, float b, float t) {
  return (a * (1.0f - t) + b * t);
}

// Perlin noise generator (Fractional Brownian Motion using value noise)
// Params[0]: Seed
// Params[1]: Frequency (Scale)
// Params[2]: Amplitude
// Params[3]: Amplitude decay
// Params[4]: Number of octaves
bool gen_perlin(uint8_t* buffer, int w, int h, const float* params,
                int num_params) {
  float base_freq = (num_params > 1) ? params[1] : 4.0f;
  float base_amp = (num_params > 2) ? params[2] : 1.0f;
  float amp_decay = (num_params > 3) ? params[3] : 0.5f;
  int octaves = (num_params > 4) ? (int)params[4] : 4;
  if (num_params > 0 && params[0] != 0) {
    srand((unsigned int)params[0]);
  }

  // Pre-allocate temporary float buffer for accumulating noise
  float* accum = (float*)calloc((size_t)w * h, sizeof(float));
  if (!accum)
    return false;

  float current_freq = base_freq;
  float current_amp = base_amp;
  float total_amp = 0.0f;

  for (int o = 0; o < octaves; ++o) {
    const int lattice_w = (int)ceil(current_freq) + 1;
    const int lattice_h = (int)ceil(current_freq) + 1;
    float* lattice =
        (float*)malloc((size_t)lattice_w * lattice_h * sizeof(float));
    if (!lattice) {
      free(accum);
      return false;
    }

    for (int i = 0; i < lattice_w * lattice_h; ++i) {
      lattice[i] = (float)rand() / RAND_MAX;
    }

    const float scale_u = current_freq / w;
    const float scale_v = current_freq / h;

    for (int y = 0; y < h; ++y) {
      const float v = scale_v * y;
      const int ly = (int)floor(v);
      const int ly_next = (ly + 1); // No wrap here for better octaves
      float fv = smooth(v - ly);
      for (int x = 0; x < w; ++x) {
        float u = scale_u * x;
        const int lx = (int)floor(u);
        const int lx_next = (lx + 1);
        float fu = smooth(u - lx);

        // Simple tiling for lattice access
        auto get_lat = [&](int ix, int iy) {
          return lattice[(iy % lattice_h) * lattice_w + (ix % lattice_w)];
        };

        float n00 = get_lat(lx, ly);
        float n10 = get_lat(lx_next, ly);
        float n01 = get_lat(lx, ly_next);
        float n11 = get_lat(lx_next, ly_next);

        const float noise = mix(mix(n00, n10, fu), mix(n01, n11, fu), fv);
        accum[y * w + x] += noise * current_amp;
      }
    }

    total_amp += current_amp;
    current_freq *= 2.0f;
    current_amp *= amp_decay;
    free(lattice);
  }

  // Normalize and write to RGBA buffer
  for (int i = 0; i < w * h; ++i) {
    float val = accum[i] / total_amp;
    uint8_t uval = (uint8_t)(fminf(fmaxf(val, 0.0f), 1.0f) * 255.0f);
    buffer[4 * i + 0] = uval;
    buffer[4 * i + 1] = uval;
    buffer[4 * i + 2] = uval;
    buffer[4 * i + 3] = 255;
  }

  free(accum);
  return true;
}

// Simple smooth noise generator (Value Noise-ish)

// Params[0]: Seed

// Params[1]: Frequency (Scale)

bool gen_noise(uint8_t* buffer, int w, int h, const float* params,

               int num_params) {
  if (num_params > 0 && params[0] == -1337.0f) return false;

  float freq = (num_params > 1) ? params[1] : 4.0f;

  if (num_params > 0 && params[0] != 0) {
    srand((unsigned int)params[0]);
  }

  // Create a small lattice of random values

  const int lattice_w = (int)ceil(freq);

  const int lattice_h = (int)ceil(freq);

  float* lattice =
      (float*)malloc((size_t)lattice_w * lattice_h * sizeof(float));

  if (!lattice)
    return false;

  for (int i = 0; i < lattice_w * lattice_h; ++i) {
    lattice[i] = (float)rand() / RAND_MAX;
  }

  const float scale_u = 1.f * (lattice_w - 1) / w;

  const float scale_v = 1.f * (lattice_h - 1) / h;

  for (int y = 0; y < h; ++y) {
    const float v = scale_v * y;

    const int ly = (int)floor(v);

    const int ly_next = (ly + 1) % lattice_h; // Wrap

    const float* const n0 = &lattice[ly * lattice_w];

    const float* const n1 = &lattice[ly_next * lattice_w];

    float fv = smooth(v - ly);

    uint8_t* const dst = &buffer[y * w * 4];

    for (int x = 0; x < w; ++x) {
      float u = scale_u * x;

      const int lx = (int)floor(u);

      const int lx_next = (lx + 1) % lattice_w;

      float fu = smooth(u - lx);

      float n00 = n0[lx];

      float n10 = n0[lx_next];

      float n01 = n1[lx];

      float n11 = n1[lx_next];

      const float noise = mix(mix(n00, n10, fu), mix(n01, n11, fu), fv);

      const uint8_t val = (uint8_t)(noise * 255.0f);

      dst[4 * x + 0] = val; // R

      dst[4 * x + 1] = val; // G

      dst[4 * x + 2] = val; // B

      dst[4 * x + 3] = 255; // A
    }
  }

  free(lattice);

  return true;
}

// Simple grid generator
// Params[0]: Grid Size (pixels)
// Params[1]: Line Thickness (pixels)
bool gen_grid(uint8_t* buffer, int w, int h, const float* params,
              int num_params) {
  int grid_size = (num_params > 0) ? (int)params[0] : 32;
  int thickness = (num_params > 1) ? (int)params[1] : 2;

  if (grid_size < 1)
    grid_size = 32;

  for (int y = 0; y < h; ++y) {
    for (int x = 0; x < w; ++x) {
      bool on_line =
          ((x % grid_size) < thickness) || ((y % grid_size) < thickness);

      int idx = (y * w + x) * 4;
      uint8_t val = on_line ? 255 : 0;

      buffer[idx + 0] = val;
      buffer[idx + 1] = val;
      buffer[idx + 2] = val;
      buffer[idx + 3] = 255;
    }
  }
  return true;
}

bool make_periodic(uint8_t* buffer, int w, int h, const float* params,
                   int num_params) {
  float ratio = (num_params > 0) ? params[0] : 0.1f;
  if (ratio <= 0.0f)
    return true;
  if (ratio > 0.5f)
    ratio = 0.5f;

  const int bx = (int)(w * ratio);
  const int by = (int)(h * ratio);
  const float scale_x = 1. / bx;
  const float scale_y = 1. / by;

  // X pass: blend right edge into left edge
  for (int y = 0; y < h; ++y) {
    for (int x = 0; x < bx; ++x) {
      const float t = smooth(scale_x * x);

      const int idx_dst = (y * w + x) * 4;
      const int idx_src = (y * w + (w - bx + x)) * 4;

      for (int c = 0; c < 3; ++c) {
        const float v_dst = buffer[idx_dst + c];
        const float v_src = buffer[idx_src + c];
        buffer[idx_dst + c] = (uint8_t)mix(v_src, v_dst, t);
      }
    }
  }

  // Y pass
  for (int x = 0; x < w; ++x) {
    for (int y = 0; y < by; ++y) {
      const float t = smooth(scale_y * y);
      const int idx_dst = (y * w + x) * 4;
      const int idx_src = ((h - by + y) * w + x) * 4;

      for (int c = 0; c < 3; ++c) {
        float v_dst = buffer[idx_dst + c];
        float v_src = buffer[idx_src + c];
        buffer[idx_dst + c] = (uint8_t)mix(v_src, v_dst, t);
      }
    }
  }
  return true;
}

} // namespace procedural