#include <ini.h>
#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "error.h"
#include "intl.h"
#include "log.h"
#include "util.h"

bool target_is_valid(target_t *target) {
  if (NULL == target->name) {
    error_set(_("Configuration target is missing a name"));
    return false;
  }

  if (NULL == target->dst) {
    error_set(_("Configuration target %s does not have \"dst\" field"), target->name);
    return false;
  }

  if (NULL == target->src) {
    error_set(_("Configuration target %s does not have \"src\" field"), target->name);
    return false;
  }

  return true;
}

bool config_add_target(config_t *config, char *name) {
  target_t *new = malloc(sizeof(target_t));
  clist_init(&new->requires);

  new->next = NULL;
  new->name = name;
  new->desc = NULL;
  new->dst  = NULL;
  new->src  = NULL;

  if (NULL == config->t_first || NULL == config->t_last) {
    config->t_first = new;
    config->t_last  = new;
    return true;
  }

  config->t_last->next = new;
  config->t_last       = new;
  return true;
}

bool config_is_valid(config_t *config) {
  if (NULL == config->name) {
    error_set(_("Configuration does not have a name field"));
    return false;
  }

  if (NULL == config->author) {
    error_set(_("Configuration does not have an author field"));
    return false;
  }

  if (NULL == config->t_last) {
    error_set(_("Configuration does not have any targets"));
    return false;
  }

  return true;
}

int config_handler(void *data, const char *section, const char *key, const char *value) {
#define MATCH(s, k) eq((char *)section, s) && eq((char *)key, k)
#define MATCHKEY(k) eq((char *)key, k)

  if (strlen(section) == 0)
    return 1;

  config_t *config = data;

  if (MATCH("details", "name")) {
    config->name = strdup(value);
    return 1;
  } else if (MATCH("details", "author")) {
    config->author = strdup(value);
    return 1;
  } else if (MATCH("details", "keywords")) {
    clist_from_str(&config->keywords, (char *)value);
    return 1;
  }

  if (NULL == config->t_last || (NULL != config->t_last->name && !eq(config->t_last->name, (char *)section))) {
    if (NULL != config->t_last) {
      if (!target_is_valid(config->t_last)) {
        errno = ConfigInvalid;
        debug("invalid %s %s", config->t_last->name, section);
        return 0;
      }
    }

    debug("adding new target => %s", section);
    config_add_target(config, strdup(section));
  }

  if (MATCHKEY("desc")) {
    config->t_last->desc = strdup(value);
    return 1;
  } else if (MATCHKEY("dst")) {
    config->t_last->dst = strdup(value);
    return 1;
  } else if (MATCHKEY("src")) {
    config->t_last->dst = strdup(value);
    return 1;
  } else if (MATCHKEY("requires")) {
    clist_from_str(&config->t_last->requires, strdup(value));
    return 1;
  }

  error_set(_("Key %s is unknown"), key);
  errno = ConfigUnknown;
  return 0;
}

void target_free(target_t *target) {
  free(target->name);
  free(target->desc);
  free(target->dst);
  free(target->src);
  clist_free(&target->requires);
  free(target);
}

void config_free(config_t *config) {
  free(config->name);
  free(config->author);

  target_t *cur = config->t_first, *prev = NULL;
  while (cur != NULL) {
    prev = cur;
    cur  = cur->next;
    target_free(prev);
  }

  clist_free(&config->keywords);
}

bool config_load(config_t *config, char *path) {
  if (!exists(path) || is_dir(path)) {
    errno = ConfigNotFound;
    return false;
  }

  config->name    = NULL;
  config->author  = NULL;
  config->t_first = NULL;
  config->t_last  = NULL;
  clist_init(&config->keywords);

  if (ini_parse(path, config_handler, config) < 0) {
    config_free(config);
    if (errno != ConfigUnknown && errno != ConfigInvalid) {
      error_set(_("Failed to parse configuration file"));
      errno = ConfigParseFail;
    }
    return false;
  }

  if (!config_is_valid(config)) {
    errno = ConfigInvalid;
    config_free(config);
    return false;
  }

  return true;
}