#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <helianthus.h>

#define COUNT 64

#define TEXCOUNT 512

#define FRAMECOUNT 512

#define W 512

#define H 512

#define STEP 0.05

#define EDGE 0

//#define SAVE "data/output/mosaic/frame%03d.png"

typedef struct {

  int w, h;

  unsigned char *pixels;

} Tex;

typedef struct {

  Tex *tex0;

  Tex *tex1;

  double alpha;

} Frame;

typedef struct {

  int x, y;

  int l, t, w, h;

  unsigned int color;

  Frame frames[FRAMECOUNT];

} Point;

typedef struct {

  double k[3];

  Point *point;

  double weight;

  double alpha;

  double edge;

  Point *point2;

  double weight2;

} Pixel;

Point points[COUNT];

Pixel pixels[H][W];

Tex textures[TEXCOUNT];

int texturesCnt;

unsigned char image[H][W][4];

Animation anim;

int wrapX(int x)

  { return (x%W + W)%W; }

int wrapY(int y)

  { return (y%H + H)%H; }

Pixel* getPixel(int x, int y)

  { return &pixels[wrapY(y)][wrapX(x)]; }

int updatePixel(Pixel *p, int x, int y, int mode) {

  Pixel *pp = getPixel(x, y);

  double w = p->weight + p->k[mode] + pp->k[mode];

  if (!pp->point || pp->weight > w) {

    pp->point2  = pp->point  = p->point;

    pp->weight2 = pp->weight = w;

    return 1;

  }

  return 0;

}

void updatePixel2(Pixel *p, int x, int y, int mode) {

  Pixel *pp = getPixel(x, y);

  if (p->point == pp->point) return;

  double w = pp->weight + pp->k[mode] + p->k[mode];

  if (p->point2 == p->point || p->weight2 > w) {

    p->point2 = pp->point;

    p->weight2 = w;

  }

}

void generateFrames(Frame *frames) {

  int start;

  int switches = 1 + rand()%10;

  for(int i = 0; i < switches; ++i) {

    start = rand()%FRAMECOUNT;

    frames[start].tex1 = &textures[rand()%texturesCnt];

  }

  double alpha = 1;

  Tex *t0 = frames[start].tex1, *t1 = t0;

  for(int i = start; i < FRAMECOUNT*10; ++i) {

    Frame *f = &frames[i%FRAMECOUNT];

    if (alpha < 1) {

      alpha += STEP;

      if (alpha >= 1) {

        alpha = 1;

        t0 = t1;

      }

    } else

    if (f->tex1 && f->tex1 != t1) {

      t1 = f->tex1;

      alpha = 0;

    }

    f->tex0 = t0;

    f->tex1 = t1;

    f->alpha = alpha;

  }

  //if (frames == points->frames)

  //  for(int i = 0; i < FRAMECOUNT; ++i)

  //    printf("%3d %3d %3d %f\n", i, frames[i].tex0 - textures, frames[i].tex1 - textures, frames[i].alpha);

}

Animation generateAnim(int frameId, const char *filename) {

  // update image

  Pixel *p = pixels[0];

  unsigned char black[] = { 0, 0, 0, 255 };

  //unsigned char white[] = { 255, 255, 255, 255 };

  unsigned char *c = image[0][0];

  for(int y = 0; y < H; ++y)

  for(int x = 0; x < W; ++x, ++p) {

    Frame *f0 = &p->point->frames[frameId];

    Frame *f1 = &p->point2->frames[frameId];

    Tex *t0 = f0->tex0;

    Tex *t1 = f0->tex1;

    Tex *t2 = f1->tex0;

    Tex *t3 = f1->tex1;

    double a00 = 1 - f0->alpha;

    double a01 = f0->alpha;

    double a10 = 1 - f1->alpha;

    double a11 = f1->alpha;

    if (t0 == t1) { a00 = 0; a01 = 1; }

    if (t2 == t3) { a10 = 0; a11 = 1; }

    double a0 = p->alpha*a00;

    double a1 = p->alpha*a01;

    double a2 = (1 - p->alpha)*a10;

    double a3 = (1 - p->alpha)*a11;

    double k = 0;

    if (t0 == t2) k += a00 < a10 ? a00 : a10;

    if (t0 == t3) k += a00 < a11 ? a00 : a11;

    if (t1 == t2) k += a01 < a10 ? a01 : a10;

    if (t1 == t3) k += a01 < a11 ? a01 : a11;

    double a4 = p->edge*(1 - k)*EDGE;

    unsigned char *c0 = t0->pixels + (y%t0->h*t0->w + x%t0->w)*4;

    unsigned char *c1 = t1->pixels + (y%t1->h*t1->w + x%t1->w)*4;

    unsigned char *c2 = t2->pixels + (y%t2->h*t2->w + x%t2->w)*4;

    unsigned char *c3 = t3->pixels + (y%t3->h*t3->w + x%t3->w)*4;

    unsigned char *c4 = black;

    for(int i = 0; i < 4; ++i)

      *c++ = (*c0++*a0 + *c1++*a1 + *c2++*a2 + *c3++*a3)*(1 - a4) + *c4++*a4;

  }

  if (filename) imageSave(filename, W, H, image);

  return createAnimationFromImageEx(W, H, image, TRUE, TRUE, FALSE, FALSE);

}

void generate() {

  // clear

  memset(points, 0, sizeof(points));

  memset(pixels, 0, sizeof(pixels));

  memset(image, 0, sizeof(image));

  // generate k

  Pixel *p = pixels[0];

  for(int y = 0; y < H; ++y)

  for(int x = 0; x < W; ++x, ++p) {

    p->k[0] = exp(randomFloat()-0.5)*4;

    p->k[1] = exp(randomFloat()-0.5);

    p->k[2] = (p->k[0] + p->k[1])*0.75;

  }

  // generate points

  for(int i = 0; i < COUNT; ++i) {

    Point *pt = &points[i];

    pt->x = rand()%W;

    pt->y = rand()%H;

    pt->color = colorByHSV(randomFloat()*360, 1, 1);

    generateFrames(pt->frames);

    Pixel *p = getPixel(pt->x, pt->y);

    p->point = p->point2 = pt;

    p->weight = p->weight2 = randomFloat();

  }

  // expand points

  int found = 1, i = 0;

  while(found) {

    found = 0;

    Pixel *p = pixels[0];

    for(int y = 0; y < H; ++y)

    for(int x = 0; x < W; ++x, ++p) {

      if (!p->point) continue;

      if (updatePixel(p, x-1, y, 0)) found = 1;

      if (updatePixel(p, x+1, y, 0)) found = 1;

      if (updatePixel(p, x, y-1, 1)) found = 1;

      if (updatePixel(p, x, y+1, 1)) found = 1;

      if (updatePixel(p, x-1, y-1, 2)) found = 1;

      if (updatePixel(p, x+1, y-1, 2)) found = 1;

      if (updatePixel(p, x-1, y+1, 2)) found = 1;

      if (updatePixel(p, x+1, y+1, 2)) found = 1;

    }

    printf("%d\n", i++); fflush(stdout);

  }

  // expand points2

  p = pixels[0];

  for(int y = 0; y < H; ++y)

  for(int x = 0; x < W; ++x, ++p) {

    updatePixel2(p, x-1, y, 0);

    updatePixel2(p, x+1, y, 0);

    updatePixel2(p, x, y-1, 1);

    updatePixel2(p, x, y+1, 1);

    updatePixel2(p, x-1, y-1, 2);

    updatePixel2(p, x+1, y-1, 2);

    updatePixel2(p, x-1, y+1, 2);

    updatePixel2(p, x+1, y+1, 2);

    double a = (p->weight2 - p->weight)*0.5 + 0.5;

    if (a < 0) a = 0;

    if (a > 1) a = 1;

    double edge = 1 - (p->weight2 - p->weight)/p->k[2]/8;

    if (edge > 1) edge = 1;

    if (edge < 0) edge = 0;

    if (p->point == p->point2) edge = 0;

    p->alpha = a;

    p->edge = edge;

  }

  // generate animation

  animationClear(anim);

  for(int i = 0; i < FRAMECOUNT; ++i) {

    #ifdef SAVE

    char filename[1024] = {};

    sprintf(filename, SAVE, i);

    printf("generate: %s\n", filename); fflush(stdout);

    animationInsert(anim, i, generateAnim(i, filename));

    #else

    printf("generate frame %d\n", i); fflush(stdout);

    animationInsert(anim, i, generateAnim(i, NULL));

    #endif

  }

  animationSetFps(anim, 32);

  animationSetLoop(anim, TRUE);

}

void loadTexture(const char *filename) {

  printf("load texture: %s\n", filename);

  Tex *t = &textures[texturesCnt];

  if (imageLoad(filename, &t->w, &t->h, &t->pixels))

    ++texturesCnt;

}

void loadTextures(const char *dirname) {

  Directory dir = openDirectoryEx(dirname, "", ".png", FALSE, TRUE, FALSE);

  if (dir) {

    for(int i = 0; i < directoryGetCount(dir); ++i)

      loadTexture(directoryGetFull(dir, i));

    closeDirectory(dir);

  }

}

void init() {

  anim = createAnimationEmpty();

  loadTextures("data/textures");

  generate();

}

void draw() {

  double w = windowGetWidth();

  double h = windowGetHeight();

  double t = windowGetSeconds();

  saveState();

  //scale(w/W, h/H);

  noStroke();

  animationSetFrame(anim, ((int)(t*32))%FRAMECOUNT);

  fillTexture(anim, 0, 0, W, H, TRUE);

  rect(0, 0, w, h);

  //stroke(COLOR_BLACK);

  //for(int i = 0; i < COUNT; ++i)

  //  point(points[i].x, points[i].y);

  restoreState();

}

int main() {

  windowSetVariableFrameRate();

  windowSetResizable(TRUE);

  windowSetInit(&init);

  windowSetDraw(&draw);

  windowRun();

}