/* This file is part of cfpeek  -*- c -*-
   Copyright (C) 2011-2012, 2015 Sergey Poznyakoff

   Cfpeek 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.

   Cfpeek 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 cfpeek.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#endif
#include <unistd.h>
#include "grecs/gitid.h"

static struct grecs_txtacc *pp_cmd_acc;
char *program_name;

#define PREPROC_NOT_SET 0
#define PREPROC_SET     1
#define PREPROC_DEFAULT 2
static int preproc_settings = PREPROC_NOT_SET;

#define CFPEEK_NODE_FLAG_DEFAULT \
	(GRECS_NODE_FLAG_PATH|GRECS_NODE_FLAG_VALUE|GRECS_NODE_FLAG_DESCEND)

static int flags_on, flags_off;

struct format_flag {
	char *name;
	char *arg;
	char *descr;
	int flag;
	void (*handler)(const char *);
};

static void
set_parent_option(const char *str)
{
	struct locate_instr *instr = new_locate_instr();
	instr->cmd = locate_parent;
	instr->v.s = grecs_strdup(str);
}

static void
set_child_option(const char *str)
{
	struct locate_instr *instr = new_locate_instr();
	instr->cmd = locate_child;
	instr->v.s = grecs_strdup(str);
}

static void
set_sibling_option(const char *str)
{
	struct locate_instr *instr = new_locate_instr();
	instr->cmd = locate_sibling;
	instr->v.s = grecs_strdup(str);
}

static void
set_up_option(const char *str)
{
	struct locate_instr *instr = new_locate_instr();
	instr->cmd = locate_up;
	instr->v.n = atoi(str);
}

static void
set_down_option(const char *str)
{
	struct locate_instr *instr = new_locate_instr();
	instr->cmd = locate_down;
	instr->v.n = atoi(str);
}

static void
set_delim_option(const char *str)
{
	flags_on |= *str & 0xff;
}

struct format_flag format_flag_table[] = {
	{ "parent", "NAME", "print the parent node with the given NAME",
	  0, set_parent_option },
	{ "child", "NAME", "print the child node with the given NAME",
	  0, set_child_option },
	{ "up", "NUMBER", "ascend NUMBER of nodes",
	  0, set_up_option },
	{ "down", "NUMBER", "descend NUMBER of nodes",
	  0, set_down_option },
	{ "sibling",
	  "NAME", "locate a sibling with the given NAME and print it",
	  0, set_sibling_option },
	{ "delim", "CHAR", "set path component delimiter",
	  0, set_delim_option },
	{ "locus", NULL, "print locations",
	  GRECS_NODE_FLAG_LOCUS },
	{ "path", NULL, "print paths",
	  GRECS_NODE_FLAG_PATH },
	{ "value", NULL, "print values",
	  GRECS_NODE_FLAG_VALUE },
	{ "quote", NULL, "always quote values",
	  GRECS_NODE_FLAG_QUOTE },
	{ "never-quote", NULL, "never quote values",
	  GRECS_NODE_FLAG_NOQUOTE },
	{ "quote-hex", NULL, "show unprintable characters as hex",
	  GRECS_NODE_FLAG_QUOTE_HEX },
	{ "descend", NULL, "descend into subnodes",
	  GRECS_NODE_FLAG_DESCEND },
	{ "default", NULL, "set default options",
	  CFPEEK_NODE_FLAG_DEFAULT },
	{ NULL }
};

static void
flags_help(FILE *stream)
{
	struct format_flag *fp;

	fprintf(stream, "[*] FLAGS is a comma-separated list of the following:\n");

	for (fp = format_flag_table; fp->name; fp++) {
		int n;
		fprintf(stream, "  ");
		if (fp->arg)
			n = fprintf(stream, "%s=%s", fp->name, fp->arg);
		else
			n = fprintf(stream, "[no]%s", fp->name);
		if (n < 24)
			n = 24 - n;
		else
			n = 2;
		fprintf(stream, "%*s%s\n", n, "", fp->descr);
	}
	fputc('\n', stream);
}

static const char *
cmpasgn(const char *a, const char *b)
{
	for (; *a && *b; a++, b++)  {
		if (*a != *b)
			return NULL;
	}
	if (*a == 0 && *b == '=')
		return b+1;

	return NULL;
}

static void
set_flag(const char *str)
{
	struct format_flag *fp;

	for (fp = format_flag_table; fp->name; fp++) {
		if (fp->arg) {
			const char *arg = cmpasgn(fp->name, str);
			if (arg) {
				fp->handler(arg);
				return;
			}
		} else if (strcmp(str, fp->name) == 0) {
			if (fp->handler)
				fp->handler(str);
			else
				flags_on |= fp->flag;
			return;
		} else if (strncmp(str, "no", 2) == 0 &&
			   strcmp(str + 2, fp->name) == 0) {
			if (fp->handler)
				fp->handler(str);
			else
				flags_off |= fp->flag;
			return;
		}
	}
	grecs_error(NULL, 0, "unknown option: %s", str);
}

OPTIONS_BEGIN("cfpeek",
              [<Get variables from a configuration file>],
	      [<FILE [PATH...]>],
	      [<gnu>],
              [<copyright_year=2011-2018>],
              [<copyright_holder=Sergey Poznyakoff>])

GROUP(Output control)

OPTION(format,H,[<FLAGS>],
       [<set output format flags [*]>])
BEGIN
        int i;
        struct wordsplit ws;
	ws.ws_delim = ",";
	if (wordsplit(optarg, &ws,
		      WRDSF_DELIM|WRDSF_SQUEEZE_DELIMS|
		      WRDSF_NOVAR|WRDSF_NOCMD|WRDSF_SHOWERR))
		exit(EX_SOFTWARE);
	for (i = 0; i < ws.ws_wordc; i++) {
		set_flag(ws.ws_wordv[i]);
	}
	wordsplit_free(&ws);
END

OPTION(quiet,q,,
       [<suppress error diagnostics>])
BEGIN
	quiet_option++;
END

GROUP(Modifiers)

OPTION(parser,p,[<GRECS|META1|BIND|GIT|PATH>],
       [<set parser type>])
BEGIN
	if (strcasecmp(optarg, "GRECS") == 0) {
		grecs_parser_fun = grecs_grecs_parser;
		if (preproc_settings == PREPROC_NOT_SET)
			preproc_settings = PREPROC_DEFAULT;
	} else if (strcasecmp(optarg, "META1") == 0)
		grecs_parser_fun = grecs_meta1_parser;
	else if (strcasecmp(optarg, "BIND") == 0)
		grecs_parser_fun = grecs_bind_parser;
	else if (strcasecmp(optarg, "DHCPD") == 0)
		grecs_parser_fun = grecs_dhcpd_parser;
	else if (strcasecmp(optarg, "GIT") == 0)
		grecs_parser_fun = grecs_git_parser;
	else if (strcasecmp(optarg, "PATH") == 0)
		grecs_parser_fun = grecs_path_parser;
	else {
		grecs_error(NULL, 0, "unsupported parser type");
		exit(EX_USAGE);
	}
END			 

OPTION(literal,L,,
       [<use literal matching>])
BEGIN
	mode = MODE_LITERAL;
END
	
OPTION(reduce,r,,
       [<reduce the tree>])
BEGIN
	reduce_option = 1;
END

OPTION(sort,S,,
       [<sort parse tree lexicografically>])
BEGIN
       sort_option = 1;
END
       
OPTION(matches,m,NUMBER,
       [<output at most NUMBER matches>])
BEGIN
	max_matches = atoi(optarg);
END

OPTION(set,s,PATH=VAL,
       [<set a keyword>])
BEGIN
        struct wordsplit ws;

	ws.ws_delim = "=";
	if (wordsplit(optarg, &ws, WRDSF_NOVAR | WRDSF_NOCMD |
                                   WRDSF_QUOTE | WRDSF_CESCAPES	|
				   WRDSF_DELIM)) {
	     grecs_error(NULL, 0, "cannot split string: %s",
	                 wordsplit_strerror(&ws));
	     exit(EX_SOFTWARE);
	}
        if (ws.ws_wordc != 2) {
                grecs_error(NULL, 0, "set: invalid syntax");
		exit(EX_USAGE);
	}
	OPTNODE(ws.ws_wordv[0], ws.ws_wordv[1]);
        wordsplit_free(&ws);
END

GROUP(Scripting)

OPTION(lang,l,NAME,
       [<select scripting language to use>])
BEGIN
	script_select(optarg);
END
	
OPTION(file,f,FILE,
       [<load the script FILE>])
BEGIN
	script_file = optarg;
END

OPTION(expression,e,EXPR,
       [<apply this expression to each node found>])
BEGIN
	script_expr = optarg;
END

OPTION(init,i,EXPR,
       [<initial setup expession>])
BEGIN
	script_init_expr = optarg;
END

OPTION(done,d,EXPR,
       [<final cleanup expession>])
BEGIN
	script_done_expr = optarg;
END

GROUP(Preprocessor control)

OPTION(include-directory,I,DIR,
       [<add include directory>])
BEGIN
        if (preproc_settings == PREPROC_NOT_SET)
		preproc_settings = PREPROC_DEFAULT;
	grecs_preproc_add_include_dir(optarg);
END

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

        if (preproc_settings == PREPROC_NOT_SET)
		preproc_settings = PREPROC_DEFAULT;
        if (!pp_cmd_acc)
		pp_cmd_acc = grecs_txtacc_create();
        grecs_txtacc_grow(pp_cmd_acc, " \"-D", 4);
        for (p = optarg; *p; p++) {
		if (*p == '\\' || *p == '"')
			grecs_txtacc_grow_char(pp_cmd_acc, '\\');
		grecs_txtacc_grow_char(pp_cmd_acc, *p);
	}
	grecs_txtacc_grow_char(pp_cmd_acc, '"');			
END

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

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

GROUP(Debugging)

OPTION(debug-parser,x,,
       [<debug configuration file parser>])
BEGIN
	grecs_gram_trace(1);
END

OPTION(debug-lexer,X,,
       [<debug configuration file lexer>])
BEGIN
	grecs_lex_trace(1);
END

OPTIONS_END

void
cfpeek_version_hook(FILE *stream)
{
	fprintf(stream, "compiled with:\n");
	fprintf(stream, "  Grecs %s\n", GRECS_GIT_ID);
#ifdef GUILE_VERSION
	fprintf(stream, "  Guile %s\n", GUILE_VERSION);
#endif
}


void
parse_options(int argc, char *argv[])
{
	program_name = strrchr(argv[0], '/');
	if (program_name)
		program_name++;
	else
		program_name = argv[0];
	proginfo.print_help_hook = flags_help;
	proginfo.print_version_hook = cfpeek_version_hook;
        GETOPT(argc, argv, file_index, exit(EX_USAGE))
	if (!(flags_on & _GRECS_NODE_MASK_OUTPUT)) 
		flags_on |= GRECS_NODE_FLAG_PATH|GRECS_NODE_FLAG_VALUE;
	flags = flags_on & ~flags_off;
	if (!(flags & (GRECS_NODE_FLAG_PATH|GRECS_NODE_FLAG_VALUE))) {
		grecs_warning(NULL, 0, "assuming --format=path,value");
		flags |= GRECS_NODE_FLAG_PATH|GRECS_NODE_FLAG_VALUE;
	}
	if (preproc_settings == PREPROC_DEFAULT)
		grecs_preprocessor = DEFAULT_PREPROCESSOR;
	if (pp_cmd_acc && grecs_preprocessor) {
		char *args, *cmd;

		grecs_txtacc_grow_char(pp_cmd_acc, 0);
		args = grecs_txtacc_finish(pp_cmd_acc, 0);
		cmd = grecs_malloc(strlen(grecs_preprocessor) +
				   strlen(args) + 1);
		strcpy(cmd, grecs_preprocessor);
		strcat(cmd, args);
		grecs_preprocessor = cmd;
	}
	grecs_txtacc_free(pp_cmd_acc);

	script_init();
}