/* This file is part of Eclat.
   Copyright (C) 2012-2014 Sergey Poznyakoff.
 
   Eclat 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, or (at your option)
   any later version.
 
   Eclat 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 Eclat.  If not, see <http://www.gnu.org/licenses/>. */

#ifdef HAVE_GETOPT_H
# include <getopt.h>
#endif

static char *pp_cmd_buffer;
static size_t pp_cmd_bufsize;
static size_t pp_cmd_buflevel;

struct replvar {
	union {
		char **strptr;
		int *intptr;
	} r_pointer;
#define s_ptr r_pointer.strptr
#define i_ptr r_pointer.intptr
	union {
		char *strval;
		int intval;
	} r_value;
#define	s_val r_value.strval
#define i_val r_value.intval
};

int
replace_string_var(void *p)
{
	struct replvar *rv = p;
	*rv->s_ptr = rv->s_val;
	return 0;
}

int
replace_int_var(void *p)
{
	struct replvar *rv = p;
	*rv->i_ptr = rv->i_val;
	return 0;
}

OPTIONS_BEGIN("eclat",
              [<EC2 Command Line Administrator Tool>],
	      [<COMMAND [COMMAND-OPTIONS...]>],
	      [<gnu>],
	      [<nopermute>],
              [<copyright_year=2012, 2013>],
              [<copyright_holder=Sergey Poznyakoff>],[<nopermute>])

GROUP(Selecting program mode)

OPTION(lint,t,,
       [<parse configuration file and exit>])
BEGIN
	lint_mode = 1;
END

OPTION(,E,,
       [<preprocess config and exit>])
BEGIN
	preprocess_only = 1;
END

OPTION(match-commands,m,,
       [<find matching command names>])
BEGIN
	match_command_mode = 1;
END	

OPTION(list-commands,l,FMT,
       [<list commands using the supplied format>])
BEGIN
	listcmd(optarg);
        exit(0);
END

GROUP(Modifiers)

OPTION(config-file,c,FILE,
       [<use FILE instead of the default configuration>])
BEGIN
	conffile = optarg;
END

OPTION(region,,NAME,
       [<set AWS region (availability zone)>])
BEGIN
	struct replvar *rv = grecs_malloc(sizeof(*rv));
	rv->s_ptr = &region_name;
	rv->s_val = optarg;
	add_config_finish_hook(replace_string_var, rv);
END

OPTION(access-file,a,NAME,
       [<set access file>])
BEGIN
	struct replvar *rv = grecs_malloc(sizeof(*rv));
	rv->s_ptr = &access_file_name;
	rv->s_val = optarg;
	add_config_finish_hook(replace_string_var, rv);
END

OPTION(access-key,O,[<STRING>],
       [<set access key to use>])
BEGIN
	access_key = optarg;
END

OPTION(secret-key,W,[<STRING>],
       [<set secret key to use>])
BEGIN
	secret_key = optarg;
END

OPTION(ssl,,,
       [<use SSL (HTTPS) connection>])
BEGIN
	struct replvar *rv = grecs_malloc(sizeof(*rv));
	rv->i_ptr = &use_ssl;
	rv->i_val = 1;
	add_config_finish_hook(replace_int_var, rv);
END	

OPTION(format,H,NAME,
       [<use format NAME for output>])
BEGIN
	format_name_option = optarg;
END

OPTION(format-expression,e,EXPR,
       [<format expression>])
BEGIN
	format_expr_option = optarg;
END	

OPTION(format-file,F,FILE,
       [<use FILE to format the output>])
ALIAS(formfile)       
BEGIN
	format_file_option = optarg;
END	

OPTION(sort,s,,
       [<sort the returned XML tree prior to outputting it>])
BEGIN
	sort_option = 1;
END	

OPTION(yes,Y,,
       [<assume `yes' to all questions>])
BEGIN
	confirm_mode = eclat_confirm_positive;
END

OPTION(no,N,,
       [<assume `no' to all questions>])
BEGIN
	confirm_mode = eclat_confirm_negative;
END

GROUP(Identifier translation)

OPTION(translate,x,,
       [<translate resource IDs>])
BEGIN
	translate_option = 1;
END	

OPTION(no-translate,X,,
       [<disable resource ID translation>])
BEGIN
	translate_option = 0;
END

OPTION(map,M,[<MAPNAME>],
       [<use this map instead of the default one (implies --translate)>])
BEGIN
	custom_map = optarg;
	translate_option = 1;
END

OPTION(test-map,,[<MAPNAME>],
       [<test the translation map; supply IDs as arguments>])
BEGIN
	test_map_name = optarg;
	translate_option = 1;
END	

GROUP(Preprocessor control)

OPTION(include-directory,I,DIR,
       [<add include directory>])
BEGIN
	grecs_preproc_add_include_dir(optarg);
END

OPTION(define,D,SYMBOL[=VALUE],
       [<define a preprocessor symbol>])
BEGIN
	size_t len;
        char *p;

        len = 5;
	for (p = optarg; *p; p++) {
		if (*p == '\\' || *p == '"')
			len++;
		len++;
	}

        if (pp_cmd_buflevel + len + 1 > pp_cmd_bufsize) {
		pp_cmd_bufsize = pp_cmd_buflevel + len + 1;
		pp_cmd_buffer = grecs_realloc(pp_cmd_buffer, pp_cmd_bufsize);
	}
        memcpy(pp_cmd_buffer + pp_cmd_buflevel, " \"-D", 4);
        pp_cmd_buflevel += 4;

	for (p = optarg; *p; p++) {
		if (*p == '\\' || *p == '"')
			pp_cmd_buffer[pp_cmd_buflevel++] = '\\';
		pp_cmd_buffer[pp_cmd_buflevel++] = *p;
	}
	pp_cmd_buffer[pp_cmd_buflevel++] = '"';
	pp_cmd_buffer[pp_cmd_buflevel] = 0;
END

OPTION(preprocessor,,COMMAND,
       [<use COMMAND instead of the default preprocessor>])
BEGIN
	grecs_preprocessor = optarg;
END

OPTION(no-preprocessor,,,
       [<disable preprocessing>])
BEGIN
	grecs_preprocessor = NULL;
END

GROUP(Debugging)

OPTION(dry-run,n,,
       [<do nothing, print almost everything>])
BEGIN
	dry_run_mode = 1;
        parse_debug_level("main.1");
        parse_debug_level("curl.1");
END

OPTION(dump-grammar-trace,,,
       [<dump configuration grammar traces>])
BEGIN
        grecs_gram_trace (1);
END

OPTION(dump-lex-trace,,,
       [<dump lexical analyzer traces>])
BEGIN
        grecs_lex_trace (1);
END

OPTION(debug,d,CAT[.LEVEL],
       [<set debugging level>])
BEGIN
	if (parse_debug_level(optarg)) {
		die(EX_USAGE, "invalid debugging category or level");
	}
END

GROUP([<Additional help>])
OPTION(config-help,,,
       [<show configuration file summary>])
BEGIN
	config_help();
	exit(0);
END

OPTIONS_END

static void
parse_options(int *pargc, char **pargv[])
{
	int index;
	int argc;
	char **argv;
	char *p;

	argc = *pargc;
	argv = *pargv;
	
	p = getenv("ECLAT_OPTIONS");
	if (p) {
		struct wordsplit ws;
		int i, j;
		
		ws.ws_offs = argc;
		if (wordsplit(p, &ws, WRDSF_DEFFLAGS|WRDSF_DOOFFS))
			die(EX_SOFTWARE, "wordsplit failed at \"%s\": %s",
			    p, wordsplit_strerror(&ws));
		memmove(ws.ws_wordv + 1, ws.ws_wordv + ws.ws_offs,
			sizeof(ws.ws_wordv[0])*ws.ws_wordc);
		ws.ws_wordv[0] = argv[0];
		for (i = 1, j = ws.ws_wordc + 1; i < argc; i++, j++)
			ws.ws_wordv[j] = argv[i];
		argc += ws.ws_wordc;
		argv = ws.ws_wordv;
	}
	
        GETOPT(argc, argv, index, exit(EX_USAGE))

	if (pp_cmd_buffer && grecs_preprocessor) {
		char *cmd = grecs_malloc(strlen(grecs_preprocessor) +
					  pp_cmd_buflevel + 1);
		strcpy(cmd, grecs_preprocessor);
		strcat(cmd, pp_cmd_buffer);
		grecs_preprocessor = cmd;
		free(pp_cmd_buffer);
	}
	
	*pargc = argc - index;
	*pargv = argv + index;
}