#include "menu.h"

#include "icons.h"

static int parseImgName(const char *imgname, int *rows, int *cols) {

  if (rows) *rows = 0;

  if (cols) *cols = 0;

  char* p = strrchr(imgname, '.');

  if (!p) return 0;

  int r = 0, c = 0;

  if ( 2 != sscanf(p, ".pz%dx%d", &c, &r)

    || r > 100 || c > 100 || r*c > 200

    || r < 1   || c < 1   || r*c < 2 ) return 0;

  if (rows) *rows = r;

  if (cols) *cols = c;

  return 1;

}

static Animation loadThumb(const char *imgname, Framebuffer fb, int w, int h) {

  char *imgpath = findImage(imgname);

  if (!imgpath)

    { ERR("loadThumb: image not found: %s", imgname); return NULL; }

  if (w < 1) w = 1;

  if (h < 1) h = 1;

  char *tpath = strprintf("%s/%s", thumbsPath(), filename(imgpath));

  if (fileExists(tpath) && filetime(imgpath) < filetime(tpath)) {

    Animation thumb = createAnimationEx(tpath, TRUE, FALSE, FALSE);

    if (abs(animationGetOrigWidth(thumb) - w) <= 2 || abs(animationGetOrigHeight(thumb) - h) <= 2) {

      free(tpath);

      free(imgpath);

      return thumb;

    }

    animationDestroy(thumb);

  }

  INF("loadThumb: create thumbnail: %s -> %s", imgpath, tpath);

  Animation full = createAnimationEx(imgpath, TRUE, FALSE, FALSE);

  int fw = animationGetOrigWidth(full);

  int fh = animationGetOrigHeight(full);

  int tw = w, th = h;

  if (fw*(double)h > fh*(double)w) th = (int)round(w/(double)fw*fh);

                              else tw = (int)round(h/(double)fh*fw);

  if (tw < 1) tw = 1; else if (tw > w) tw = w;

  if (th < 1) th = 1; else if (th > h) th = h;

  DBG("[%dx%d] -> [%dx%d]", fw, fh, tw, th);

  saveState();

  resetState();

  target(fb);

  background(COLOR_TRANSPARENT);

  clear();

  noStroke();

  rectTextured(full, 0, 0, tw, th);

  int iw, ih;

  unsigned char *pixels;

  Animation thumb = NULL;

  if (imageFromViewport(&iw, &ih, &pixels)) {

    if (ih > th) ih = th;

    if (iw > tw) {

      for(int i = 1; i < ih; ++i) memmove(pixels + i*tw*4, pixels + i*iw*4, tw*4);

      iw = tw;

    }

    if (iw != tw || ih != th) {

      WRN("loadThumb: thumbnail was truncated: %s, [%dx%d] -> [%dx%d]", imgpath, tw, th, iw, ih);

    } else

    if (!imageSave(tpath, iw, ih, pixels)) {

      WRN("loadThumb: cannot save thumbnail to: %s", tpath);

      thumb = createAnimationFromImageEx(iw, ih, pixels, FALSE, FALSE, TRUE, TRUE);

    } else {

      thumb = createAnimationEx(tpath, TRUE, FALSE, FALSE);

    }

    free(pixels);

  } else {

    WRN("loadThumb: cannot capture vieport: %s", imgpath);

    unsigned char px[4*4*4] = {};

    thumb = createAnimationFromImageEx(4, 4, px, FALSE, FALSE, TRUE, TRUE);

  }

  restoreState();

  free(tpath);

  free(imgpath);

  return thumb;

}

int menuItemInit(MenuItem *mi, const char *path, const char *imgname, Vec p0, Vec p1, Framebuffer fb, int w, int h) {

  memset(mi, 0, sizeof(*mi));

  DBG("%s, %s", path ? path : "null", imgname ? imgname : "null");

  Vec d = vsub(p1, p0);

  if (!(fabs(d.x) > PRECISION) || !(fabs(d.y) > PRECISION)) return 0;

  if (path) {

    GameInfo *gi = loadGameInfo(path);

    if (!gi) return 0;

    mi->image = loadThumb(gi->imgname, fb, w, h);

    if (!mi->image) { free(gi); return 0; }

    int cnt = gi->rows*gi->cols;

    mi->path = strprintf("%s", path);

    mi->imgname = strprintf("%s", gi->imgname);

    mi->percent = (cnt - gi->groups)/(cnt - 1.0);

    mi->t = filetime(path);

    free(gi);

  } else

  if (imgname) {

    mi->image = loadThumb(imgname, fb, w, h);

    if (!mi->image) return 0;

    mi->imgname = strprintf("%s", imgname);

    parseImgName(mi->imgname, &mi->rows, &mi->cols);

  } else {

    return 0;

  }

  Vec is = { animationGetOrigWidth(mi->image), animationGetOrigHeight(mi->image) };

  if (is.x < 1) is.x = 1;

  if (is.y < 1) is.y = 1;

  Vec k = vabs(vdivv(is, d));

  if (k.x > k.y) {

    double l = (1 - k.y/k.x)/2;

    mi->p0 = vec(p0.x, lintr(p0.y, p1.y, l));

    mi->p1 = vec(p1.x, lintr(p0.y, p1.y, 1-l));

  } else {

    double l = (1 - k.x/k.y)/2;

    mi->p0 = vec(lintr(p0.x, p1.x, l), p0.y);

    mi->p1 = vec(lintr(p0.x, p1.x, 1-l), p1.y);

  }

  return 1;

}

void menuItemFree(MenuItem *mi) {

  free(mi->path);

  free(mi->imgname);

  if (mi->image) animationDestroy(mi->image);

  memset(mi, 0, sizeof(*mi));

}

static void splitRect(Vec p0, Vec p1, double percent, Vec *v0, int *v0c, Vec *v1, int *v1c) {

  Vec s = vabs(vsub(p1, p0));

  if (s.x < s.y) {

    splitRect(vtranspose(p0), vtranspose(p1), percent, v0, v0c, v1, v1c);

    for(int i = 0; i < *v0c; ++i) v0[i] = vtranspose(v0[i]);

    for(int i = 0; i < *v1c; ++i) v1[i] = vtranspose(v1[i]);

    return;

  }

  if (percent > 0.5) {

    splitRect(p1, p0, 1 - percent - PRECISION, v1, v1c, v0, v0c);

    return;

  }

  if (!(percent > PRECISION) || !(s.x > PRECISION) || !(s.y > PRECISION))

    { v0[0] = p0; v0[1] = vec(p1.x, p0.y); v0[2] = p1; v0[3] = vec(p0.x, p1.y); *v0c = 4; *v1c = 0; return; }

  if (!(percent < 1-PRECISION))

    { v1[0] = p1; v1[1] = vec(p0.x, p1.y); v1[2] = p0; v1[3] = vec(p1.x, p0.y); *v0c = 0; *v1c = 4; return; }

  *v0c = *v1c = 0;

   v0[(*v0c)++] = p0;

   v1[(*v1c)++] = p1;

  double af = s.x*s.y;

  double ap = af*percent;

  double ac = s.y*s.y/2;

  if (ap < ac) {

    double ky = sqrt(ap/ac);

    Vec a = { lintr(p0.x, p1.x, ky*s.y/s.x), p0.y };

    Vec b = { p0.x, lintr(p0.y, p1.y, ky) };

    v0[(*v0c)++] = a;

    v0[(*v0c)++] = b;

    v1[(*v1c)++] = vec(p0.x, p1.y);

    v1[(*v1c)++] = b;

    v1[(*v1c)++] = a;

    v1[(*v1c)++] = vec(p1.x, p0.y);

  } else {

    double kx = (ap-ac)/(af-2*ac)*(s.x-s.y)/s.x;

    Vec b = { lintr(p0.x, p1.x, kx), p1.y };

    Vec a = { b.x + p1.y - p0.y, p0.y };

    v0[(*v0c)++] = a;

    v0[(*v0c)++] = b;

    v0[(*v0c)++] = vec(p0.x, p1.y);

    v1[(*v1c)++] = b;

    v1[(*v1c)++] = a;

    v1[(*v1c)++] = vec(p1.x, p0.y);

  }

}

void menuItemDraw(MenuItem *mi) {

  saveState();

  Vec d = vsub(mi->p1, mi->p0);

  if (mi->path) {

    noStroke();

    Vec v[2][5] = {};

    int vc[2] = {};

    splitRect(mi->p0, mi->p1, mi->percent, v[0], &vc[0], v[1], &vc[1]);

    noStroke();

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

      fill(colorByRGBA(1, 1, 1, (2-i)*0.5));

      fillTexture(mi->image, mi->p0.x, mi->p0.y, d.x, d.y, FALSE);

      moveTo(v[i][0].x, v[i][0].y);

      for(int j = 1; j < vc[i]; ++j) lineTo(v[i][j].x, v[i][j].y);

      closePath();

    }

    noFill();

    stroke(COLOR_BLUE);

    rect(mi->p0.x, mi->p0.y, d.x, d.y);

  } else {

    stroke(COLOR_BLACK);

    fill(COLOR_WHITE);

    rectTextured(mi->image, mi->p0.x, mi->p0.y, d.x, d.y);

  }

  restoreState();

}

static Animation loadIcon(const void *data, size_t size) {

  unsigned char *p = NULL; int w = 0, h = 0;

  if (!imageLoadFromMemory(data, size, &w, &h, &p))

    return createAnimationEmpty();

  Animation a = createAnimationFromImageEx(w, h, p, FALSE, FALSE, TRUE, TRUE);

  free(p);

  return a;

}

void menuInit(Menu *m) {

  memset(m, 0, sizeof(*m));

  m->contentSize = vone();

  #define LOADICON(x) loadIcon(dataIcon ## x, dataIcon ## x ## Size)

  m->iconBack     = LOADICON(Back);

  m->iconCount[0] = LOADICON(Count1);

  m->iconCount[1] = LOADICON(Count2);

  m->iconCount[2] = LOADICON(Count3);

  m->iconCount[3] = LOADICON(Count4);

  m->iconTurn[0]  = LOADICON(Noturn);

  m->iconTurn[1]  = LOADICON(Turn);

  #undef LOADICON

}

void menuFree(Menu *m) {

  if (gameStarted(&m->gm)) gameFree(&m->gm);

  for(int i = 0; i < m->itemsCnt; ++i) menuItemFree(&m->items[i]);

  free(m->items);

  if (m->iconBack) animationDestroy(m->iconBack);

  for(int i = 0; i < COUNTOF(m->iconCount); ++i)

    if (m->iconCount[i]) animationDestroy(m->iconCount[i]);

  for(int i = 0; i < COUNTOF(m->iconTurn); ++i)

    if (m->iconTurn[i]) animationDestroy(m->iconTurn[i]);

  memset(m, 0, sizeof(*m));

}

void menuUpdateItems(Menu* m) {

  // remove old items, but copy images to keep them in memory

  Animation animCopy = createAnimationEmpty();

  for(int i = 0; i < m->itemsCnt; ++i) {

    animationInsert(animCopy, -1, m->items[i].image);

    menuItemFree(&m->items[i]);

  }

  free(m->items);

  m->itemsCnt = 0;

  Vec border = {1, 1};

  Vec spacing = {1, 1};

  Vec thumb = {16, 12};

  int cols = 4;

  int tw = 256;

  int th = tw/4*3;

  Framebuffer fb = createFramebuffer(tw, tw);

  PathList *pls = saveFiles();

  PathList *pli = imageFiles();

  m->items = alloc((pls->cnt + pli->cnt)*ASIZEOF(*m->items));

  int c = 0;

  double y = border.y, ly = y;

  for(int i = 0; i < pls->cnt; ++i) {

    Vec p0 = { border.x + (thumb.x + spacing.x)*c, y };

    Vec p1 = vadd(p0, thumb);

    if (menuItemInit(&m->items[m->itemsCnt], pls->l[i], NULL, p0, p1, fb, tw, th)) {

      if (++c >= cols) { c = 0; y += thumb.y + spacing.y; }

      ++m->itemsCnt; ly = p1.y;

    }

  }

  if (c) { c = 0; y += thumb.y + spacing.y; }

  if (m->itemsCnt) y += spacing.y;

  for(int i = 0; i < pli->cnt; ++i) {

    Vec p0 = { border.x + (thumb.x + spacing.x)*c, y };

    Vec p1 = vadd(p0, thumb);

    char *imgname = filebase(pli->l[i]);

    if (menuItemInit(&m->items[m->itemsCnt], NULL, imgname, p0, p1, fb, tw, th)) {

      if (++c >= cols) { c = 0; y += thumb.y + spacing.y; }

      ++m->itemsCnt; ly = p1.y;

    }

    free(imgname);

  }

  animationDestroy(animCopy);

  free(pls);

  free(pli);

  framebufferDestroy(fb);

  m->contentSize = vec( 2*border.x + thumb.x*cols + spacing.x*(cols-1), ly + border.y );

}

int menuSave(Menu *m) {

  makeDirectoryRecursive(savesPath());

  const char *fn = settingsFile();

  FILE *f = fopen(fn, "w");

  if (!f) return ERR("menuSave: cannnot open file for write: %s", fn);

  fprintf(f, "puzzle1\n[%s]\n%d %d\n", m->gm.path ? m->gm.path : "", m->countMode, m->turnMode);

  fflush(f);

  if (ferror(f)) ERR("menuSave: cannnot write to file: %s", fn);

  fclose(f);

  return 1;

}

int menuLoad(Menu *m) {

  const char *fn = settingsFile();

  FILE *f = fopen(fn, "r");

  if (!f) return 0;

  char *l = trim(readline(f));

  if (strcmp(l, "puzzle1")) {

    ERR("menuLoad: wrong file version (expected: puzzle1): %s", l);

    free(l); fclose(f); return 0;

  }

  l = unquote(readline(f), '[', ']');

  int cm = -1, tm = -1;

  fscanf(f, "%d %d", &cm, &tm);

  fclose(f);

  if ( cm < 0 || cm > COUNTOF(m->iconCount) || tm < 0 || tm > COUNTOF(m->iconTurn))

    { ERR("menuLoad: cannot parse file: %s", fn); free(l); return 0; }

  m->countMode = cm;

  m->turnMode = tm;

  if (*l) gameLoad(&m->gm, l);

  free(l);

  return 1;

}

void menuChooseItem(Menu *m, MenuItem *mi) {

  if (mi->path) {

    gameLoad(&m->gm, mi->path);

    return;

  }

  int cnt = m->countMode == 0 ? 12

          : m->countMode == 1 ? 24

          : m->countMode == 2 ? 48 : 96;

  int rows = mi->rows;

  int cols = mi->cols;

  if (!mi->rows || !mi->cols) { rows = cnt; cols = 0; }

  char *path = NULL;

  for(int j = 0; j < 10000; ++j) {

    path = strprintf("%s/%s_%04d.puzzle", savesPath(), mi->imgname, j);

    if (fileExists(path)) { free(path); continue; }

    gameCreate(&m->gm, path, mi->imgname, rows, cols, m->turnMode, 0);

    free(path);

    break;

  }

}

void menuClick(Menu *m, Vec screenSize, double cornerSize) {

  double cs2 = cornerSize*cornerSize;

  if (vlen2(vsub(vec(screenSize.x, 0), m->mouseDownPos)) <= cs2)

    { m->countMode = (m->countMode+1) % COUNTOF(m->iconCount); return; }

  if (vlen2(vsub(screenSize, m->mouseDownPos)) <= cs2)

    { m->turnMode = (m->turnMode+1) % COUNTOF(m->iconTurn); return; }

  Vec p = m->mouseDownPos;

  p.y += m->scrollPos;

  for(int i = 0; i < m->itemsCnt; ++i) {

    MenuItem *mi = &m->items[i];

    if ( !(p.x >= mi->p0.x) || !(p.x <= mi->p1.x)

      || !(p.y >= mi->p0.y) || !(p.y <= mi->p1.y) ) continue;

    m->choosingItem = mi;

    m->choosingItemFrames = 4;

    return;

  }

}

void menuDraw(Menu *m) {

  if (m->choosingItem) {

    if (--m->choosingItemFrames > 0) return;

    MenuItem *mi = m->choosingItem;

    m->choosingItem = NULL;

    m->choosingItemFrames = 0;

    menuChooseItem(m, mi);

  }

  int w = windowGetWidth();

  int h = windowGetHeight();

  double dt = windowGetFrameTime();

  double k = w/m->contentSize.x;

  Vec screenSize = { w/k, h/k };

  double maxPath    = m->contentSize.x*0.1;

  double scrollMax  = m->contentSize.y - screenSize.y;

  double scrollBase = m->contentSize.x*dt*2;

  double scrollDecc = m->contentSize.x*dt*2;

  double scrollOver = m->contentSize.x*0.2;

  if (!(scrollMax > 0)) scrollMax = 0;

  saveState();

  zoom(k);

  strokeWidth(1/k);

  double cornerSizeX = screenSize.x/8;

  double cornerSizeY = screenSize.y/4;

  double cornerSize = cornerSizeX < cornerSizeY ? cornerSizeX : cornerSizeY;

  Vec mouse = { mouseTransformedX(), mouseTransformedY() };

  if (mouseWentDown("left")) {

    m->mouseDownPos = mouse;

    m->mouseDownTime = 0;

    m->mousePath = 0;

    m->mouseScroll = m->scrollPos;

    if (vlen2(mouse) <= cornerSize*cornerSize || gameWon(&m->gm))

    {

      if (gameStarted(&m->gm) && !gameWon(&m->gm)) gameSave(&m->gm);

      m->closing = 1;

    }

  }

  if (mouseWentUp("left")) m->closing = 0;

  if (mouseDown("left")) {

    m->mousePath += vlen(vsub(mouse, m->mouse));

    m->mouseDownTime += dt;

    if (!(m->mousePath < maxPath)) m->closing = 0;

  }

  if (!gameStarted(&m->gm)) {

    if (mouseWentDown("left"))

      memset(m->scrollHist, 0, sizeof(m->scrollHist));

    if (mouseWentUp("left")) {

      if ( m->mousePath < maxPath

        && m->mouseDownTime < 1

        && vlen(vsub(mouse, m->mouseDownPos)) < maxPath )

      {

        m->scrollVel = 0;

        menuClick(m, screenSize, cornerSize);

      } else {    

        double p1 = m->scrollPos, p0 = p1, t = 0;

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

          if (m->scrollHist[i][1] > PRECISION) {

            p0 = m->scrollHist[i][0];

            t += m->scrollHist[i][1];

            if (i >= 3 && t > 0.2) break;

          }

        }

        m->scrollVel = t > PRECISION ? (p1 - p0)/t : 0;

      }

    }

    if (mouseDown("left")) {

      m->scrollPos = m->mouseScroll + m->mouseDownPos.y - mouse.y;

      memmove(m->scrollHist + 1, m->scrollHist, (MS_CNT-1)*sizeof(*m->scrollHist));

      m->scrollHist[0][0] = m->scrollPos;

      m->scrollHist[0][1] = dt;

    } else {

      if (m->scrollPos < -scrollOver && m->scrollVel < 0) m->scrollVel = 0;

      if (m->scrollPos > scrollMax+scrollOver && m->scrollVel > 0) m->scrollVel = 0;

      m->scrollPos += m->scrollVel*dt;

      if (m->scrollVel < 0) {

        m->scrollVel += scrollDecc;

        if (!(m->scrollVel < 0)) m->scrollVel = 0;

      } else {

        m->scrollVel -= scrollDecc;

        if (!(m->scrollVel > 0)) m->scrollVel = 0;

      }

      if (m->scrollPos < 0) {

        m->scrollPos += scrollBase;

        if (!(m->scrollPos < 0)) m->scrollPos = 0;

      } else

      if (m->scrollPos > scrollMax) {

        m->scrollPos -= scrollBase;

        if (!(m->scrollPos > scrollMax)) m->scrollPos = scrollMax;

      }

    }

    saveState();

    translate(0, -m->scrollPos);

    for(int i = 0; i < m->itemsCnt; ++i)

      menuItemDraw(&m->items[i]);

    restoreState();

  }

  m->mouse = mouse;

  if (gameStarted(&m->gm)) {

    int wasGroups = m->gm.pz.groups;

    int wasWon = gameWon(&m->gm);

    saveState();

    zoom(1/k);

    gameDraw(&m->gm);

    restoreState();

    if (wasGroups != m->gm.pz.groups && !gameWon(&m->gm))

      gameSave(&m->gm);

    if (wasWon && gameWon(&m->gm) && fileExists(m->gm.path) && remove(m->gm.path))

      ERR("cannot remove save-file for the won game: %s", m->gm.path);

  }

  saveState();

  noStroke();

  fill(colorByRGBA(1, 1, 1, 0.25));

  rectTextured(m->iconBack, 0, 0, cornerSize, cornerSize);

  if (!gameStarted(&m->gm)) {

    rectTextured(m->iconCount[m->countMode], screenSize.x-cornerSize, 0, cornerSize, cornerSize);

    rectTextured(m->iconTurn[m->turnMode], screenSize.x-cornerSize, screenSize.y-cornerSize, cornerSize, cornerSize);

  }

  restoreState();

  if (m->closing) {

    m->closingTransition += dt;

    if (m->closingTransition > 1) {

      if (gameStarted(&m->gm)) {

        gameFree(&m->gm);

        m->closing = 0;

        m->closingTransition = 0;

        menuUpdateItems(m);

      } else {

        m->closingTransition = 1;

        windowStop();

      }

    }

  } else {

    m->closingTransition -= dt;

    if (!(m->closingTransition > 0)) m->closingTransition = 0;

  }

  if (m->closingTransition > 0) {

    saveState();

    noStroke();

    fill(gameStarted(&m->gm) ? colorByRGBA(0.05, 0.05, 0.05, 1) : COLOR_BLACK);

    Vec c = m->mouseDownPos;

    Vec d = vsub(screenSize, c);

    double rmax2 = maxd( maxd(vlen2(vec(c.x, d.y)), vlen2(c)),

                         maxd(vlen2(vec(d.x, c.y)), vlen2(d)) );

    double r0 = sqrt(rmax2) * (1 - m->closingTransition);

    double r1 = r0 + vlen(screenSize);

    arcPath(c.x-r0, c.y-r0, 2*r0, 2*r0, 180, -180);

    arcPath(c.x-r1, c.y-r1, 2*r1, 2*r1, -180, 180);

    closePath();

    restoreState();

  }

  restoreState();

}