/*
  Copyright 2008 Nathan Phillip Brink, Ethan Zonca

  This file is a part of DistRen.

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

  DistRen 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 Affero General Public License for more details.

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

/* The purpose of this file is to... */

#include "options.h"

#include <confuse.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

struct options_common_data 
{
  cfg_t *cfg;
};


int options_init(int argc, char *argv[], cfg_t **mycfg, cfg_opt_t *myopts, char *myname, struct options_common **allopts)
{
  char *configfile;

  size_t i;

  /* For those of you who don't know, the following is an example of concatenation of constant strings by the C compiler. Now, that doesn't mean you can do run-time string concatenation ;-) 
   strdup is because someday configfile will be customizable via argv[]
   */

  i = strlen(SYSCONFDIR "/distren.conf") + strlen(myname) + 1;
  configfile = malloc(i);
  if(!configfile)
    {
      perror("malloc");
      return 1;
    }
  strncpy(configfile, SYSCONFDIR "/distren", strlen(SYSCONFDIR "/distren") + 1);
  strcat(configfile, myname);
  strcat(configfile, ".conf");
  
  *allopts = malloc(sizeof(struct options_common));
  if(!*allopts)
    {
      perror("malloc");
      free(configfile);
      return 1;
    }
  memset(*allopts, '\0', sizeof(struct options_common));
  
  (*allopts)->data = malloc(sizeof(struct options_common_data));
  if(!(*allopts)->data)
    {
      perror("malloc");
      free(configfile);
      free(*allopts);
      return 1;
    }
  memset((*allopts)->data, '\0', sizeof(struct options_common_data));
  
  /* Conf File Parser */
  cfg_opt_t common_opts[] =
    {
      CFG_END()
    };
  
  /*
    In these arrays, I should replace NULL with a pointer to a string in the struct which should hold the result of confuse processing an option. This is partially because confuse will not free the values it parses.
   */
  cfg_opt_t server_opts[] = 
    {
      CFG_STR("username", NULL, CFGF_NONE),
      CFG_STR("hostname", NULL, CFGF_NONE),
      CFG_STR("method", "ssh", CFGF_NONE),
      CFG_STR_LIST("types", NULL, CFGF_NONE),
      CFG_END()
    };

  cfg_opt_t opts[] =
    {
      CFG_SEC("common",
	      common_opts,
	      CFGF_NONE),
      CFG_SEC("server",
	      server_opts,
	      CFGF_MULTI | CFGF_TITLE),
      CFG_SEC(myname,
	      myopts,
	      0),
      CFG_FUNC("include",
	       &cfg_include),
      CFG_END()
    };



  (*allopts)->data->cfg = cfg_init(opts, 0);
  switch(cfg_parse((*allopts)->data->cfg, configfile))
    {
    default:
      fprintf(stderr, "cfg_parse returned an unknown error code\n");
    case CFG_FILE_ERROR:
      cfg_error((*allopts)->data->cfg, "Couldn't open file ``%s''\n", configfile);
      /* no break; on purpose */

    case CFG_PARSE_ERROR:
      
      free((*allopts)->data);
      free(*allopts);
      free(configfile);
      
      return 1;
      
    case CFG_SUCCESS:
      break;
    }
  
  free(configfile);
  
  *mycfg = cfg_getsec((*allopts)->data->cfg, myname);

  return 0;
}

int options_free(struct options_common *opts)
{
  /* free the other common_options struct's members */

  cfg_free(opts->data->cfg);

  free(opts->data);
  free(opts);
  
  return 0;
}