// clang-format off

/*

 * matt | MatterLinux package manager 
 * MatterLinux 2023-2024 (https://matterlinux.xyz)

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

// clang-format on

#include <errno.h>
#include <libmp/all.h>
#include <locale.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#include "args.h"
#include "cmd.h"
#include "config.h"
#include "intl.h"
#include "lock.h"
#include "log.h"
#include "util.h"

lm_ctx_t ctx;

void handler(int sig) {
  unlock(&ctx);
  printf("\e[?25h");
  if (SIGSEGV == sig)
    error(_("Received a segfault"));
  else
    printf("\n"); // print a newline to not the break shell prompt on SIGINT
  exit(1);
}

int main(int argc, char *argv[], char *envp[]) {
  signal(SIGSEGV, handler);
  signal(SIGINT, handler);

  setbuf(stdout, NULL);
  setlocale(LC_ALL, "");
  textdomain("matt");

  cmd_t commands[] = {
      {.name = "info",    .desc = "show information about a single package", .root = false, .func = cmd_info   },
      {.name = "list",    .desc = "list all the installed packages",         .root = false, .func = cmd_list   },
      {.name = "sync",    .desc = "update the pool info and package lists",  .root = true,  .func = cmd_sync   },
      {.name = "install", .desc = "install package(s) from remote pools",    .root = true,  .func = cmd_install},
      {.name = "remove",  .desc = "remove installed package(s)",             .root = true,  .func = cmd_remove },
      {.name = "update",  .desc = "update installed package(s)",             .root = true,  .func = cmd_update },
  };

  char      *full_datadir = NULL, *full_tmpdir = NULL, *full_pooldir = NULL;
  bool       ret = false, r = false, use_root = false;
  char      *config_file = NULL, *root_dir = NULL;
  cmd_func_t cmd  = NULL;
  args_t    *args = NULL;
  config_t   config;

  set_env(envp);
  lm_ctx_init(&ctx);
  args = args_parse(argc, argv);
  args_register(args, "config");
  args_register(args, "root");
  args_register(args, "help");

  if ((config_file = args_get_string(args, "config")) == NULL)
    config_file = "/etc/matt/config.ini";

  if (!config_load(&ctx, &config, config_file))
    goto end;

  for (int i = 0; i < sizeof(commands) / sizeof(cmd_t); i++) {
    if (!eq(commands[i].name, args->list[0].value))
      continue;

    use_root = commands[i].root;

    if (!use_root)
      goto skip_lock;

    switch (lock(&ctx)) {
    case ALREADY_LOCKED:
      error(_("Failed to lock, matt is already running"));
      goto end;

    case LOCK_ERROR:
      error(_("Failed to lock, are you root?"));
      goto end;

    default:
      break;
    }

  skip_lock:
    cmd = commands[i].func;
    break;
  }

  if (args->count <= 0 || args->list[0].name != NULL)
    goto help;

  if ((root_dir = args_get_string(args, "root")) == NULL)
    root_dir = "/";

  full_datadir = join_alloc(root_dir, config.datadir);
  full_tmpdir  = join_alloc(root_dir, config.tmpdir);

  if (!lm_ctx_new(&ctx, use_root ? root_dir : NULL, full_tmpdir, full_datadir)) {
    switch (lm_error()) {
    case LM_ERR_CtxRootFail:
      error(_("Failed to access the root directory, are you running as root?"));
      break;

    case LM_ERR_CtxDataFail:
      error(_("Failed to access the data directory (" FG_BOLD "%s" FG_RESET ")"), full_datadir);
      break;

    case LM_ERR_CtxTempFail:
      error(_("Failed to access the temp directory (" FG_BOLD "%s" FG_RESET ")"), full_tmpdir);
      break;

    default:
      error(_("Failed to initialize libmp context: %s"), lm_strerror());
      break;
    }

    goto end;
  }

  pool_config_t *pool = config.pools;
  full_pooldir        = join_alloc(full_datadir, "pools");

  if (mkdir(full_pooldir, 0755) < 0 && errno != EEXIST) {
    error(_("Failed to create the pools directory (" FG_BOLD "%s" FG_RESET "): %s"), pool->name, strerror(errno));
    goto end;
  }

  while (NULL != pool) {
    char *pd = join_alloc(full_pooldir, pool->name);

    r = lm_ctx_pool_add(&ctx, pool->name, pool->url, pd);

    if (!r) {
      error(_("Failed to add pool " FG_BOLD "%s" FG_RESET " to the list: %s"), pool->name, lm_strerror());
      goto end;
    }

    free(pd);
    pool = pool->next;
  }

  if (NULL != cmd) {
    ret = cmd(&ctx, &config, args);
    unlock(&ctx);
    goto end;
  }

  error(_("Command not found: " FG_BOLD "%s"), args->list[0].value);
  info(_("Displaying help information"));

help:
  info(_("MatterLinux package manager %s (libmp %s)"), VERSION, LM_VERSION);
  info(_("Usage: " FG_BOLD "%s [command] <options> <arguments>"), argv[0]);
  printf("\n");
  info(_("Here is a list of available commands:"));

  for (int i = 0; i < sizeof(commands) / sizeof(cmd_t); i++)
    printf("    " FG_BOLD "%s" FG_RESET ":\t %s\n", commands[i].name, commands[i].desc);
  printf("\n");

  info(_("To list different options, use commands with " FG_BOLD "--help" FG_RESET " option"));
  info(_("Here is a list of available global options:"));

  printf(
      _("    " FG_BOLD "--config" FG_RESET ":\t specify the configuration file (default is /etc/matt/config.ini)\n"));
  printf(_("    " FG_BOLD "--root" FG_RESET ":\t specify a custom root directory (default is /)\n\n"));

  info(_("Licensed under GPLv3, see https://www.gnu.org/licenses/ for more information"));

  ret = true;
  goto end;

end:
  free(full_pooldir);
  free(full_datadir);
  free(full_tmpdir);

  args_free(args);
  lm_ctx_free(&ctx);
  config_free(&config);

  return ret ? EXIT_SUCCESS : EXIT_FAILURE;
}