#include "path.h"

#include <unistd.h>
#include <sys/stat.h>



#ifndef APPNAME
#define APPNAME "jigsaw"
#endif

#ifndef SUBDIR
#define SUBDIR "games/" APPNAME
#endif

#ifndef PREFIX
#define PREFIX "/usr"
#endif

#ifndef PATHENV_DATA
#define PATHENV_DATA "JIGSAW_DATA"
#endif

#ifndef PATHENV_SAVE
#define PATHENV_SAVE "JIGSAW_SAVE"
#endif



const char* filename(const char *path) {
  const char *r = path;
  for(const char *c = r; *c; ++c) if (*c == '/' || *c == '\\') r = c+1;
  return r;
}


const char* fileext(const char *path) {
  const char* r = path = filename(path), *c = r;
  for(;*c; ++c) if (*c == '.') r = c;
  return r == path ? c : r;
}


char* filebase(const char *path) {
  const char* c0 = filename(path);
  const char* c1 = fileext(c0);
  char* r = (char*)alloc(c1 - c0 + 1);
  return strncpy(r, c0, c1 - c0);
}


char* filedir(const char *path) {
  const char* c = filename(path);
  while(c > path && (*(c-1) == '/' || *(c-1) == '\\')) --c;
  char* r = (char*)alloc(c - path + 1);
  return strncpy(r, path, c - path);
}




time_t filetime(const char *path) {
  struct stat st = {};
  return stat(path, &st) ? 0 : st.st_mtime;
}


int makeDirectoryRecursive(const char *path) {
  if (directoryExists(path)) return 1;
  char *parent = filedir(path);
  if (*parent) makeDirectoryRecursive(parent);
  free(parent);
  return makeDirectory(path);
}



PathList* mergePaths(PathList a, PathList b) {
  int cnt = 0;
  size_t size = ASIZEOF(PathList);
  for(int i = 0, j = 0; i < a.cnt || j < b.cnt; ++cnt) {
    int r = i < a.cnt && j < b.cnt ? strcmp(filename(a.l[i]), filename(b.l[i]))
          : i < a.cnt ? -1 : 1;
    if (r < 0) { size += strlen(a.l[i++]) + 1; }
          else { size += strlen(b.l[j++]) + 1; i += !r; }
  }
  size += cnt*ASIZEOF(char*);
  
  PathList *pl = alloc(size);
  char **l = (char**)(pl+1);
  char *c = (char*)(l+cnt);
  pl->l = (StrList)l;
  pl->cnt = cnt;
  for(int i = 0, j = 0; i < a.cnt || j < b.cnt; ++cnt) {
    int r = i < a.cnt && j < b.cnt ? strcmp(filename(a.l[i]), filename(b.l[i]))
          : i < a.cnt ? -1 : 1;
    if (r < 0) { *l++ = strcpy(c, a.l[i++]); }
          else { *l++ = strcpy(c, b.l[j++]); i += !r; }
    c += strlen(c) + 1;
  }
  
  return pl;
}


PathList* readDir(const char *path, const char *ext) {
  Directory d = openDirectory(path);
  if (!d) return alloc(sizeof(PathList));
  
  int cnt = directoryGetCount(d);
  size_t size = ASIZEOF(PathList) + cnt*ASIZEOF(char*);
  for(int i = 0; i < cnt; ++i) {
    const char *p = directoryGetFull(d, i);
    if (!fileExists(p) || strcmp(fileext(p), ext)) continue;
    size += strlen(p) + 1;
  }
  
  PathList *pl = alloc(size);
  char **l = (char**)(pl+1);
  char *c = (char*)(l+cnt);
  pl->l = (StrList)l;
  for(int i = 0; i < cnt; ++i) {
    const char *p = directoryGetFull(d, i);
    if (!fileExists(p) || strcmp(fileext(p), ext)) continue;
    l[pl->cnt++] = strcpy(c, p);
    c += strlen(c) + 1;
  }
  
  closeDirectory(d);
  return pl;
}


PathList* readDirs(PathList paths, const char *ext) {
  PathList *a = alloc(sizeof(PathList));
  for(int i = 0; i < paths.cnt; ++i) {
    PathList *b = readDir(paths.l[i], ext);
    PathList *c = mergePaths(*a, *b);
    free(a); free(b); a = c;
  }
  return a;
}


char* findFile(PathList paths, const char *name) {
  for(int i = paths.cnt-1; i >= 0; --i) {
    char *fn = strprintf("%s/%s", paths.l[i], name);
    if (fileExists(fn)) return fn;
    free(fn);
  }
  return NULL;
}



PathList imagePaths() {
  static PathList pl;
  if (pl.l) return pl;
  
  const char *sys = PREFIX "/local/share:" PREFIX "/share";
  const char *xdd = getenv("XDG_DATA_DIRS");
  if (!xdd) xdd = "";
  const char *home = getenv("HOME");
  
  char *paths = home && *home ? strprintf("%s/.local/share:%s:%s", home, xdd, sys)
                              : strprintf("%s:%s", xdd, sys);
  int cnt = 3; // :tail + wd + ud
  for(char* c = paths; *c; ++c) if (*c == ':') ++cnt;
  
  char **l = (char**)alloc(cnt*ASIZEOF(*l));
  pl.l = (StrList)l;
  
  while(pl.cnt < cnt) {
    char* c = strrchr(paths, ':');
    if (c) *c++ = 0; else c = paths;
    if (*c) l[pl.cnt++] = strprintf("%s/%s", c, SUBDIR);
    if (c == paths) break;
  }

  const char *wd = getcwd(NULL, 0);
  const char *ud = getenv(PATHENV_DATA);
  if (wd && *wd) l[pl.cnt++] = strprintf("%s/data/images", wd);
  if (ud && *ud) l[pl.cnt++] = strprintf("%s", ud);
  
  for(int i = 0; i < pl.cnt; ++i) INF("images directory: %s", l[i]);
  return pl;
}


const char* savesPath() {
  static char *path;
  if (path) return path;
  
  if (!path) {
    const char *p = getenv(PATHENV_SAVE);
    if (p && *p) path = strprintf("%s", p);
  }
  if (!path) {
    const char *p = getenv("HOME");
    if (p && *p) path = strprintf("%s/.local/share/%s/saves", p, SUBDIR);
  }
  if (!path) {
    const char *p = getcwd(NULL, 0);
    if (p && *p) path = strprintf("%s/data/saves", p);
  }
  if (!path)
    path = strprintf("./data/saves");

  INF("saves directory: %s", path);
  if (!makeDirectoryRecursive(path))
    WRN("cannot create saves directory: %s", path);
  return path;
}


const char* thumbsPath() {
  static char *path;
  if (!path) {
    path = strprintf("%s/thumbs", savesPath());
    INF("thumbs directory: %s", path);
    if (!makeDirectoryRecursive(path))
      WRN("cannot create thumbs directory: %s", path);
  }
  return path;  
}


const char* settingsFile() {
  static char *path;
  if (!path) {
    path = strprintf("%s/settings.ini", savesPath());
    INF("settings file: %s", path);
  }
  return path;  
}


char* findImage(const char *name) {
  char* fn = strprintf("%s.png", name);
  char* r = findFile(imagePaths(), fn);
  free(fn);
  return r;
}


PathList* imageFiles() { return readDirs(imagePaths(), ".png"); }
PathList* saveFiles() { return readDir(savesPath(), ".puzzle"); }