#include <math.h>

#include <stdio.h>

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include "helianthus.h"

#define COLS          16

#define ROWS           9

#define ACTIVELETTERS 20

#define MAXLETTERS   256

#define MAXSOUNDS     16

#define RMTIME       1.0

#define EXTIME       2.0

#define COUNT (ROWS*COLS)

typedef struct {

  Animation glyphs[4];

  int glyphsCount;

  Sound sounds[MAXSOUNDS];

  int soundsCount;

  Animation g[4];

} Letter;

typedef struct {

  int r, c;

} Pos;

typedef struct {

  int len;

  Pos p[4];

  double tm;

} Track;

typedef struct {

  Letter *l;

  Animation g;

  double tm;

} Cell;

Letter menuLetter;

Letter letters[MAXLETTERS];

int lettersCount;

int cellWidth = 1;

int cellHeight = 1;

Cell board[ROWS][COLS];

Pos selected = { -1, -1 };

Track tracks[COUNT];

int tracksCount;

Animation bgtex;

int glyphsMask = 0;

int mode;

int mute;

double exitTm;

void clearBoard() {

  exitTm = 0;

  mode = 0;

  memset(tracks, 0, sizeof(tracks));

  memset(board, 0, sizeof(board));

  tracksCount = 0;

  selected = (Pos){ -1, -1 };

}

void clearSounds() {

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

    for(int j = 0; j < letters[i].soundsCount; ++i)

      soundDestroy(letters[i].sounds[j]);

}

void clearLetters() {

  clearBoard();

  clearSounds();

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

    for(int j = 0; j < letters[i].glyphsCount; ++j)

      animationDestroy(letters[i].glyphs[j]);

  memset(letters, 0, sizeof(letters));

  memset(&menuLetter, 0, sizeof(menuLetter));

  lettersCount = 0;

  cellWidth = cellHeight = 1;

}

int loadLetters(const char *filename, int rows, int cols) {

  clearLetters();

  int w, h;

  unsigned char *pixels;

  if (!imageLoad(filename, &w, &h, &pixels))

    return FALSE;

  int stride = w*4;

  int ww = w/cols/2;

  int hh = h/rows/2;

  if (!ww || !hh)

    { free(pixels); return FALSE; }

  int bufstride = ww*4;

  int bufsize = hh*bufstride;

  unsigned char *buf = calloc(bufsize, 1);

  Letter *letter = letters;

  for(int r = 0; r < rows; ++r)

  for(int c = 0; c < cols; ++c)

  {

    for(int rr = 0; rr < 2; ++rr)

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

      unsigned char *p = pixels + (r*2 + rr)*hh*stride + (c*2 + cc)*bufstride;

      for(int rrr = 0; rrr < hh; ++rrr) memcpy(buf + rrr*bufstride, p + rrr*stride, bufstride);

      unsigned int visible = 0;

      for(unsigned char *b = buf + 3, *e = b + bufsize; b < e; b += 4) visible += *b;

      if (!visible) continue;

      letter->glyphs[ letter->glyphsCount++ ] = createAnimationFromImage(ww, hh, buf, TRUE);

    }

    if (letter->glyphsCount > menuLetter.glyphsCount) menuLetter = *letter;

    if (letter->glyphsCount > 0) ++letter;

  }

  lettersCount = letter - letters;

  cellWidth = ww;

  cellHeight = hh;

  assert(menuLetter.glyphsCount == 4);

  free(buf);

  free(pixels);

  return TRUE;

}

void loadSounds(const char *path) {

  Directory dir = openDirectoryEx(path, "", ".ogg", FALSE, TRUE, FALSE);

  if (!dir) return;

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

    int index = atoi(directoryGet(dir, i));

    if (index <= 0 || index > lettersCount) continue;

    Letter *l = &letters[index-1];

    if (l->soundsCount >= MAXSOUNDS) continue;

    l->sounds[l->soundsCount] = createSound(directoryGetFull(dir, i));

    if (l->sounds[l->soundsCount]) ++l->soundsCount;

  }

  closeDirectory(dir);

}

void shuffleLetters(int glyps) {

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

    int j = randomNumber(i, lettersCount - 1);

    if (j != i) { Letter l = letters[i]; letters[i] = letters[j]; letters[j] = l; }

    Letter *l = &letters[i];

    assert(l->glyphsCount > 0);

    int gc = 0;

    Animation g[4] = {};

    for(int j = 0; j < l->glyphsCount; ++j)

      if (glyps & (1 << j)) g[gc++] = l->glyphs[j];

    if (!gc) g[gc++] = l->glyphs[0];

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

      int k = randomNumber(j, gc - 1);

      if (k != j) { Animation a = g[j]; g[j] = g[k]; g[k] = a; }

    }

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

      l->g[j] = g[j%gc];

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

      int k = randomNumber(j, 3);

      if (k != j) { Animation g = l->g[j]; l->g[j] = l->g[k]; l->g[k] = g; }

      assert(l->g[j]);

    }

  }

}

void simpleBoard() {

  clearBoard();

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

    Letter *l = &letters[i%lettersCount];

    board[i/COLS][i%COLS].l = l;

    board[i/COLS][i%COLS].g = l->glyphs[1];

  }

  mode = 1;

}

void generateBoard(int glyphsMask, int maxLetters) {

  if (maxLetters < 1) maxLetters = 1;

  clearBoard();

  shuffleLetters(glyphsMask);

  int indices[COUNT];

  for(int i = 0; i < COUNT; ++i) indices[i] = i;

  int lc = lettersCount < maxLetters ? lettersCount : maxLetters;

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

    int j = randomNumber(i, COUNT-1);

    int id = indices[j]; indices[j] = indices[i]; indices[i] = id;

    Letter *l = &letters[ (id/4)%lc ];

    board[i/COLS][i%COLS].l = l;

    board[i/COLS][i%COLS].g = l->g[id%4];

  }

  mode = 1;

}

Letter* get(Pos p)

  { return p.r >= 0 && p.r < ROWS && p.c >= 0 && p.c < COLS ? board[p.r][p.c].l : NULL; }

int findSubTrack1(Track *t, Pos b) {

  Pos p = t->p[t->len - 1];

  //printf(" --  -- ft1: %d %d -> %d %d\n", p.r, p.c, b.r, b.c);

  if (p.c == b.c && p.r < b.r) { for(++p.r; p.r != b.r; ++p.r) if (get(p)) return FALSE; } else

  if (p.c == b.c && p.r > b.r) { for(--p.r; p.r != b.r; --p.r) if (get(p)) return FALSE; } else

  if (p.r == b.r && p.c < b.c) { for(++p.c; p.c != b.c; ++p.c) if (get(p)) return FALSE; } else

  if (p.r == b.r && p.c > b.c) { for(--p.c; p.c != b.c; --p.c) if (get(p)) return FALSE; } else return FALSE;

  t->p[t->len++] = p;

  return TRUE;

}

int findSubTrack2(Track *t, Pos b, int horz) {

  Pos *p = &t->p[t->len];

  *p = t->p[t->len - 1];

  //printf(" -- ft2: %d %d -> %d %d %s\n", p->r, p->c, b.r, b.c, horz ? "horz" : "vert");

  if (p->c == b.c || p->r == b.r) return findSubTrack1(t, b);

  ++t->len;

  if (horz) {

    if (p->c < b.c) { for(++p->c; p->c != b.c; ++p->c) if (get(*p)) break; }

               else { for(--p->c; p->c != b.c; --p->c) if (get(*p)) break; }

  } else {

    if (p->r < b.r) { for(++p->r; p->r != b.r; ++p->r) if (get(*p)) break; }

               else { for(--p->r; p->r != b.r; --p->r) if (get(*p)) break; }

  }

  if (!get(*p) && findSubTrack1(t, b)) return TRUE;

  --t->len;

  return FALSE;

}

int findSubTrack3(Track *t, Pos b) {

  Pos p0 = t->p[t->len - 1];

  Pos *p = &t->p[t->len];

  if (p->c == b.c && p->r == b.r) return FALSE;

  //printf("ft3: %d %d -> %d %d\n", p0.r, p0.c, b.r, b.c);

  if (findSubTrack2(t, b, FALSE)) return TRUE;

  ++t->len;

  *p = p0;

  for(++p->c; p->c <= COLS; ++p->c)

    if (get(*p)) break; else

      if (findSubTrack2(t, b, FALSE)) return TRUE;

  *p = p0;

  for(--p->c; p->c >= -1; --p->c)

    if (get(*p)) break; else

      if (findSubTrack2(t, b, FALSE)) return TRUE;

  *p = p0;

  for(++p->r; p->r <= ROWS; ++p->r)

    if (get(*p)) break; else

      if (findSubTrack2(t, b, TRUE)) return TRUE;

  *p = p0;

  for(--p->r; p->r >= -1; --p->r)

    if (get(*p)) break; else

      if (findSubTrack2(t, b, TRUE)) return TRUE;

  --t->len;

  return FALSE;

}

Track findTrack(Pos a, Pos b) {

  Track t = {};

  t.p[t.len++] = a;

  Letter *la = get(a);

  Letter *lb = get(b);

  return la && la == lb && (a.c != b.c || a.r != b.r) && findSubTrack3(&t, b) ? t : (Track){};

}

void hint() {

  if (tracksCount) return;

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

    Pos a = { i/COLS, i%COLS };

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

      Pos b = { j/COLS, j%COLS };

      Track t = findTrack(a, b);

      if (t.len) {

        t.tm = 1;

        tracks[tracksCount++] = t;

      }

    }

  }

  if (!tracksCount) return; // beep

  int i = randomNumber(0, tracksCount - 1);

  if (i) tracks[0] = tracks[i];

  tracksCount = 1;

}

void init() {

  bgtex = createAnimationEx("data/shisen/minas.png", TRUE, TRUE, TRUE);

  if (!loadLetters("data/shisen/letters-gen.png", 5, 8)) {

    printf("cannot load letters\n");

    windowStop();

    return;

  }

  loadSounds("data/shisen/sounds");

  //simpleBoard();

}

void draw() {

  double w = windowGetWidth();

  double h = windowGetHeight();

  double dt = windowGetFrameTime();

  saveState();

  translate(w*0.5, h*0.5);

  {

    saveState();

    double aw = animationGetFrameOrigWidth(bgtex, 0);

    double ah = animationGetFrameOrigHeight(bgtex, 0);

    double kw = w/aw;

    double kh = h/ah;

    double k = kw > kh ? kw: kh;

    aw *= k;

    ah *= k;

    noStroke();

    rectTextured(bgtex, -0.5*aw, -0.5*ah, aw, ah);

    fill(colorByRGBA(1.0, 1.0, 1.0, 0.5));

    rect(-0.5*aw, -0.5*ah, aw, ah);

    restoreState();

  }

  if (mode == 0) {

    double kw = w/(cellWidth*6);

    double kh = h/(cellHeight*3);

    double k = kw < kh ? kw: kh;

    if (k > 1) k = 1;

    zoom(k);

    noStroke();

    translate(-cellWidth*2, -0.5*cellHeight);

    assert(letters[0].glyphsCount >= 4);

    int mc = (int)floor(mouseTransformedX()/cellWidth);

    int mr = (int)floor(mouseTransformedY()/cellHeight);

    if (!mr && mc >= 0 && mc < 4 && mouseWentDown("left")) glyphsMask ^= 1 << mc;

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

      double s = !mr && mc == i ? 1 : 0.9;

      double d = (1 - s)/2;

      double a = glyphsMask & (1 << i) ? 1.0 : 0.5;

      fill(colorByRGBA(1, 1, 1, a));

      rectTextured(menuLetter.glyphs[i], (i + d)*cellWidth, d*cellHeight, cellWidth*s, cellHeight*s);

    }

    if (glyphsMask) {

      noFill();

      stroke(colorByRGBA(0.0, 0.0, 0.0, 0.75));

      textAlign(HALIGN_CENTER, VALIGN_CENTER);

      textSize(cellHeight*0.5);

      text(2*cellWidth, 1.5*cellHeight, "press enter");

      if ( keyWentDown("any enter")

        || (mr == 1 && mc >= 0 && mc < 4 && mouseWentDown("left")) )

          generateBoard(glyphsMask, ACTIVELETTERS);

    }

    if (keyWentDown("escape")) windowStop();

  } else {

    double kw = w/(cellWidth*(COLS + 4));

    double kh = h/(cellHeight*(ROWS + 2));

    double k = kw < kh ? kw: kh;

    zoom(k);

    translate(-0.5*COLS*cellWidth, -0.5*ROWS*cellHeight);

    strokeWidth(0.1*cellWidth);

    saveState();

    noFill();

    stroke(colorByRGBA(0.0, 0.0, 0.0, 0.75));

    textSize(cellWidth*0.5);

    textAlign(HALIGN_RIGHT, VALIGN_BOTTOM);

    text(-0.2*cellWidth, -0.2*cellHeight, "back");

    textAlign(HALIGN_LEFT, VALIGN_TOP);

    text((COLS + 0.2)*cellWidth, (ROWS + 0.2)*cellHeight, "hint");

    textAlign(HALIGN_LEFT, VALIGN_BOTTOM);

    text((COLS + 0.2)*cellWidth, -0.2*cellHeight, mute ? "silence" : "sound");

    restoreState();

    double mx = mouseTransformedX();

    double my = mouseTransformedY();

    Pos hover = {};

    hover.r = (int)floor(my/cellHeight);

    hover.c = (int)floor(mx/cellWidth);

    if (hover.r < 0 && hover.c < 0 && mouseDown("left"))

      exitTm += dt/EXTIME; else exitTm = 0;

    if (keyWentDown("escape") || exitTm >= 1)

      clearBoard();

    if (mouseWentDown("left")) {

      Letter *l = get(hover);

      if (l && l->soundsCount && !mute)

        soundPlay( l->sounds[ randomNumber(0, l->soundsCount-1) ], FALSE );

      Track t = findTrack(selected, hover);

      if (t.len) {

        t.tm = 1;

        Cell *ca = &board[selected.r][selected.c];

        Cell *cb = &board[hover.r][hover.c];

        ca->l  = cb->l  = NULL;

        ca->tm = cb->tm = t.tm;

        tracks[tracksCount++] = t;

      }

      if (hover.r == selected.r && hover.c == selected.c)

        selected.r = selected.c = -1;

      else

      if ( !(hover.r < 0 && hover.c < 0) // ignore hint, sound or exit pressing

        && !(hover.r >= ROWS && hover.c >= COLS)

        && !(hover.r < 0 && hover.c >= COLS) )

        selected = hover;

      if (hover.r < 0 && hover.c >= COLS) mute = !mute;

    }

    Letter *hl = mouseDown("right") ? get(hover) : NULL;

    if (keyWentDown("h") || (!hl && mouseWentDown("right")))

      hint();

    if (hover.r >= ROWS && hover.c >= COLS) {

      hl = mouseDown("left") ? get(selected) : NULL;

      if (!hl && mouseWentDown("left")) hint();

    }

    // draw letters

    for(int r = 0; r < ROWS; ++r)

    for(int c = 0; c < COLS; ++c) {

      Cell *cell = &board[r][c];

      if (!cell->g) continue;

      double a = 1;

      if (cell->tm) {

        cell->tm -= dt/RMTIME;

        if (cell->tm <= 0) {

          cell->g = NULL;

          cell->tm = 0;

          continue;

        }

        a = cell->tm;

      }

      saveState();

      noStroke();

      fill(colorByRGBA(1.0, 1.0, 1.0, a));

      if (a == 1 && hl && hl == cell->l               ) fill(colorByRGBA(0.9, 0.9, 0.9, a));

      if (a == 1 && c ==    hover.c && r ==    hover.r) fill(colorByRGBA(0.9, 0.9, 0.9, a));

      if (a == 1 && c == selected.c && r == selected.r) fill(colorByRGBA(0.8, 0.8, 0.8, a));

      rectTextured(cell->g, c*cellWidth, r*cellHeight, cellWidth, cellHeight);

      restoreState();

    }

    // draw tracks

    int j = 0;

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

      Track *t = &tracks[i];

      t->tm -= dt/RMTIME;

      if (t->tm <= 0) { j = i + 1; continue; }

      saveState();

      stroke(colorByRGBA(1, 0, 0, t->tm));

      for(int k = 0; k < t->len; ++k)

        lineTo((t->p[k].c + 0.5)*cellWidth, (t->p[k].r + 0.5)*cellHeight);

      strokePath();

      restoreState();

    }

    tracksCount -= j;

    memmove(tracks, tracks + j, sizeof(*tracks)*tracksCount);

    // draw exiting

    noFill();

    stroke(colorByRGBA(1, 0, 0, exitTm));

    double r = cellHeight/2;

    arc(mx - r, my - r, 2*r, 2*r, 0, 360*exitTm);

  }

  restoreState();

}

int main() {

  windowSetResizable(TRUE);

  windowSetVariableFrameRate();

  windowSetInit(&init);

  windowSetDraw(&draw);

  windowRun();

}