/*
 * Command line utility for making sense of C declarations.
 * Copyright © 2011-2012 Nick Bowler
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <locale.h>
#include <getopt.h>
#include <gettext.h>
#include <assert.h>
#include "readline.h"
#include "history.h"
#include "cdecl.h"

#define _(x) gettext(x)
#define N_(x) x
#define PN_(c, x) x

static const char *progname = "cdecl99";
static const char sopts[] = "qbif:e:VH";
#define RAW_LOPTS \
	{ PN_("longopt", "quiet"),       0, NULL, 'q' }, \
	{ PN_("longopt", "batch"),       0, NULL, 'b' }, \
	{ PN_("longopt", "interactive"), 0, NULL, 'i' }, \
	{ PN_("longopt", "file"),        1, NULL, 'f' }, \
	{ PN_("longopt", "execute"),     1, NULL, 'e' }, \
	{ PN_("longopt", "version"),     0, NULL, 'V' }, \
	{ PN_("longopt", "help"),        0, NULL, 'H' }

/*
 * With NLS, we need a buffer big enough to store the translated options.
 * The translations will be filled in at program startup.
 */
enum { NOPTS = sizeof (struct option[]){RAW_LOPTS} / sizeof (struct option) };
static struct option lopts[NOPTS + !!ENABLE_NLS * NOPTS + 1] = { RAW_LOPTS };

static struct helptext {
	int val;
	const char *text;
	const char *argname;
} helptext[] = {
	/*
	 * TRANSLATORS: Help messages are indented 20 spaces and thus should
	 * not have lines longer than 60 columns.
	 */
	{ 'q', N_("Suppress the welcome message.\n") },
	{ 'b', N_("Execute commands as normal, but do not print any prompts.\n") },
	{ 'i', N_("Run in interactive mode.  This is the default.\n") },
	{ 'f', N_("Read commands from FILE instead of standard input.\n"),
	       PN_("longopt|file", "FILE") },
	{ 'e', N_("Execute COMMAND as if it were entered at the prompt.\n"
	          "This can be specified multiple times.\n"),
	       PN_("longopt|execute", "COMMAND") },
	{ 'V', N_("Print a version message and then exit.\n") },
	{ 'H', N_("Print this message.\n") },

	/* TRANSLATORS: ARG is only used for options without help text. */
	{ 0, NULL, PN_("longopt", "ARG") }
};

static void print_version(void)
{
	puts(PACKAGE_STRING);
	/* TRANSLATORS: (C) must *always* be translated as ©. */
	printf("Copyright %s 2011 Nick Bowler.\n", gettext("(C)"));
	puts("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.");
	puts("This is free software: you are free to change and redistribute it.");
	puts("There is NO WARRANTY, to the extent permitted by law.");
}

static void print_usage(FILE *f)
{
	fprintf(f, "Usage: %s [options]\n", progname);
}

/*
 * Print the help description of a particular command-line option, identified
 * by its short option name.
 */
static void print_option(int val)
{
	const struct option *tmp[2];
	const struct helptext *help;
	const char *argname;
	char context[32];
	size_t rc, n = 0;
	int w;

	/* Find the options and help text corresponding to val. */
	for (const struct option *o = lopts; o->val; o++) {
		if (o->val == val) {
			assert(n < sizeof tmp / sizeof tmp[0]);
			tmp[n++] = o;
		}
	}

	for (help = helptext; help->val; help++) {
		if (help->val == val)
			break;
	}

	/* Prepare translations. */
	if (!ENABLE_NLS) {
		argname = help->argname;
	} else if (n > 0) {
		rc = snprintf(context, sizeof context, "longopt%c%s",
		              help->text ? '|' : '\0', tmp[0]->name);
		assert(rc < sizeof context);

		if (help->argname)
			argname = pgettext_expr(context, help->argname);
	}

	switch (n) {
	case 0:
		w = printf(_("  -%c"), val);
		break;
	case 1:
		w = printf(tmp[0]->has_arg ? _("  -%c, --%s=%s")
		                           : _("  -%c, --%s"),
		           val, tmp[0]->name, argname);
		break;
	case 2:
		if (tmp[0]->has_arg) {
			w = printf(_("  -%c, --%s=%s, --%s=%s"), val,
			           tmp[0]->name, argname,
			           tmp[1]->name, argname);
		} else {
			w = printf(_("  -%c, --%s, --%s"), val,
			           tmp[0]->name, tmp[1]->name);
		}
		break;
	default:
		assert(0);
	}

	if (!help->text) {
		putchar('\n');
		return;
	}

	if (w > 18) {
		putchar('\n');
		w = 0;
	}

	for (const char *line = gettext(help->text); *line;) {
		const char *nl = strchr(line, '\n');

		if (!nl) {
			printf("%*s%s\n", 20-w, "", line);
			break;
		}

		printf("%*s%.*s\n", 20-w, "", (int)(nl-line), line);
		line = nl+1;
	}
}

static void print_help(void)
{
	print_usage(stdout);

	puts(_(
"This is \"cdecl99\": a command-line tool for parsing and constructing\n"
"complicated C declarations.\n"));

	puts(_("Options:"));
	for (const char *c = sopts; *c; c++) {
		if (*c == ':' || *c == '+' || *c == '-')
			continue;

		print_option(*c);
	}
	putchar('\n');

	puts(_("For more information, see the cdecl99(1) man page.\n"));

	/*
	 * TRANSLATORS: Please add *another line* indicating where users should
	 * report translation bugs.
	 */
	printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
}

/*
 * Format a declaration according to the given function and return a pointer
 * to the formatted string.  The returned pointer remains valid until the
 * next call, after which it must not be re-used.
 *
 * Returns NULL on failure.
 */
static const char *
do_format(size_t func(char *, size_t, struct cdecl *), struct cdecl *decl)
{
	static size_t bufsz;
	static char *buf;

	size_t rc;

retry:
	rc = func(buf, bufsz, decl);
	if (rc >= bufsz) {
		char *tmp;

		tmp = realloc(buf, rc + 1);
		if (!tmp) {
			fprintf(stderr, "failed to allocate memory\n");
			return NULL;
		}

		buf = tmp;
		bufsz = rc + 1;
		goto retry;
	}

	return buf;
}

static int cmd_explain(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	decl = cdecl_parse_decl(arg);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	for (struct cdecl *i = decl; i; i = i->next) {
		str = do_format(cdecl_explain, i);
		if (!str)
			goto out;

		printf("%s\n", str);
	}

	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_simplify(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	decl = cdecl_parse_decl(arg);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	for (struct cdecl *i = decl; i; i = i->next) {
		struct cdecl_declspec *s = i->specifiers;

		if (i != decl) {
			i->specifiers = NULL;
			printf(", ");
		}

		str = do_format(cdecl_declare, i);
		i->specifiers = s;

		if (!str)
			goto out;

		printf("%s", str);
	}

	putchar('\n');

	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_declare(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	/* The name of the command is significant here. */
	decl = cdecl_parse_english(cmd);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	/*
	 * English parses have at most one full declarator, so no loop is
	 * needed here.
	 */
	str = do_format(cdecl_declare, decl);
	if (!str)
		goto out;

	printf("%s\n", str);
	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_quit(const char *cmd, const char *arg)
{
	return 0;
}

static int cmd_help(const char *cmd, const char *arg);

static const struct command {
	char name[16];
	int (*func)(const char *cmd, const char *arg);
	const char *blurb;
} commands[] = {
	{ "explain",  cmd_explain,  "Explain a C declaration." },
	{ "simplify", cmd_simplify, "Simplify a C declaration." },
	{ "declare",  cmd_declare,  "Construct a C declaration." },
	{ "type",     cmd_declare,  "Construct a C type name." },
	{ "help",     cmd_help,     "Print this list of commands." },
	{ "quit",     cmd_quit,     "Quit the program." },
	{ "exit",     cmd_quit,     NULL }
};
static const size_t ncommands = sizeof commands / sizeof commands[0];

static int cmd_help(const char *cmd, const char *arg)
{
	for (size_t i = 0; i < ncommands; i++) {
		if (!commands[i].blurb)
			continue;

		printf("%s -- %s\n", commands[i].name, commands[i].blurb);
	}

	return 1;
}

/*
 * Ensure that the first n characters of str equal the entire (null-terminated)
 * string cmd.
 */
static int cmd_cmp(const char *str, const char *cmd, size_t n)
{
	size_t cmdlen = strlen(cmd);

	if (n < cmdlen)
		return -1;
	if (n > cmdlen)
		return 1;
	return memcmp(str, cmd, n);
}

static int run_command(const char *line)
{
	const char *cmd = line + strspn(line, " \t");
	const char *arg = cmd  + strcspn(cmd, " \t");

	if (cmd[0] == '\0')
		return 1;

	for (size_t i = 0; i < ncommands; i++) {
		if (cmd_cmp(cmd, commands[i].name, arg-cmd) != 0)
			continue;

		return commands[i].func(cmd, arg);
	}

	fprintf(stderr, "Undefined command: %.*s\n", (int)(arg-cmd), cmd);
	return -1;
}

static bool is_blank_line(const char *line)
{
	for (size_t i = 0; line[i]; i++) {
		if (!isblank((unsigned char)line[i]))
			return false;
	}

	return true;
}

static int repl(void)
{
	char *line;

	for (; (line = readline("> ")); free(line)) {
		if (!is_blank_line(line))
			cdecl_add_history(line);

		if (!run_command(line))
			break;
	}

	free(line);
	return 0;
}

static int repl_cmdline(int argc, char **argv)
{
	int opt, rc, ret = 0;

	optind = 1;
	while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
		if (opt != 'e')
			continue;

		rc = run_command(optarg);
		if (rc < 0)
			ret = -1;
		else if (rc == 0)
			break;
	}

	return ret;
}

static int repl_noninteractive(void)
{
	int rc, ret = 0, saved_errno;
	char *line = NULL;
	size_t n;

	while (getline(&line, &n, stdin) >= 0) {
		char *c = strchr(line, '\n');
		if (c)
			*c = '\0';

		rc = run_command(line);
		if (rc < 0)
			ret = -1;
		else if (rc == 0)
			break;
	}

	saved_errno = errno;
	free(line);

	if (ferror(stdin)) {
		errno = saved_errno;
		perror("read error");
		return -1;
	}

	return ret;
}

/* Initialize gettext and setup translated long options. */
static void init_i18n(void)
{
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);

	if (!ENABLE_NLS)
		return;

	for (int i = 0, j = NOPTS; i < NOPTS; i++) {
		const char *tname = pgettext_expr("longopt", lopts[i].name);

		if (strcmp(tname, lopts[i].name) != 0) {
			lopts[j] = lopts[i];
			lopts[j].name = tname;
			j++;
		}
	}
}

int main(int argc, char **argv)
{
	bool show_intro = true, interactive = true, execute = false;
	const char *filename = NULL;
	int opt, rc;

	if (argc > 0)
		progname = argv[0];

	init_i18n();

	while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
		switch (opt) {
		case 'q':
			show_intro = false;
			break;
		case 'b':
			interactive = false;
			break;
		case 'i':
			interactive = true;
			break;
		case 'f':
			filename = optarg;
			break;
		case 'e':
			execute = true;
			break;
		case 'V':
			print_version();
			return EXIT_SUCCESS;
		case 'H':
			print_help();
			return EXIT_SUCCESS;
		default:
			print_usage(stderr);
			return EXIT_FAILURE;
		}
	}

	/* --filename and --execute imply --batch. */
	if (filename || execute)
		interactive = false;

	/* --batch implies --quiet */
	if (interactive && show_intro)
		print_version();

	/* --execute supersedes --filename */
	if (filename && !execute) {
		if (!freopen(filename, "r", stdin)) {
			perror(filename);
			return EXIT_FAILURE;
		}
	}

	if (interactive)
		rc = repl();
	else if (execute)
		rc = repl_cmdline(argc, argv);
	else
		rc = repl_noninteractive();

	if (rc != 0)
		return EXIT_FAILURE;
	return EXIT_SUCCESS;
}