//

// clib-cache.c

//

// Copyright (c) 2016-2020 clib authors

// MIT licensed

//

#include "clib-cache.h"

#include "copy/copy.h"

#include "fs/fs.h"

#include "rimraf/rimraf.h"

#include <limits.h>

#include <mkdirp/mkdirp.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#define GET_PKG_CACHE(a, n, v)                                                 \

  char pkg_cache[BUFSIZ];                                                      \

  package_cache_path(pkg_cache, a, n, v);

#define GET_JSON_CACHE(a, n, v)                                                \

  char json_cache[BUFSIZ];                                                     \

  json_cache_path(json_cache, a, n, v);

#ifdef _WIN32

#define BASE_DIR getenv("AppData")

#else

#define BASE_DIR getenv("HOME")

#endif

#define BASE_CACHE_PATTERN "%s/.cache/clib"

#define PKG_CACHE_PATTERN "%s/%s_%s_%s"

#define JSON_CACHE_PATTERN "%s/%s_%s_%s.json"

/** Portable PATH_MAX ? */

static char package_cache_dir[BUFSIZ];

static char search_cache[BUFSIZ];

static char json_cache_dir[BUFSIZ];

static char meta_cache_dir[BUFSIZ];

static time_t expiration;

static void json_cache_path(char *pkg_cache, char *author, char *name,

                            char *version) {

  sprintf(pkg_cache, JSON_CACHE_PATTERN, json_cache_dir, author, name, version);

}

static void package_cache_path(char *json_cache, char *author, char *name,

                               char *version) {

  sprintf(json_cache, PKG_CACHE_PATTERN, package_cache_dir, author, name,

          version);

}

const char *clib_cache_dir(void) { return package_cache_dir; }

static int check_dir(char *dir) {

  if (0 != (fs_exists(dir))) {

    return mkdirp(dir, 0700);

  }

  return 0;

}

int clib_cache_meta_init(void) {

  sprintf(meta_cache_dir, BASE_CACHE_PATTERN "/meta", BASE_DIR);

  if (0 != check_dir(meta_cache_dir)) {

    return -1;

  }

  return 0;

}

const char *clib_cache_meta_dir(void) { return meta_cache_dir; }

int clib_cache_init(time_t exp) {

  expiration = exp;

  sprintf(package_cache_dir, BASE_CACHE_PATTERN "/packages", BASE_DIR);

  sprintf(json_cache_dir, BASE_CACHE_PATTERN "/json", BASE_DIR);

  sprintf(search_cache, BASE_CACHE_PATTERN "/search.html", BASE_DIR);

  if (0 != check_dir(package_cache_dir)) {

    return -1;

  }

  if (0 != check_dir(json_cache_dir)) {

    return -1;

  }

  return 0;

}

static int is_expired(char *cache) {

  fs_stats *stat = fs_stat(cache);

  if (!stat) {

    return -1;

  }

  time_t modified = stat->st_mtime;

  time_t now = time(NULL);

  free(stat);

  return now - modified >= expiration;

}

int clib_cache_has_json(char *author, char *name, char *version) {

  GET_JSON_CACHE(author, name, version);

  return 0 == fs_exists(json_cache) && !is_expired(json_cache);

}

char *clib_cache_read_json(char *author, char *name, char *version) {

  GET_JSON_CACHE(author, name, version);

  if (is_expired(json_cache)) {

    return NULL;

  }

  return fs_read(json_cache);

}

int clib_cache_save_json(char *author, char *name, char *version,

                         char *content) {

  GET_JSON_CACHE(author, name, version);

  return fs_write(json_cache, content);

}

int clib_cache_delete_json(char *author, char *name, char *version) {

  GET_JSON_CACHE(author, name, version);

  return unlink(json_cache);

}

int clib_cache_has_search(void) {

  return 0 == fs_exists(search_cache) && !is_expired(search_cache);

}

char *clib_cache_read_search(void) {

  if (!clib_cache_has_search()) {

    return NULL;

  }

  return fs_read(search_cache);

}

int clib_cache_save_search(char *content) {

  return fs_write(search_cache, content);

}

int clib_cache_delete_search(void) { return unlink(search_cache); }

int clib_cache_has_package(char *author, char *name, char *version) {

  GET_PKG_CACHE(author, name, version);

  return 0 == fs_exists(pkg_cache) && !is_expired(pkg_cache);

}

int clib_cache_is_expired_package(char *author, char *name, char *version) {

  GET_PKG_CACHE(author, name, version);

  return is_expired(pkg_cache);

}

int clib_cache_save_package(char *author, char *name, char *version,

                            char *pkg_dir) {

  GET_PKG_CACHE(author, name, version);

  if (0 == fs_exists(pkg_cache)) {

    rimraf(pkg_cache);

  }

  return copy_dir(pkg_dir, pkg_cache);

}

int clib_cache_load_package(char *author, char *name, char *version,

                            char *target_dir) {

  GET_PKG_CACHE(author, name, version);

  if (-1 == fs_exists(pkg_cache)) {

    return -1;

  }

  if (is_expired(pkg_cache)) {

    rimraf(pkg_cache);

    return -2;

  }

  return copy_dir(pkg_cache, target_dir);

}

int clib_cache_delete_package(char *author, char *name, char *version) {

  GET_PKG_CACHE(author, name, version);

  return rimraf(pkg_cache);

}