#include <math.h>

#include <stdlib.h>

#include <string.h>

#include <helianthus.h>

#define WIDTH     285.0

#define HEIGHT    200.0

#define RES        10.0

#define THIKNESS    0.5

#define ALPHA       0.1

#define CELLSIZE   22.5

#define ITEMSIZE   10.0

#define WALLSIZE   10.0

#define WALLJITTER  1.0

#define WALLBORDER  2.0

#define SRCRES    10.0

#define SCALE      1.0

double itemScale;

double cellScale;

Animation itemTiles[1024];

Animation cellTiles[1024];

int itemTilesCount = 0;

int cellTilesCount = 0;

int rows;

int cols;

Framebuffer framebuffer;

Animation fbAnim;

void shuffle(Animation *anims, int count) {

  for(int i = 0; i < 2*count; ++i) {

    int a = randomNumber(0, count-1);

    int b = randomNumber(0, count-1);

    if (a != b) {

      Animation anim = anims[a];

      anims[a] = anims[b];

      anims[b] = anim;

    }

  }

}

void groundLine(double len, double k) {

  double x = 0;

  double y = 0;

  moveTo(x, y);

  while(x < len) {

    double ny;

    do { ny = (randomFloat()*2 - 1)*k; } while(fabs(y + ny) > k);

    y += ny;

    x += (1 + (randomFloat()*2 - 1)*0.5)*2*k;

    if (x >= len) { x = len; y = 0; }

    lineTo(x, y);

  }

  strokePath();

}

void generate() {

  int fw = framebufferGetWidth(framebuffer);

  int fh = framebufferGetHeight(framebuffer);

  saveState();

  target(framebuffer);

  background(COLOR_TRANSPARENT);

  clear();

  translate(fw/2, fh/2);

  zoom(RES);

  fill(COLOR_WHITE);

  noStroke();

  double step = CELLSIZE + WALLSIZE;

  translate(-(cols-1)*step/2, -(rows-1)*step/2);

  double itemStep = (CELLSIZE - ITEMSIZE)/2;

  double cellSize = CELLSIZE*cellScale;

  double itemSize = ITEMSIZE*itemScale;

  int cellId = cellTilesCount;

  int itemId = itemTilesCount;

  for(int y = 0; y < rows; ++y) {

    for(int x = 0; x < cols; ++x) {

      saveState();

      translate(x*step, y*step);

      if (cellTilesCount > 0 && randomFloat()*100 < 10) {

        if (cellId >= cellTilesCount) {

          shuffle(cellTiles, cellTilesCount);

          cellId = 0;

        }

        rectTextured(cellTiles[cellId++], -cellSize/2, -cellSize/2, cellSize, cellSize);

      } else

      if (itemTilesCount > 0) {

        int cnt = 4;

        if (cnt < itemTilesCount) cnt = rand()%itemTilesCount;

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

          saveState();

          translate(i%2 ? itemStep : -itemStep, i/2 ? itemStep : -itemStep);

          if (itemId >= itemTilesCount) {

            shuffle(itemTiles, itemTilesCount);

            itemId = 0;

          }

          rectTextured(itemTiles[itemId++], -itemSize/2, -itemSize/2, itemSize, itemSize);

          restoreState();

        }

      }

      restoreState();

    }

  }

  noFill();

  stroke(COLOR_BLACK);

  strokeWidth(THIKNESS);

  double k = WALLJITTER;

  double wallStep = CELLSIZE/2 + k + WALLBORDER;

  saveState();

    translate(-wallStep, 0);

    double len = (cols-1)*step + 2*wallStep;

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

      saveState();

      translate(0, i*step - wallStep);

      groundLine(len, k);

      translate(0, 2*wallStep);

      groundLine(len, k);

      restoreState();

    }

  restoreState();

  saveState();

    rotate(90);

    scale(1, -1);

    translate(-wallStep, 0);

    len = (rows-1)*step + 2*wallStep;

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

      saveState();

      translate(0, i*step - wallStep);

      groundLine(len, k);

      translate(0, 2*wallStep);

      groundLine(len, k);

      restoreState();

    }

  restoreState();

  viewportSave("data/output/generated-dungeon2.png");

  restoreState();

}

Animation subImage(int width, int height, unsigned char *pixels, int x, int y, int w, int h) {

  if (x < 0 || y < 0 || x + w > width || y + h > height || !pixels)

    return NULL;

  unsigned char *px = calloc(4, w*h);

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

    memcpy(px + i*w*4, pixels + ((y+i)*width + x)*4, w*4);

  Animation anim = createAnimationFromImage(w, h, px, FALSE);

  free(px);

  return anim;

}

void init() {

  int w = 0;

  int h = 0;

  unsigned char *px = NULL;

  imageLoad("data/dungeon2.png", &w, &h, &px);

  int is = 128;

  int cs = 256;

  itemScale = is/(ITEMSIZE*SRCRES);

  cellScale = cs/(CELLSIZE*SRCRES);

  int ix0 = (int)round((1*ITEMSIZE + (1 - itemScale)*ITEMSIZE/2)*SRCRES);

  int iy0 = ix0;

  int idx = (int)round(2*ITEMSIZE*SRCRES);

  int idy = idx;

  int cx0 = (int)round((1*ITEMSIZE + (1 - cellScale)*CELLSIZE/2)*SRCRES);

  int cy0 = (int)round((5*ITEMSIZE + (1 - cellScale)*CELLSIZE/2)*SRCRES);

  int cdx = (int)round(3*ITEMSIZE*SRCRES);

  int y = iy0;

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

      if ((itemTiles[itemTilesCount] = subImage(w, h, px, ix0 + i*idx, y, is, is)))

        ++itemTilesCount;

  y += idy;

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

      if ((itemTiles[itemTilesCount] = subImage(w, h, px, ix0 + i*idx, y, is, is)))

        ++itemTilesCount;

  y = cy0;

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

      if ((cellTiles[cellTilesCount] = subImage(w, h, px, cx0 + i*cdx, y, cs, cs)))

        ++cellTilesCount;

  free(px);

  rows = HEIGHT/(CELLSIZE + WALLSIZE);

  cols = WIDTH/(CELLSIZE + WALLSIZE);

  int fw = ceil(WIDTH*RES - 0.001);

  int fh = ceil(HEIGHT*RES - 0.001);

  framebuffer = createFramebuffer(fw, fh);

  fbAnim = createAnimationFromFramebuffer(framebuffer);

  generate();

}

void draw() {

  background(COLOR_WHITE);

  double w = windowGetWidth();

  double h = windowGetHeight();

  if (keyWentDown("space")) generate();

  saveState();

  translate(w/2, h/2);

  zoom(w/WIDTH);

  fill(COLOR_WHITE);

  noStroke();

  rectTextured(fbAnim, -WIDTH/2.0, -HEIGHT/2.0, WIDTH, HEIGHT);

  restoreState();

}

int main() {

  windowSetVariableFrameRate();

  windowSetResizable(TRUE);

  windowSetInit(&init);

  windowSetDraw(&draw);

  windowRun();

}