/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <locale.h>
#include <ctype.h>
#ifdef WITH_LIBTECLA
#include <libtecla.h>
#endif
#include "idmap_engine.h"

/* The maximal line length. Longer lines may not be parsed OK. */
#define	MAX_CMD_LINE_SZ 1023

#ifdef WITH_LIBTECLA
#define	MAX_HISTORY_LINES 1023
static GetLine * gl_h;
/* LINTED E_STATIC_UNUSED */
#endif

/* Array for arguments of the actuall command */
static char ** my_argv;
/* Allocated size for my_argv */
static int my_argv_size = 16;
/* Actuall length of my_argv */
static int my_argc;

/* Array for subcommands */
static cmd_ops_t *my_comv;
/* my_comc length */
static int my_comc;

/* Input filename specified by the -f flag */
static char *my_filename;

/*
 * Batch mode means reading file, stdin or libtecla input. Shell input is
 * a non-batch mode.
 */
static int my_batch_mode;

/* Array of all possible flags */
static flag_t flags[FLAG_ALPHABET_SIZE];

/* getopt variables */
extern char *optarg;
extern int optind, optopt, opterr;

/* Fill the flags array: */
static int
options_parse(int argc, char *argv[], const char *options)
{
	int c;

	optind = 1;

	while ((c = getopt(argc, argv, options)) != EOF) {
		switch (c) {
		case '?':
			return (-1);
		case ':':
	/* This is relevant only if options starts with ':': */
			(void) fprintf(stderr,
			    gettext("Option %s: missing parameter\n"),
			    argv[optind - 1]);
			return (-1);
		default:
			if (optarg == NULL)
				flags[c] = FLAG_SET;
			else
				flags[c] = optarg;

		}
	}
	return (optind);
}

/* Unset all flags */
static void
options_clean()
{
	(void) memset(flags, 0, FLAG_ALPHABET_SIZE * sizeof (flag_t));
}

/* determine which subcommand is argv[0] and execute its handler */
static int
run_command(int argc, char **argv, cmd_pos_t *pos)
{
	int i;

	if (argc == 0) {
		if (my_batch_mode)
			return (0);
		return (-1);
	}
	for (i = 0; i < my_comc; i++) {
		int optind;
		int rc;

		if (strcmp(my_comv[i].cmd, argv[0]) != 0)
			continue;

		/* We found it. Now execute the handler. */
		options_clean();
		optind = options_parse(argc, argv, my_comv[i].options);
		if (optind < 0) {
			return (-1);
		}

		rc = my_comv[i].p_do_func(flags,
		    argc - optind,
		    argv + optind,
		    pos);

		return (rc);
	}

	(void) fprintf(stderr, gettext("Unknown command %s\n"),
	    argv[0]);

	return (-1);

}

/*
 * Read another parameter from "from", up to a space char (unless it
 * is quoted). Duplicate it to "to". Remove quotation, if any.
 */
static int
get_param(char **to, const char *from)
{
	int to_i, from_i;
	char c;
	int last_slash = 0; 	/* Preceded by a slash? */
	int in_string = 0;	/* Inside quites? */
	int is_param = 0;
	size_t buf_size = 20;	/* initial length of the buffer. */
	char *buf = (char *)malloc(buf_size * sizeof (char));

	from_i = 0;
	while (isspace(from[from_i]))
		from_i++;

	for (to_i = 0; '\0' != from[from_i]; from_i++) {
		c = from[from_i];

		if (to_i >= buf_size - 1) {
			buf_size *= 2;
			buf = (char *)realloc(buf, buf_size * sizeof (char));
		}

		if (c == '"' && !last_slash) {
			in_string = !in_string;
			is_param = 1;
			continue;

		} else if (c == '\\' && !last_slash) {
			last_slash = 1;
			continue;

		} else if (!last_slash && !in_string && isspace(c)) {
			break;
		}

		buf[to_i++] = from[from_i];
		last_slash = 0;

	}

	if (to_i == 0 && !is_param) {
		free(buf);
		*to = NULL;
		return (0);
	}

	buf[to_i] = '\0';
	*to = buf;

	if (in_string)
		return (-1);

	return (from_i);
}

/*
 * Split a string to a parameter array and append it to the specified position
 * of the array
 */
static int
line2array(const char *line)
{
	const char *cur;
	char *param;
	int len;

	for (cur = line; len = get_param(&param, cur); cur += len) {
		if (my_argc >= my_argv_size) {
			my_argv_size *= 2;
			my_argv = (char **)realloc(my_argv,
			    my_argv_size * sizeof (char *));
		}

		my_argv[my_argc] = param;
		++my_argc;

		/* quotation not closed */
		if (len < 0)
			return (-1);

	}
	return (0);

}

/* Clean all aruments from my_argv. Don't deallocate my_argv itself. */
static void
my_argv_clean()
{
	int i;
	for (i = 0; i < my_argc; i++) {
		free(my_argv[i]);
		my_argv[i] = NULL;
	}
	my_argc = 0;
}


#ifdef WITH_LIBTECLA
/* This is libtecla tab completion. */
static
CPL_MATCH_FN(command_complete)
{
	/*
	 * WordCompletion *cpl; const char *line; int word_end are
	 * passed from the CPL_MATCH_FN macro.
	 */
	int i;
	char *prefix;
	int prefix_l;

	/* We go on even if quotation is not closed */
	(void) line2array(line);


	/* Beginning of the line: */
	if (my_argc == 0) {
		for (i = 0; i < my_comc; i++)
			(void) cpl_add_completion(cpl, line, word_end,
			    word_end, my_comv[i].cmd, "", " ");
		goto cleanup;
	}

	/* Is there something to complete? */
	if (isspace(line[word_end - 1]))
		goto cleanup;

	prefix = my_argv[my_argc - 1];
	prefix_l = strlen(prefix);

	/* Subcommand name: */
	if (my_argc == 1) {
		for (i = 0; i < my_comc; i++)
			if (strncmp(prefix, my_comv[i].cmd, prefix_l) == 0)
				(void) cpl_add_completion(cpl, line,
				    word_end - prefix_l,
				    word_end, my_comv[i].cmd + prefix_l,
				    "", " ");
		goto cleanup;
	}

	/* Long options: */
	if (prefix[0] == '-' && prefix [1] == '-') {
		char *options2 = NULL;
		char *paren;
		char *thesis;
		int i;

		for (i = 0; i < my_comc; i++)
			if (0 == strcmp(my_comv[i].cmd, my_argv[0])) {
				options2 = strdup(my_comv[i].options);
				break;
			}

		/* No such subcommand, or not enough memory: */
		if (options2 == NULL)
			goto cleanup;

		for (paren = strchr(options2, '(');
		    paren && ((thesis = strchr(paren + 1, ')')) != NULL);
		    paren = strchr(thesis + 1, '(')) {
		/* Short option or thesis must precede, so this is safe: */
			*(paren - 1) = '-';
			*paren = '-';
			*thesis = '\0';
			if (strncmp(paren - 1, prefix, prefix_l) == 0) {
				(void) cpl_add_completion(cpl, line,
				    word_end - prefix_l,
				    word_end, paren - 1 + prefix_l, "", " ");
			}
		}
		free(options2);

		/* "--" is a valid completion */
		if (prefix_l == 2) {
			(void) cpl_add_completion(cpl, line,
			    word_end - 2,
			    word_end, "", "", " ");
		}

	}

cleanup:
	my_argv_clean();
	return (0);
}

/* libtecla subshell: */
static int
interactive_interp()
{
	int rc = 0;
	char *prompt;
	const char *line;

	(void) sigset(SIGINT, SIG_IGN);

	gl_h = new_GetLine(MAX_CMD_LINE_SZ, MAX_HISTORY_LINES);

	if (gl_h == NULL) {
		(void) fprintf(stderr,
		    gettext("Error reading terminal: %s.\n"),
		    gl_error_message(gl_h, NULL, 0));
		return (-1);
	}

	(void) gl_customize_completion(gl_h, NULL, command_complete);

	for (;;) {
new_line:
		my_argv_clean();
		prompt = "> ";
continue_line:
		line = gl_get_line(gl_h, prompt, NULL, -1);

		if (line == NULL) {
			switch (gl_return_status(gl_h)) {
			case GLR_SIGNAL:
				gl_abandon_line(gl_h);
				goto new_line;

			case GLR_EOF:
				(void) line2array("exit");
				break;

			case GLR_ERROR:
				(void) fprintf(stderr,
				    gettext("Error reading terminal: %s.\n"),
				    gl_error_message(gl_h, NULL, 0));
				rc = -1;
				goto end_of_input;
			default:
				(void) fprintf(stderr, "Internal error.\n");
				exit(1);
			}
		} else {
			if (line2array(line) < 0) {
				(void) fprintf(stderr,
				    gettext("Quotation not closed\n"));
				goto new_line;
			}
			if (my_argc == 0) {
				goto new_line;
			}
			if (strcmp(my_argv[my_argc-1], "\n") == 0) {
				my_argc--;
				free(my_argv[my_argc]);
				(void) strcpy(prompt, "> ");
				goto continue_line;
			}
		}

		rc = run_command(my_argc, my_argv, NULL);

		if (strcmp(my_argv[0], "exit") == 0 && rc == 0) {
			break;
		}

	}

end_of_input:
	gl_h = del_GetLine(gl_h);
	my_argv_clean();
	return (rc);
}
#endif

/* Interpretation of a source file given by "name" */
static int
source_interp(const char *name)
{
	FILE *f;
	int is_stdin;
	int rc = -1;
	char line[MAX_CMD_LINE_SZ];
	cmd_pos_t pos;

	if (name == NULL || strcmp("-", name) == 0) {
		f = stdin;
		is_stdin = 1;
	} else {
		is_stdin = 0;
		f = fopen(name, "r");
		if (f == NULL) {
			perror(name);
			return (-1);
		}
	}

	pos.linenum = 0;
	pos.line = line;

	while (fgets(line, MAX_CMD_LINE_SZ, f)) {
		pos.linenum ++;

		if (line2array(line) < 0) {
			(void) fprintf(stderr,
			    gettext("Quotation not closed\n"));
			my_argv_clean();
			continue;
		}

		/* We do not wan't "\n" as the last parameter */
		if (my_argc != 0 && strcmp(my_argv[my_argc-1], "\n") == 0) {
			my_argc--;
			free(my_argv[my_argc]);
			continue;
		}

		if (my_argc != 0 && strcmp(my_argv[0], "exit") == 0) {
			rc = 0;
			my_argv_clean();
			break;
		}

		rc = run_command(my_argc, my_argv, &pos);
		my_argv_clean();
	}

	if (my_argc > 0) {
		(void) fprintf(stderr, gettext("Line continuation missing\n"));
		rc = 1;
		my_argv_clean();
	}

	if (!is_stdin)
		(void) fclose(f);

	return (rc);
}

/*
 * Initialize the engine.
 * comc, comv is the array of subcommands and its length,
 * argc, argv are arguments to main to be scanned for -f filename and
 *    the length og the array,
 * is_batch_mode passes to the caller the information if the
 *    batch mode is on.
 *
 * Return values:
 * 0: ... OK
 * IDMAP_ENG_ERROR: error and message printed already
 * IDMAP_ENG_ERROR_SILENT: error and message needs to be printed
 *
 */

int
engine_init(int comc, cmd_ops_t *comv, int argc, char **argv,
    int *is_batch_mode)
{
	int c;

	my_comc = comc;
	my_comv = comv;

	my_argc = 0;
	my_argv = (char **)calloc(my_argv_size, sizeof (char *));

	if (argc < 1) {
		my_filename = NULL;
		if (isatty(fileno(stdin))) {
#ifdef WITH_LIBTECLA
			my_batch_mode = 1;
#else
			my_batch_mode = 0;
			return (IDMAP_ENG_ERROR_SILENT);
#endif
		} else
			my_batch_mode = 1;

		goto the_end;
	}

	my_batch_mode = 0;

	optind = 0;
	while ((c = getopt(argc, argv,
	    "f:(command-file)")) != EOF) {
		switch (c) {
		case '?':
			return (IDMAP_ENG_ERROR);
		case 'f':
			my_batch_mode = 1;
			my_filename = optarg;
			break;
		default:
			(void) fprintf(stderr, "Internal error.\n");
			exit(1);
		}
	}

the_end:

	if (is_batch_mode != NULL)
		*is_batch_mode = my_batch_mode;
	return (0);
}

/* finitialize the engine */
int
engine_fini()
{
	my_argv_clean();
	free(my_argv);
	return (0);
}

/*
 * Interpret the subcommands defined by the arguments, unless
 * my_batch_mode was set on in egnine_init.
 */
int
run_engine(int argc, char **argv)
{
	int rc = -1;

	if (my_batch_mode) {
#ifdef WITH_LIBTECLA
		if (isatty(fileno(stdin)))
			rc = interactive_interp();
		else
#endif
			rc = source_interp(my_filename);
		goto cleanup;
	}

	rc = run_command(argc, argv, NULL);

cleanup:
	return (rc);
}