#include "../../include/package.h"
#include "../../include/error.h"
#include "../../include/pool.h"
#include "../../include/util.h"
#include "../../include/ctx.h"

#include <spawn.h>
#include <wait.h>
#include <archive.h>
#include <archive_entry.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

bool __lm_ctx_save_install(lm_ctx_t *ctx, lm_pkg_t *pkg, char *install_path){
  if(NULL == ctx->data){
    lm_error_set(LM_ERR_CtxDataNULL);
    return false;
  }

  // no need to save empty install script :)
  if(is_empty(install_path))
    return true;

  char script_name[strlen(pkg->data.name)+15];
  char script_dir[strlen(ctx->data)+15];

  sprintf(script_name, "install_%s", pkg->data.name);
  join(script_dir, ctx->data, "scripts");

  if(!mkdir_ifnot(script_dir)){
    lm_error_set(LM_ERR_InstallDirFail);
    return false;
  }

  char dst[sizeof(script_name)+sizeof(script_dir)+10];
  join(dst, script_dir, script_name);

  return copy_file(dst, install_path);
}

bool __lm_ctx_run_install(char *root, char *install_path) {
  // no need to run empty install script :)
  if(is_empty(install_path))
    return true;

  char *args[] = {"/bin/bash", install_path, NULL}, *oldpwd = NULL;
  bool ret = false;
  int status = 0;
  pid_t pid = 0;

  if((oldpwd = getcwd(NULL, 0)) == NULL){
    lm_error_set(LM_ERR_InstallCwdFail);
    goto end;
  }

  if(chdir(root) < 0){
    lm_error_set(LM_ERR_InstallRootChdirFail);
    goto end;
  }

  if (posix_spawn(&pid, "/bin/bash", NULL, NULL, args, NULL) != 0) {
    lm_error_set(LM_ERR_InstallSpawnFail);
    goto end;
  }

  waitpid(pid, &status, 0);

  if(chdir(root) < 0){
    lm_error_set(LM_ERR_InstallBackChdirFail);
    goto end;
  }

  if(status != 0){
    lm_error_set(LM_ERR_InstallStatusFail);
    goto end;
  }

  ret = true;
end:
  free(oldpwd);
  return ret;
}

bool __lm_ctx_extract_files(lm_ctx_t *ctx, lm_pkg_t *pkg, char *files, lm_ctx_install_callback_t callback, void *data){
  struct archive       *reader = NULL, *writer = NULL;
  struct archive_entry *entry = NULL;
  int                   flags = 0, rc = 0;
  char                 *oldpwd = NULL, *entry_path = NULL;
  bool                  ret    = false;
  size_t total = 0, current = 0;
  mode_t type = 0;
  struct stat st;

  if(stat(files, &st) < 0){
    lm_error_set(LM_ERR_ExtractStatFail);
    goto end;
  }

  oldpwd = getcwd(NULL, 0);
  total = st.st_size;

  if (NULL == oldpwd) {
    lm_error_set(LM_ERR_GetCwdFail);
    goto end;
  }

  chdir(ctx->root);

  flags = ARCHIVE_EXTRACT_PERM;
  flags |= ARCHIVE_EXTRACT_UNLINK;

  reader = archive_read_new();
  writer = archive_write_disk_new();

  if (NULL == reader || NULL == writer) {
    lm_error_set(LM_ERR_ArcNewFail);
    goto end;
  }

  archive_write_disk_set_options(writer, flags);
  archive_write_disk_set_standard_lookup(writer);

  archive_read_support_format_tar(reader);
  archive_read_support_filter_gzip(reader);

  if (archive_read_open_filename(reader, files, 1024 * 10) != ARCHIVE_OK) {
    lm_error_set(LM_ERR_ArcOpenFail);
    goto end;
  }

  while ((rc = archive_read_next_header(reader, &entry)) == ARCHIVE_OK) {
    entry_path = (char *)archive_entry_pathname(entry);
    current += archive_entry_size(entry);
    type = archive_entry_filetype(entry);

    if(type == AE_IFREG && !lm_database_files_contains(ctx->db, &pkg->data, entry_path)){
      pdebug(__func__, "archive file not included in the database: %s (%s)", entry_path, pkg->data.name);
      continue;
    }

    rc = archive_write_header(writer, entry);
    if (rc != ARCHIVE_OK) {
      lm_error_set(LM_ERR_ArcWHeaderFail);
      goto end;
    }

    if (!copy_blocks(writer, reader))
      goto end;

    rc = archive_write_finish_entry(writer);
    if (rc != ARCHIVE_OK) {
      lm_error_set(LM_ERR_ArcWEntryFail);
      goto end;
    }

    if(NULL != callback)
      if(!callback(ctx, pkg, entry_path, current, total, data))
        goto end;
  }

  if (rc != ARCHIVE_EOF) {
    lm_error_set(LM_ERR_ArcNextHeaderFail);
    goto end;
  }

  ret = true;

end:
  if (NULL != reader) {
    archive_read_close(reader);
    archive_read_free(reader);
  }

  if (NULL != writer) {
    archive_write_close(writer);
    archive_write_free(writer);
  }

  if (NULL != oldpwd) {
    chdir(oldpwd);
    free(oldpwd);
  }

  return ret;
}

bool lm_ctx_install(lm_ctx_t *ctx, lm_pkg_t *pkg, bool run_install, lm_ctx_install_callback_t callback, void *data) { 
  if(NULL == ctx->temp || NULL == pkg){
    lm_error_set(LM_ERR_CtxTempNULL);
    return false;
  }

  if(NULL == ctx->root){
    lm_error_set(LM_ERR_CtxRootNULL);
    return false;
  }

  if(!mkdir_ifnot(ctx->temp)){
    lm_error_set(LM_ERR_CtxTempFailMkdir);
    return false;
  }

  if(!lm_ctx_database_init(ctx))
    return false; // error set by function

  if(lm_ctx_database_is_installed(ctx, pkg->data.name, NULL)){
    lm_error_set(LM_ERR_PkgAlreadyInstalled);
    return false;
  }

  if(lm_package_path_is_empty(pkg)){
    lm_error_set(LM_ERR_PkgPathsEmpty);
    return false;
  }

  if(!extract_archive(ctx->temp, pkg->archive))
    return false; // error set by function
 
  size_t bufsize = strlen(ctx->temp) + 25;
  char data_file[bufsize], changes_file[bufsize], hashes_file[bufsize];
  char install_file[bufsize], files_archive[bufsize];
  lm_pkg_t temp;

  lm_package_init(&temp);

  join(data_file, ctx->temp, "DATA");
  join(hashes_file, ctx->temp, "HASHES");
  join(changes_file, ctx->temp, "CHANGES");
  join(install_file, ctx->temp, "INSTALL");
  join(files_archive, ctx->temp, "files.tar.gz");

  if(!exists(data_file) || !is_file(data_file) ||
     !exists(hashes_file) || !is_file(hashes_file) ||
     !exists(changes_file) || !is_file(changes_file) ||
     !exists(install_file) || !is_file(install_file) ||
     !exists(files_archive) || !is_file(files_archive)){
    lm_error_set(LM_ERR_PkgBadArchive);
    return false;
  }
  
  if(!lm_package_data_load(&temp.data, data_file))
    return false; // error set by function

  if(!lm_package_is_same(&temp, pkg)){
    pdebug(__func__, "DATA file does not match with stored %s data", pkg->data.name);
    lm_error_set(LM_ERR_PkgDataNotMatch);
    return false;
  }

  if(!lm_database_changes_update(ctx->db, &pkg->data, changes_file)){
    char *suberr = lm_strerror_dup();
    pdebug(__func__, "failed to update changes file for %s: %s", pkg->data.name, suberr);
    lm_error_set(LM_ERR_PkgChangesUpdateFail, suberr);
    return false;
  }
  
  char *line = NULL, *hash = NULL, *file = NULL;
  ssize_t line_len = 0, file_len = 0;
  FILE *hashes = NULL;
  bool ret = false;

  if((hashes = fopen(hashes_file, "r")) == NULL){
    pdebug(__func__, "failed to open hash file for %s", pkg->data.name);
    lm_error_set(LM_ERR_PkgHashesOpenFail);
    return false;
  }

  while((line_len = getline(&line, (size_t*)&line_len, hashes)) > 0){
    if(NULL == line)
      goto next;

    if(HASH_LEN+2 >= line_len)
      goto next;

    line[HASH_LEN] = 0;
    hash = line;
    
    file = line+HASH_LEN+2;
    file_len = strlen(file);
    file[file_len-1] = 0;

    if(file[0] == '.')
      file++;

    if(file_len >= 2 && file[0] == '/')
      file++;

    pdebug(__func__, "(%lu) %s => %s", line_len, file, hash);

    if(!lm_database_files_add(ctx->db, &pkg->data, file, hash)){
      char *suberr = lm_strerror_dup();
      pdebug(__func__, "failed to add file to the database for %s: %s", pkg->data.name, suberr);
      lm_error_set(LM_ERR_PkgFilesAddFail, file, suberr);
      free(suberr);
      goto end;
    }

  next:
    free(line);
    line = NULL;
    line_len = 0;
  }

  if(!__lm_ctx_extract_files(ctx, pkg, files_archive, callback, data)){
    char *suberr = lm_strerror_dup();
    pdebug(__func__, "failed to extract the files archive for %s: %s", pkg->data.name, suberr);
    lm_error_set(LM_ERR_PkgExtractFilesFail, suberr);
    free(suberr);
    goto end;
  }

  if(!lm_database_entry_add(ctx->db, &pkg->data)){
    char *suberr = lm_strerror_dup();
    pdebug(__func__, "failed to add %s to the database: %s", pkg->data.name, lm_strerror());
    lm_error_set(LM_ERR_PkgDatabaseAddFail, suberr);
    free(suberr);
    goto end;
  }

  if(run_install && !__lm_ctx_run_install(ctx->root, install_file)){
    char *suberr = lm_strerror_dup();
    pdebug(__func__, "failed to run install script: %s", lm_strerror());
    lm_error_set(LM_ERR_InstallRunFail, suberr);
    free(suberr);
    goto end;
  }

  if(!run_install && !__lm_ctx_save_install(ctx, pkg, install_file)){
    char *suberr = lm_strerror_dup();
    pdebug(__func__, "failed to save install script: %s", lm_strerror());
    lm_error_set(LM_ERR_InstallSaveFail, suberr);
    free(suberr);
    goto end;
  }

  ret = true;
end:
  free(line);

  if(NULL != hashes)
    fclose(hashes);

  if(!ret){
    lm_database_entry_del(ctx->db, &pkg->data);
    lm_database_changes_del(ctx->db, &pkg->data);
    lm_database_files_del(ctx->db, &pkg->data);
  }

  unlink(pkg->archive);
  unlink(pkg->signature);
  return ret;
}