#include <img.h>
#include <snd.h>

#include <ctype.h>
#include <dirent.h>

#define MAXSIZE       40
#define MAXCOUNT (MAXSIZE*MAXSIZE)
#define VBASE          8 // must be even
#define HBASE         10 // must be even

#define LETTERSRATIO   7
#define MAXLETTERS   256
#define MAXSOUNDS     16
#define RMTIME       1.0
#define EXTIME       2.0
#define SNDRATE    44100


typedef struct {
  Image src;
  XImage *x;
} ImageEx;

typedef struct {
  ImageEx a, b;
} ImagePair;

typedef struct {
  ImagePair glyphs[4];
  int glyphsCount;
  Sound sounds[MAXSOUNDS];
  int soundsCount;
  ImagePair *g[4];
} Letter;

typedef struct {
  int r, c;
} Pos;

typedef struct {
  int len;
  Pos p[4];
} Track;

typedef struct {
  Letter *l;
  ImagePair *g;
} Cell;


int cols = 4;
int rows = 4;
int count = 4*4;

Letter menuLetter;
Letter letters[MAXLETTERS];
int lettersCount;
int baseCellWidth = 1;
int baseCellHeight = 1;
int cellWidth = 1;
int cellHeight = 1;

Cell board[MAXSIZE][MAXSIZE];
Pos hover = { -1, -1 };
Pos selected = { -1, -1 };
Track tracks[MAXCOUNT];
int tracksCount;
int glyphsMask = 0;
int mode;
Letter *hintLetter;
int back;
int mute;
int ox, oy, cw, ch;

ImageEx bgtex;
ImageEx starttex;
ImageEx hinttex;
ImageEx backtex[3];
ImageEx sndtex[3];


void imgExFree(ImageEx *img) {
  if (!img) return;
  if (img->x) XDestroyImage(img->x);
  imgFree(&img->src);
  *img = (ImageEx){};
}


void imgExResample(ImageEx *img, int w, int h) {
  if (!imgValid(img->src) || w <= 0 || h <= 0) return;
  if (img->x && (img->x->width != w || img->x->height != h))
    { XDestroyImage(img->x); img->x = NULL; }
  if (!img->x) {
    Image tmp = imgResample(img->src, w, h);
    imgDivA(tmp);
    img->x = imgToX(&tmp);
  }
}


void imgExDraw(ImageEx *img, int x, int y, int w, int h) {
  imgExResample(img, w, h);
  if (img->x)
    XPutImage(dpy, drw, gc, img->x, 0, 0, x, y, img->x->width, img->x->height);
}


int imgExLoadTga(ImageEx *img, const char *filename) {
  imgExFree(img);
  img->src = imgLoadTga(filename);
  imgMultA(img->src);
  return imgValid(img->src);
}


void imgPairFree(ImagePair *img) {
  if (!img) return;
  imgExFree(&img->a);
  imgExFree(&img->b);
}


void imgPairDraw(ImagePair *img, int mode, int x, int y, int w, int h) {
  imgExResample(mode ? &img->a : &img->b, w, h);
  imgExDraw(mode ? &img->b : &img->a, x, y, w, h);
}


void clearBoard() {
  if (mute != 1) mute = 0;
  mode = 0;
  back = 0;
  hintLetter = NULL;
  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)
      sndFree(&letters[i].sounds[j]);
}


void clearLetters() {
  clearBoard();
  clearSounds();
  for(int i = 0; i < lettersCount; ++i)
    for(int j = 0; j < letters[i].glyphsCount; ++j)
      imgPairFree(&letters[i].glyphs[j]);
  memset(letters, 0, sizeof(letters));
  memset(&menuLetter, 0, sizeof(menuLetter));
  lettersCount = 0;
  cellWidth = cellHeight = 1;
}


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

  Image img = imgLoadTga(filename);
  if (!imgValid(img))
    return 0;
  int ww = img.w/cols/2;
  int hh = img.h/rows/2;
  if (!ww || !hh)
    return LOGERR("loadLetters: image too small (%dx%d): %s", img.w, img.h, filename), imgFree(&img), 0;

  Image imgsel = imgLoadTga(filesel);
  if (!imgValid(imgsel))
    return imgFree(&img), 0;
  int wws = imgsel.w/cols/2;
  int hhs = imgsel.h/rows/2;
  if (!wws || !hhs)
    return LOGERR("loadLetters: image too small (%dx%d): %s", imgsel.w, imgsel.h, filesel), imgFree(&img), imgFree(&imgsel), 0;

  imgMultA(img);
  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) {
      Image sub = imgSub(img, (c*2 + cc)*ww, (r*2 + rr)*hh, ww, hh);
      if (!imgHasPicture(sub))
        { imgFree(&sub); continue; }
      letter->glyphs[ letter->glyphsCount ].a.src = sub;
      letter->glyphs[ letter->glyphsCount ].b.src = imgSub(imgsel, (c*2 + cc)*wws, (r*2 + rr)*hhs, wws, hhs);
      ++letter->glyphsCount;
    }
    if (letter->glyphsCount > menuLetter.glyphsCount) menuLetter = *letter;
    if (letter->glyphsCount > 0) ++letter;
  }
  lettersCount = letter - letters;
  baseCellWidth = wws;
  baseCellHeight = hhs;
  cellWidth = ww;
  cellHeight = hh;
  assert(menuLetter.glyphsCount == 4);

  imgFree(&img);
  return 1;
}


void loadSounds(const char *path) {
  DIR *dir = opendir(path);
  if (!dir) return;
  size_t pl = strlen(path);

  char buf[1024];
  while(1) {
    struct dirent *e = readdir(dir);
    if (!e) break;
    size_t nl = strlen(e->d_name);
    if (nl < 4 || pl + nl + 1 >= sizeof(buf)) continue;

    const char *ex = e->d_name + nl - 4;
    if ( ex[0] != '.'
     || tolower(ex[1]) != 'r'
     || tolower(ex[2]) != 'a'
     || tolower(ex[3]) != 'w' ) continue;

    int index = atoi(e->d_name);
    if (index <= 0 || index > lettersCount) continue;

    Letter *l = &letters[index-1];
    if (l->soundsCount >= MAXSOUNDS) continue;

    sprintf(buf, "%s/%s", path, e->d_name);
    l->sounds[l->soundsCount] = sndLoadRaw(buf, SNDRATE);
    //l->sounds[l->soundsCount] = sndGen(SNDRATE, 100, SNDRATE);
    if (sndValid(l->sounds[l->soundsCount])) ++l->soundsCount;
  }
  closedir(dir);
}


void shuffleLetters(int glyps) {
  for(int i = 0; i < lettersCount; ++i) {
    int j = rand()%(lettersCount - i) + i;
    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;
    ImagePair *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 = rand()%(gc - j) + j;
      if (k != j) { ImagePair *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 = rand()%(4 - j) + j;
      if (k != j) { ImagePair *g = l->g[j]; l->g[j] = l->g[k]; l->g[k] = g; }
      assert(l->g[j]);
    }
  }
}


void calcSize() {
    if (winW*baseCellHeight < baseCellWidth*winH) {
        cols = HBASE; // portrait
        rows = winH*cols*baseCellWidth/(winW*baseCellHeight);
    } else {
        rows = VBASE; // landscape
        cols = winW*rows*baseCellHeight/(winH*baseCellWidth);
    }
    cols -= 4; // place for buttons
    rows -= 2;
    if (rows < 1) rows = 1;
    if (cols < 1) cols = 1;
    if (rows > MAXSIZE) rows = MAXSIZE;
    if (cols > MAXSIZE) cols = MAXSIZE;
    count = rows*cols;
}


void simpleBoard() {
  clearBoard();
  calcSize();
  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) {
  clearBoard();
  calcSize();
  shuffleLetters(glyphsMask);

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

  int maxLetters = count/LETTERSRATIO + 1;
  int lc = lettersCount < maxLetters ? lettersCount : maxLetters;
  for(int i = 0; i < count; ++i) {
    int j = rand()%(count - i) + i;
    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 0; } else
  if (p.c == b.c && p.r > b.r) { for(--p.r; p.r != b.r; --p.r) if (get(p)) return 0; } else
  if (p.r == b.r && p.c < b.c) { for(++p.c; p.c != b.c; ++p.c) if (get(p)) return 0; } else
  if (p.r == b.r && p.c > b.c) { for(--p.c; p.c != b.c; --p.c) if (get(p)) return 0; } else return 0;
  t->p[t->len++] = p;
  return 1;
}


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 1;
  --t->len;

  return 0;
}


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 0;

  //printf("ft3: %d %d -> %d %d\n", p0.r, p0.c, b.r, b.c);
  if (findSubTrack2(t, b, 0)) return 1;

  ++t->len;

  *p = p0;
  for(++p->c; p->c <= cols; ++p->c)
    if (get(*p)) break; else
      if (findSubTrack2(t, b, 0)) return 1;

  *p = p0;
  for(--p->c; p->c >= -1; --p->c)
    if (get(*p)) break; else
      if (findSubTrack2(t, b, 0)) return 1;

  *p = p0;
  for(++p->r; p->r <= rows; ++p->r)
    if (get(*p)) break; else
      if (findSubTrack2(t, b, 1)) return 1;

  *p = p0;
  for(--p->r; p->r >= -1; --p->r)
    if (get(*p)) break; else
      if (findSubTrack2(t, b, 1)) return 1;

  --t->len;
  return 0;
}


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)
        tracks[tracksCount++] = t;
    }
  }

  LOGDBG("hint: tracks count: %d", tracksCount);
  if (!tracksCount) return; // beep

  int i = rand()%tracksCount;
  if (i) tracks[0] = tracks[i];
  tracksCount = 1;
}


int init() {
  sndInit();
  srand(time(NULL));
  imgExLoadTga(&bgtex,      "data/minas.tga");
  imgExLoadTga(&starttex,   "data/start.tga");
  imgExLoadTga(&hinttex,    "data/hint.tga");
  imgExLoadTga(&backtex[0], "data/back.tga");
  imgExLoadTga(&backtex[1], "data/back1.tga");
  imgExLoadTga(&backtex[2], "data/back2.tga");
  imgExLoadTga(&sndtex[0],  "data/sound.tga");
  imgExLoadTga(&sndtex[1],  "data/silence.tga");
  imgExLoadTga(&sndtex[2],  "data/sound2.tga");
  if (!loadLetters("data/letters.tga", "data/letters-sel.tga", 5, 8))
    return LOGERR("init: cannot load letters"), 0;
  loadSounds("data/sounds");
  //simpleBoard();
  return 1;
}


void deinit() {
  clearLetters();
  imgExFree(&bgtex);
  imgExFree(&starttex);
  imgExFree(&hinttex);
  imgExFree(&backtex[0]);
  imgExFree(&backtex[1]);
  imgExFree(&backtex[2]);
  imgExFree(&sndtex[0]);
  imgExFree(&sndtex[1]);
  imgExFree(&sndtex[2]);
  sndDeinit();
}


void resize() { }


void mouseDown(int x, int y) {
  int mc = (x - ox)/cw;
  int mr = (y - oy)/ch;
  if (x < ox) --mc;
  if (y < oy) --mr;

  if (mode == 0) {
    if (!mr && mc >= 0 && mc < 4) {
      glyphsMask ^= 1 << mc;
    } else
    if (mr == 1 && mc >= 1 && mc <= 2) {
      generateBoard(glyphsMask);
    }
  } else {
    if (mc < 0 && mr < 0) {
      if (++back >= 3) clearBoard();
      return;
    } else back = 0;

    hover.r = hover.c = -1;
    hintLetter = NULL;
    tracksCount = 0;
    for(int r = 0; r < rows; ++r)
    for(int c = 0; c < cols; ++c)
      if (!board[r][c].l) board[r][c].g = NULL;

    if (mc >= cols && mr >= rows) {
      hintLetter = get(selected);
      if (!hintLetter) hint();
      selected.r = selected.c = -1;
    } else
    if (mc >= cols && mr < 0) {
      mute = mute == 1 ? 2 : 1;
    } else
    if (mc >= 0 && mr >= 0 && mc < cols && mr < rows) {
      hover.r = mr;
      hover.c = mc;
      Letter *l = get(hover);
      if (l && l->soundsCount > 0 && mute != 1)
        sndPlay(l->sounds[rand() % l->soundsCount]);
      if (!l || (mr == selected.r && mc == selected.c)) {
        selected.r = selected.c = hover.r = hover.c = -1;
      } else
      if (l == get(selected)) {
        Track t = findTrack(selected, hover);
        if (t.len) {
          Cell *ca = &board[selected.r][selected.c];
          Cell *cb = &board[hover.r][hover.c];
          ca->l = cb->l = NULL;
          tracks[tracksCount++] = t;
        } else {
          selected = hover;
        }
      } else {
        selected = hover;
      }
    } else {
      selected.r = selected.c = hover.r = hover.c = -1;
    }
  }
}


void mouseUp() {
  int cnt = 0;
  for(int r = 0; r < rows; ++r)
  for(int c = 0; c < cols; ++c)
    if (!board[r][c].l && board[r][c].g)
      { ++cnt; board[r][c].g = NULL; }
  if (cnt) tracksCount = 0;
}


void draw() {
  if (imgValid(bgtex.src)) {
    if (winW*bgtex.src.h > winH*bgtex.src.w) {
      int h = bgtex.src.h*winW/bgtex.src.w;
      imgExDraw(&bgtex, 0, (winH - h)/2, winW, h);
    } else {
      int w = bgtex.src.w*winH/bgtex.src.h;
      imgExDraw(&bgtex, (winW - w)/2, 0, w, winH);
    }
  }

  if (mode == 0) {
    if (winW*cellHeight*3 < winH*cellWidth*6) {
      cw = winW/6;
      ch = cellHeight*cw/cellWidth;
    } else {
      ch = winH/3;
      cw = cellWidth*ch/cellHeight;
    }
    ox = (winW - cw*4)/2;
    oy = (winH - ch)/2;

    for(int i = 0; i < 4; ++i)
      imgPairDraw(&menuLetter.glyphs[i], !(glyphsMask & (1 << i)), ox + i*cw, oy, cw, ch);
    if (glyphsMask)
      imgExDraw(&starttex, ox + cw, oy + ch, 2*cw, ch);
  } else {
    if (winW*cellHeight*(rows + 2) < winH*cellWidth*(cols + 4)) {
      cw = winW/(cols + 4);
      ch = cellHeight*cw/cellWidth;
    } else {
      ch = winH/(rows + 2);
      cw = cellWidth*ch/cellHeight;
    }
    ox = (winW - cw*cols)/2;
    oy = (winH - ch*rows)/2;

    // draw buttons
    imgExDraw(&backtex[back], ox - 2*cw, oy - ch, 2*cw, ch);
    imgExDraw(&hinttex, ox + cols*cw, oy + rows*ch, 2*cw, ch);
    imgExDraw(&sndtex[mute], ox + cols*cw, oy - ch, 2*cw, ch);
    for(int i = 0; i < 3; ++i) imgExResample(&sndtex[i], cw, ch);

    // draw cells
    for(int r = 0; r < rows; ++r)
    for(int c = 0; c < cols; ++c) {
      Cell *cell = &board[r][c];
      if (!cell->g) continue;
      int hilight = (r == hover.r && c == hover.c)
                 || (r == selected.r && c == selected.c)
                 || (hintLetter && hintLetter == cell->l);
      imgPairDraw(cell->g, hilight, ox + c*cw, oy + r*ch, cw, ch);
    }

    // draw tracks
    int lw = cw/6;
    if (lw < 1) lw = 1;
    XSetForeground(dpy, gc, 0xff0000);
    XSetLineAttributes(dpy, gc, lw, LineSolid, CapRound, JoinRound);
    for(int i = 0; i < tracksCount; ++i) {
      Track *t = &tracks[i];
      XPoint p[4];
      for(int j = 0; j < t->len; ++j) {
        p[j].x = ox + t->p[j].c*cw + cw/2;
        p[j].y = oy + t->p[j].r*ch + ch/2;
      }
      XDrawLines(dpy, drw, gc, p, t->len, CoordModeOrigin);
    }
  }
}