#include "puzzle.h"

unsigned int chunkCalcEdges(Chunk *c) {

  unsigned int edges = 0;

  if (c->c   <= 0           || c->pz->chunks[c->r][c->c-1].parent != c->parent) edges |= PF_BORDER_L;

  if (c->c+1 >= c->pz->cols || c->pz->chunks[c->r][c->c+1].parent != c->parent) edges |= PF_BORDER_R;

  if (c->r   <= 0           || c->pz->chunks[c->r-1][c->c].parent != c->parent) edges |= PF_BORDER_T;

  if (c->r+1 >= c->pz->rows || c->pz->chunks[c->r+1][c->c].parent != c->parent) edges |= PF_BORDER_B;

  return edges;

}

void chunkDrawBase(Chunk *c, unsigned int edges) {

  int levels = 4;

  Vec gp = chunkGroupPos(c);

  saveState();

  noFill();

  strokeWidth( mind(c->pz->cs.x, c->pz->cs.y)*0.025 );

  translate(-gp.x, -gp.y);

  if (edges & PF_BORDER_T) lineDraw(c->pz->hlines[c->r + 0] + (c->c + 0)*LN_SEGS,  1, levels);

  if (edges & PF_BORDER_R) lineDraw(c->pz->vlines[c->c + 1] + (c->r + 0)*LN_SEGS,  1, levels);

  if (edges & PF_BORDER_B) lineDraw(c->pz->hlines[c->r + 1] + (c->c + 1)*LN_SEGS, -1, levels);

  if (edges & PF_BORDER_L) lineDraw(c->pz->vlines[c->c + 0] + (c->r + 1)*LN_SEGS, -1, levels);

  restoreState();

  saveState();

  translate(-gp.x, -gp.y);

  /*strokeWidth( mind(c->pz->cs.x, c->pz->cs.y)*0.1 );

  stroke(COLOR_WHITE);

  strokeTexture(c->pz->image, 0, 0, c->pz->cols*c->pz->cs.x, c->pz->rows*c->pz->cs.x, FALSE);

  if (edges & PF_BORDER_T)    lineDraw(c->pz->hlines[c->r + 0] + (c->c + 0)*LN_SEGS,  1, levels);

  if (edges & PF_BORDER_R)  lineDraw(c->pz->vlines[c->c + 1] + (c->r + 0)*LN_SEGS,  1, levels);

  if (edges & PF_BORDER_B) lineDraw(c->pz->hlines[c->r + 1] + (c->c + 1)*LN_SEGS, -1, levels);

  if (edges & PF_BORDER_L)   lineDraw(c->pz->vlines[c->c + 0] + (c->r + 1)*LN_SEGS, -1, levels);*/

  noStroke();

  fill(COLOR_WHITE);

  fillTexture(c->pz->image, 0, 0, c->pz->cols*c->pz->cs.x, c->pz->rows*c->pz->cs.y, FALSE);

  linePut(c->pz->hlines[c->r + 0] + (c->c + 0)*LN_SEGS,  1, levels);

  linePut(c->pz->vlines[c->c + 1] + (c->r + 0)*LN_SEGS,  1, levels);

  linePut(c->pz->hlines[c->r + 1] + (c->c + 1)*LN_SEGS, -1, levels);

  linePut(c->pz->vlines[c->c + 0] + (c->r + 1)*LN_SEGS, -1, levels);

  closePath();

  restoreState();

}

void chunkDraw(Chunk *c) {

  saveState();

  Vec p = chunkWorldPos(c);

  translate(p.x, p.y);

  rotate(vangled(c->parent->dx));

  if (c->t.tex && c->t.ts > 1e-5 && (c->flags & PF_RENDERED)) {

    translate(-c->t.s/2, -c->t.s/2);

    noStroke();

    double k = c->t.s/c->t.ts;

    fillTexture(c->t.tex, -c->t.tp.x*k, -c->t.tp.y*k, k, k, FALSE);

    rect(0, 0, c->t.s, c->t.s);

  } else {

    chunkDrawBase(c, chunkCalcEdges(c));

  }

  restoreState();

}

void chunkDrawDebug(Chunk *c) {

  saveState();

  Vec p = chunkWorldPos(c);

  translate(p.x, p.y);

  rotate(vangled(c->parent->dx));

  stroke(randColorPtr(c->parent));

  Vec hs = vdiv(c->pz->cs, 2);

  if (c->flags & PF_HANDLE_L) line(-hs.x, -hs.y, -hs.x,  hs.y);

  if (c->flags & PF_HANDLE_R) line( hs.x, -hs.y,  hs.x,  hs.y);

  if (c->flags & PF_HANDLE_T) line(-hs.x, -hs.y,  hs.x, -hs.y);

  if (c->flags & PF_HANDLE_B) line(-hs.x,  hs.y,  hs.x,  hs.y);

  restoreState();

}

void chunkRender(Chunk *c) {

  if (!c->t.fb || !(c->t.ts > 1e-5)) return;

  unsigned int edges = PF_RENDERED | chunkCalcEdges(c);

  if ((c->flags & PF_RENDERING) == edges) return;

  saveState();

  target(c->t.fb);

  resetStateEx(STATE_TRANSFORM);

  int ix = (int)round(c->t.tp.x*TM_SIZE);

  int iy = (int)round(c->t.tp.y*TM_SIZE);

  int s = (int)round(c->t.ts*TM_SIZE);

  background(COLOR_TRANSPARENT);

  glEnable(GL_SCISSOR_TEST);

  glScissor(ix, iy, s, s);

  clear();

  glScissor(0, 0, TM_SIZE, TM_SIZE);

  glDisable(GL_SCISSOR_TEST);

  double k = c->t.s/c->t.ts;

  zoom(TM_SIZE/k);

  translate(c->t.tp.x*k + c->t.s/2, c->t.tp.y*k + c->t.s/2);

  cliprect(-c->t.s/2, -c->t.s/2, c->t.s, c->t.s);

  chunkDrawBase(c, edges);

  c->flags |= edges;

  restoreState();

}

void chunkMerge(Chunk *a, Chunk *b) {

  if (a->parent == b->parent) return;

  Puzzle *pz = a->pz;

  PhGroup *pa = a->parent, *pb = b->parent;

  phGroupMerge(pa, pb);

  phGroupFix(pa, !pz->turn);

  for(int r = 0; r < pz->rows; ++r)

  for(int c = 0; c < pz->cols; ++c) {

    Chunk *chunk = &pz->chunks[r][c];

    if (chunk->parent == pa || chunk->parent == pb) chunk->flags &= ~PF_HANDLES;

    if (chunk->parent != pb) continue;

    chunk->parent = pa;

    chunkRender(chunk);

    if (c   > 0       ) chunkRender(&pz->chunks[r][c-1]);

    if (c+1 < pz->cols) chunkRender(&pz->chunks[r][c+1]);

    if (r   > 0       ) chunkRender(&pz->chunks[r-1][c]);

    if (r+1 < pz->rows) chunkRender(&pz->chunks[r+1][c]);

  }

  int c0 = pz->cols-1, c1 = 0;

  for(int r = 0; r < pz->rows; ++r) {

    Chunk *first = NULL, *last = NULL;

    for(int c = 0; c < pz->cols; ++c) {

      Chunk *chunk = &pz->chunks[r][c];

      if (chunk->parent != pa) continue;

      if (c <= c0) { first = chunk; c0 = c; }

      if (c >= c1) { last  = chunk; c1 = c; }

    }

    if (first) first->flags |= PF_HANDLE_L;

    if (last)  last->flags  |= PF_HANDLE_R;

  }

  c0 = pz->cols-1, c1 = 0;

  for(int r = pz->rows-1; r >= 0; --r) {

    Chunk *first = NULL, *last = NULL;

    for(int c = 0; c < pz->cols; ++c) {

      Chunk *chunk = &pz->chunks[r][c];

      if (chunk->parent != pa) continue;

      if (c <= c0) { first = chunk; c0 = c; }

      if (c >= c1) { last  = chunk; c1 = c; }

    }

    if (first) first->flags |= PF_HANDLE_L;

    if (last)  last->flags  |= PF_HANDLE_R;

  }

  int r0 = pz->rows-1, r1 = 0;

  for(int c = 0; c < pz->cols; ++c) {

    Chunk *first = NULL, *last = NULL;

    for(int r = 0; r < pz->rows; ++r) {

      Chunk *chunk = &pz->chunks[r][c];

      if (chunk->parent != pa) continue;

      if (r <= r0) { first = chunk; r0 = r; }

      if (r >= r1) { last  = chunk; r1 = r; }

    }

    if (first) first->flags |= PF_HANDLE_T;

    if (last)  last->flags  |= PF_HANDLE_B;

  }

  r0 = pz->rows-1, r1 = 0;

  for(int c = pz->cols-1; c >= 0; --c) {

    Chunk *first = NULL, *last = NULL;

    for(int r = 0; r < pz->rows; ++r) {

      Chunk *chunk = &pz->chunks[r][c];

      if (chunk->parent != pa) continue;

      if (r <= r0) { first = chunk; r0 = r; }

      if (r >= r1) { last  = chunk; r1 = r; }

    }

    if (first) first->flags |= PF_HANDLE_T;

    if (last)  last->flags  |= PF_HANDLE_B;

  }

}

void chunkTryMerge(Chunk *a, int dr, int dc) {

  int r = a->r + dr;

  int c = a->c + dc;

  Puzzle *pz = a->pz;

  if (r < 0 || c < 0 || r >= pz->rows || c >= pz->cols) return;

  Chunk *b = &pz->chunks[r][c];

  if (a->parent == b->parent) return;

  Vec gp = vadd( chunkGroupPos(a), vdiv(vec(dc,dr), 2));

  Vec pa = phGroupTrans(a->parent, gp);

  Vec pb = phGroupTrans(b->parent, gp);

  double d2 = vdist2(pb, pa);

  if (d2 < pz->cs.x*pz->cs.y/16)

    chunkMerge(a, b);

}

Flags chunkCheckPoint(Chunk *c, Vec p) {

  Vec hs = vdiv(c->pz->cs, 2);

  double hbs = mind(hs.x, hs.y);

  Vec hs0 = vsub(hs, vecxy(hbs*0.25));

  Vec hs1 = vadd(hs, vecxy(hbs*0.50));

  Vec gp = vsub(phGroupUntrans(c->parent, p), chunkGroupPos(c));

  int l = c->flags & (gp.x < 0 ? PF_HANDLE_L : PF_HANDLE_R);

  int t = c->flags & (gp.y < 0 ? PF_HANDLE_T : PF_HANDLE_B);

  gp = vabs(gp);

  int inx = gp.x < hs0.x;

  int iny = gp.y < hs0.y;

  if (!(gp.x < hs1.x) || !(gp.y < hs1.y)) return 0;

  if (inx && iny) return PCP_BODY;

  Flags res = 0;

  if (gp.x < hs.x && gp.y < hs.y) res |= PCP_BODY;

  double r = hs1.x - hs.x;

  if ( (l && !inx && gp.y < hs.y)

    || (t && !iny && gp.x < hs.x)

    || (l && t && !inx && !iny && vdist2(gp, hs) < r*r) ) res |= PCP_EDGE;

  return res;

}