#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <string.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxslt/transform.h>
#include <libexslt/exslt.h>
#include "s1kd_tools.h"
#include "resources.h"

#define PROG_NAME "s1kd-aspp"
#define VERSION "5.0.1"

#define ERR_PREFIX PROG_NAME ": ERROR: "
#define WRN_PREFIX PROG_NAME ": WARNING: "
#define INF_PREFIX PROG_NAME ": INFO: "

#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"

#define W_MISSING_REF WRN_PREFIX "Could not read referenced object: %s\n"

#define I_PROCESS INF_PREFIX "Processing %s...\n"

/* ID for the inline <applic> element representing the whole data module's
 * applicability. */
#define DEFAULT_DM_APPLIC_ID BAD_CAST "app-0000"
static xmlChar *dmApplicId;

/* XPath to select all elements which may have applicability annotations.
 *
 * Read from elements_list.h*/
static xmlChar *applicElemsXPath;

/* Search for ACTs/CCTs recursively. */
static bool recursive_search = false;

/* Directory to start search for ACTs/CCTs in. */
static char *search_dir;

/* Overwrite existing display text in annotations. */
static bool overwriteDispText = true;

/* Verbose output. */
static enum verbosity { QUIET, NORMAL, VERBOSE } verbosity = NORMAL;

/* Assume objects were created with -N. */
static bool no_issue = false;

/* Delimiter for format strings. */
#define FMTSTR_DELIM '%'

/* Return the first node matching an XPath expression. */
static xmlNodePtr firstXPathNode(xmlDocPtr doc, xmlNodePtr node, const char *xpath)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr first;

	if (doc) {
		ctx = xmlXPathNewContext(doc);
	} else if (node) {
		ctx = xmlXPathNewContext(node->doc);
	} else {
		return NULL;
	}

	ctx->node = node;

	obj = xmlXPathEvalExpression(BAD_CAST xpath, ctx);

	if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		first = NULL;
	} else {
		first = obj->nodesetval->nodeTab[0];
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);

	return first;
}

/* Return the last node matching an XPath expression. */
static xmlNodePtr lastXPathNode(xmlDocPtr doc, xmlNodePtr node, const char *xpath)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr last;

	if (doc) {
		ctx = xmlXPathNewContext(doc);
	} else if (node) {
		ctx = xmlXPathNewContext(node->doc);
	} else {
		return NULL;
	}

	ctx->node = node;

	obj = xmlXPathEvalExpression(BAD_CAST xpath, ctx);

	if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		last = NULL;
	} else {
		last = obj->nodesetval->nodeTab[obj->nodesetval->nodeNr - 1];
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);

	return last;
}

/* Return the value of the first node matching an XPath expression. */
static xmlChar *first_xpath_value(xmlDocPtr doc, xmlNodePtr node, const char *xpath)
{
	return xmlNodeGetContent(firstXPathNode(doc, node, xpath));
}

/* Set an explicit applicability annotation on a node.
 *
 * Nodes with the attribute @applicRefId already have an explicit annotation.
 *
 * Nodes without @applicRefId have an implicit annotation inherited from their
 * parent/ancestor which does have an explicit annotation, or ultimately from
 * the applicability of the whole data module. */
static void processNode(xmlNodePtr node)
{
	xmlNodePtr attr;

	attr = firstXPathNode(NULL, node, "@applicRefId|@refapplic");

	if (!attr) {
		/* Inherit applicability from
		 * - an ancestor, or
		 * - the whole data module level */
		xmlNodePtr ancestor;
		xmlChar *name;

		ancestor = lastXPathNode(NULL, node, "ancestor::*[@applicRefId]|ancestor::*[@refapplic]");

		name = BAD_CAST (firstXPathNode(NULL, node, "//idstatus") ? "refapplic" : "applicRefId");

		if (!ancestor) {
			xmlSetProp(node, name, dmApplicId);
		} else {
			xmlChar *ancestorApplic = xmlGetProp(ancestor, name);
			xmlSetProp(node, name, ancestorApplic);
			xmlFree(ancestorApplic);
		}
	}
}

/* Set explicit applicability on all nodes in a nodeset. */
static void processNodeSet(xmlNodeSetPtr nodes)
{
	int i;

	for (i = 0; i < nodes->nodeNr; ++i) {
		processNode(nodes->nodeTab[i]);
	}
}

/* Remove duplicate applicability annotations in document-order so that an
 * annotation is only shown when applicability changes. */
static void removeDuplicates(xmlNodeSetPtr nodes)
{
	int i;

	xmlChar *applic = xmlStrdup(dmApplicId);

	for (i = 0; i < nodes->nodeNr; ++i) {
		xmlNodePtr attr;
		xmlChar *applicRefId;

		attr = firstXPathNode(NULL, nodes->nodeTab[i], "@applicRefId|@refapplic");
		applicRefId = xmlNodeGetContent(attr);

		if (xmlStrcmp(applicRefId, applic) == 0) {
			xmlUnsetProp(nodes->nodeTab[i], attr->name);
		} else {
			xmlFree(applic);
			applic = xmlStrdup(applicRefId);
		}

		xmlFree(applicRefId);
	}

	xmlFree(applic);
}

/* Insert a new inline <applic> element representing the applicability of the
 * whole data module, based on the dmStatus/applic element. */
static void addDmApplic(xmlNodePtr dmodule)
{
	xmlNodePtr referencedApplicGroup;

	if ((referencedApplicGroup = firstXPathNode(NULL, dmodule, ".//referencedApplicGroup|.//inlineapplics"))) {
		xmlNodePtr applic;
		xmlNodePtr wholeDmApplic;

		wholeDmApplic = firstXPathNode(NULL, dmodule, ".//dmStatus/applic|.//status/applic");
		applic = xmlAddChild(referencedApplicGroup, xmlCopyNode(wholeDmApplic, 1));

		xmlSetProp(applic, BAD_CAST "id", dmApplicId);
	}
}

static xmlDocPtr parse_disptext(xmlDocPtr config)
{
	xmlDocPtr doc1, doc2, res;
	xsltStylesheetPtr style;

	doc1 = read_xml_mem((const char *) disptext_xsl, disptext_xsl_len);
	style = xsltParseStylesheetDoc(doc1);

	doc2 = xsltApplyStylesheet(style, config, NULL);
	xsltFreeStylesheet(style);

	res = xmlCopyDoc(doc2, 1);
	xmlFreeDoc(doc2);

	return res;
}

static void dumpGenDispTextXsl(void)
{
	xmlDocPtr doc1, doc2;
	doc1 = read_xml_mem((const char *) disptext_xml, disptext_xml_len);
	doc2 = parse_disptext(doc1);
	xmlFreeDoc(doc1);
	save_xml_doc(doc2, "-");
	xmlFreeDoc(doc2);
}

static void dumpDispText(void)
{
	printf("%.*s", disptext_xml_len, disptext_xml);
}

/* Customize the display text based on a format string. */
static void apply_format_str(xmlDocPtr doc, const char *fmt)
{
	xmlNodePtr t, c;
	int i;

	/* Get the assert text template. */
	t = firstXPathNode(doc, NULL, "//*[@match='assert' and @mode='text']");

	if (!t) {
		return;
	}

	/* Clear the template. */
	c = t->children;
	while (c) {
		xmlNodePtr n;
		n = c->next;
		xmlUnlinkNode(c);
		xmlFreeNode(c);
		c = n;
	}

	/* Parse the format string and generate the new template. */
	for (i = 0; fmt[i]; ++i) {
		xmlChar s[2] = {0};

		if (fmt[i] == FMTSTR_DELIM) {
			if (fmt[i + 1] == FMTSTR_DELIM) {
				s[0] = FMTSTR_DELIM;
				xmlNewChild(t, t->nsDef, BAD_CAST "text", s);
				++i;
			} else {
				const char *k, *e;
				int n;

				k = fmt + i + 1;
				e = strchr(k, FMTSTR_DELIM);
				if (!e) break;
				n = e - k;

				if (strncmp(k, "name", n) == 0) {
					c = xmlNewChild(t, t->nsDef, BAD_CAST "call-template", NULL);
					xmlSetProp(c, BAD_CAST "name", BAD_CAST "applicPropertyName");
				} else if (strncmp(k, "values", n) == 0) {
					c = xmlNewChild(t, t->nsDef, BAD_CAST "call-template", NULL);
					xmlSetProp(c, BAD_CAST "name", BAD_CAST "applicPropertyVal");
				}

				i += n + 1;
			}
		} else {
			if (fmt[i] == '\\') {
				switch (fmt[i + 1]) {
					case 'n': s[0] = '\n'; ++i; break;
					case 't': s[0] = '\t'; ++i; break;
					default: s[0] = fmt[i]; break;
				}
			} else {
				s[0] = fmt[i];
			}
			xmlNewChild(t, t->nsDef, BAD_CAST "text", s);
		}
	}
}

static void generateDisplayText(xmlDocPtr doc, xmlNodePtr acts, xmlNodePtr ccts, xsltStylesheetPtr style)
{
	xmlDocPtr res, muxdoc;
	xmlNodePtr mux, cur, muxacts, muxccts, new, old;
	const char *params[3];

	muxdoc = xmlNewDoc(BAD_CAST "1.0");
	mux = xmlNewNode(NULL, BAD_CAST "mux");
	xmlDocSetRootElement(muxdoc, mux);

	xmlAddChild(mux, xmlCopyNode(xmlDocGetRootElement(doc), 1));
	muxacts = xmlNewChild(mux, NULL, BAD_CAST "acts", NULL);
	muxccts = xmlNewChild(mux, NULL, BAD_CAST "ccts", NULL);
	for (cur = acts->children; cur; cur = cur->next) {
		xmlDocPtr act;
		xmlChar *path;
		path = xmlNodeGetContent(cur);
		act = read_xml_doc((char *) path);
		xmlAddChild(muxacts, xmlCopyNode(xmlDocGetRootElement(act), 1));
		xmlFreeDoc(act);
		xmlFree(path);
	}
	for (cur = ccts->children; cur; cur = cur->next) {
		xmlDocPtr cct;
		xmlChar *path;
		path = xmlNodeGetContent(cur);
		cct = read_xml_doc((char *) path);
		xmlAddChild(muxccts, xmlCopyNode(xmlDocGetRootElement(cct), 1));
		xmlFreeDoc(cct);
		xmlFree(path);
	}

	params[0] = "overwrite-display-text";
	params[1] = overwriteDispText ? "true()" : "false()";
	params[2] = NULL;

	res = xsltApplyStylesheet(style, muxdoc, params);

	new = xmlCopyNode(firstXPathNode(res, NULL, "/mux/dmodule"), 1);
	old = xmlDocSetRootElement(doc, new);
	xmlFreeNode(old);

	xmlFreeDoc(res);
	xmlFreeDoc(muxdoc);
}

static void processDmodule(xmlNodePtr dmodule)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;

	ctx = xmlXPathNewContext(dmodule->doc);
	ctx->node = dmodule;
	obj = xmlXPathEvalExpression(applicElemsXPath, ctx);

	processNodeSet(obj->nodesetval);
	removeDuplicates(obj->nodesetval);
	addDmApplic(dmodule);

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);
}

static void processDmodules(xmlNodeSetPtr dmodules)
{
	int i;

	for (i = 0; i < dmodules->nodeNr; ++i) {
		processDmodule(dmodules->nodeTab[i]);
	}
}

/* Find a data module filename in the current directory based on the dmRefIdent
 * element. */
static bool find_dmod_fname(char *dst, xmlNodePtr dmRefIdent)
{
	char *model_ident_code;
	char *system_diff_code;
	char *system_code;
	char *sub_system_code;
	char *sub_sub_system_code;
	char *assy_code;
	char *disassy_code;
	char *disassy_code_variant;
	char *info_code;
	char *info_code_variant;
	char *item_location_code;
	char *learn_code;
	char *learn_event_code;
	char code[64];
	xmlNodePtr dmCode, issueInfo, language;

	dmCode = firstXPathNode(NULL, dmRefIdent, "dmCode|avee");
	issueInfo = firstXPathNode(NULL, dmRefIdent, "issueInfo|issno");
	language = firstXPathNode(NULL, dmRefIdent, "language");

	model_ident_code     = (char *) first_xpath_value(NULL, dmCode, "modelic|@modelIdentCode");
	system_diff_code     = (char *) first_xpath_value(NULL, dmCode, "sdc|@systemDiffCode");
	system_code          = (char *) first_xpath_value(NULL, dmCode, "chapnum|@systemCode");
	sub_system_code      = (char *) first_xpath_value(NULL, dmCode, "section|@subSystemCode");
	sub_sub_system_code  = (char *) first_xpath_value(NULL, dmCode, "subsect|@subSubSystemCode");
	assy_code            = (char *) first_xpath_value(NULL, dmCode, "subject|@assyCode");
	disassy_code         = (char *) first_xpath_value(NULL, dmCode, "discode|@disassyCode");
	disassy_code_variant = (char *) first_xpath_value(NULL, dmCode, "discodev|@disassyCodeVariant");
	info_code            = (char *) first_xpath_value(NULL, dmCode, "incode|@infoCode");
	info_code_variant    = (char *) first_xpath_value(NULL, dmCode, "incodev|@infoCodeVariant");
	item_location_code   = (char *) first_xpath_value(NULL, dmCode, "itemloc|@itemLocationCode");
	learn_code           = (char *) first_xpath_value(NULL, dmCode, "@learnCode");
	learn_event_code     = (char *) first_xpath_value(NULL, dmCode, "@learnEventCode");

	snprintf(code, 64, "DMC-%s-%s-%s-%s%s-%s-%s%s-%s%s-%s",
		model_ident_code,
		system_diff_code,
		system_code,
		sub_system_code,
		sub_sub_system_code,
		assy_code,
		disassy_code,
		disassy_code_variant,
		info_code,
		info_code_variant,
		item_location_code);

	xmlFree(model_ident_code);
	xmlFree(system_diff_code);
	xmlFree(system_code);
	xmlFree(sub_system_code);
	xmlFree(sub_sub_system_code);
	xmlFree(assy_code);
	xmlFree(disassy_code);
	xmlFree(disassy_code_variant);
	xmlFree(info_code);
	xmlFree(info_code_variant);
	xmlFree(item_location_code);

	if (learn_code) {
		char learn[8];
		snprintf(learn, 8, "-%s%s", learn_code, learn_event_code);
		strcat(code, learn);
	}

	xmlFree(learn_code);
	xmlFree(learn_event_code);

	if (!no_issue) {
		if (issueInfo) {
			char *issue_number;
			char *in_work;
			char iss[8];

			issue_number = (char *) first_xpath_value(NULL, issueInfo, "@issno|@issueNumber");
			in_work      = (char *) first_xpath_value(NULL, issueInfo, "@inwork|@inWork");

			snprintf(iss, 8, "_%s-%s", issue_number, in_work ? in_work : "00");
			strcat(code, iss);

			xmlFree(issue_number);
			xmlFree(in_work);
		} else if (language) {
			strcat(code, "_\?\?\?-\?\?");
		}
	}

	if (language) {
		char *language_iso_code;
		char *country_iso_code;
		char lang[8];

		language_iso_code = (char *) first_xpath_value(NULL, language, "@language|@languageIsoCode");
		country_iso_code  = (char *) first_xpath_value(NULL, language, "@country|@countryIsoCode");

		snprintf(lang, 8, "_%s-%s", language_iso_code, country_iso_code);
		strcat(code, lang);

		xmlFree(language_iso_code);
		xmlFree(country_iso_code);
	}

	if (find_csdb_object(dst, search_dir, code, is_dm, recursive_search)) {
		return true;
	}

	if (verbosity >= NORMAL) {
		fprintf(stderr, W_MISSING_REF, code);
	}
	return false;
}

/* Find the filename of a referenced ACT data module. */
static bool find_act_fname(char *dst, xmlDocPtr doc)
{
	xmlNodePtr actref;
	actref = firstXPathNode(doc, NULL, "//applicCrossRefTableRef/dmRef/dmRefIdent|//actref/refdm");
	return actref && find_dmod_fname(dst, actref);
}

/* Find the filename of a referenced PCT data module via the ACT. */
static bool find_cct_fname(char *dst, xmlDocPtr act)
{
	xmlNodePtr pctref;
	bool found;

	pctref = firstXPathNode(act, NULL, "//condCrossRefTableRef/dmRef/dmRefIdent|//cctref/refdm");
	found = pctref && find_dmod_fname(dst, pctref);

	return found;
}

/* Add cross-reference tables by searching for them in the current directory. */
static void find_cross_ref_tables(xmlDocPtr doc, xmlNodePtr acts, xmlNodePtr ccts)
{
	char act_fname[PATH_MAX];
	xmlDocPtr act = NULL;

	if (find_act_fname(act_fname, doc) && (act = read_xml_doc(act_fname))) {
		char cct_fname[PATH_MAX];

		xmlNewChild(acts, NULL, BAD_CAST "act", BAD_CAST act_fname);

		if (find_cct_fname(cct_fname, act)) {
			xmlNewChild(ccts, NULL, BAD_CAST "cct", BAD_CAST cct_fname);
		}

		xmlFreeDoc(act);
	}
}

/* Add tags containing the display text of the referenecd applic annotation. */
static void addTags(xmlDocPtr doc, const char *tags)
{
	xmlDocPtr styledoc, src, res;
	xsltStylesheetPtr style;
	const char *params[3];
	xmlNodePtr old;

	styledoc = read_xml_mem((const char *) addTags_xsl, addTags_xsl_len);
	style = xsltParseStylesheetDoc(styledoc);

	params[0] = "mode";
	if (strcmp(tags, "comment") == 0) {
		params[1] = "'comment'";
	} else if (strcmp(tags, "pi") == 0) {
		params[1] = "'pi'";
	} else {
		params[1] = "'remove'";
	}
	params[2] = NULL;

	src = xmlCopyDoc(doc, 1);
	res = xsltApplyStylesheet(style, src, params);
	xmlFreeDoc(src);

	old = xmlDocSetRootElement(doc, xmlCopyNode(xmlDocGetRootElement(res), 1));
	xmlFreeNode(old);

	xmlFreeDoc(res);
	xsltFreeStylesheet(style);
}

/* Recursively delete display text nodes. */
static void deleteDisplayTextNode(xmlNodePtr node)
{
	xmlNodePtr cur;

	/* 3.0-: displaytext
	 * 4.0+: displayText
	 *
	 * Ignore display text nodes without any siblings. */
	if ((xmlStrcmp(node->name, BAD_CAST "displayText") == 0 || xmlStrcmp(node->name, BAD_CAST "displaytext") == 0) && xmlChildElementCount(node->parent) > 1) {
		xmlUnlinkNode(node);
		xmlFreeNode(node);
		return;
	}

	/* Call recursively on all children. */
	cur = node->children;
	while (cur) {
		xmlNodePtr next = cur->next;
		deleteDisplayTextNode(cur);
		cur = next;
	}

}

/* Delete all display text nodes in a document. */
static void deleteDisplayText(xmlDocPtr doc)
{
	deleteDisplayTextNode(xmlDocGetRootElement(doc));
}

static void processFile(const char *in, const char *out, bool process,
	bool genDispText, bool delDispText, xmlNodePtr acts, xmlNodePtr ccts,
	bool findcts, xsltStylesheetPtr style, const char *tags)
{
	xmlDocPtr doc;
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr all_acts, all_ccts;

	if (verbosity >= VERBOSE) {
		fprintf(stderr, I_PROCESS, in);
	}

	doc = read_xml_doc(in);

	if (findcts) {
		/* Copy the user-defined ACTs/CCTs. */
		all_acts = xmlCopyNode(acts, 1);
		all_ccts = xmlCopyNode(ccts, 1);
		/* Find the ACT/CCT referenced by the current DM. */
		find_cross_ref_tables(doc, all_acts, all_ccts);
	} else {
		/* Only use the user-defined ACTs/CCTs. */
		all_acts = acts;
		all_ccts = ccts;
	}

	if (process) {
		ctx = xmlXPathNewContext(doc);
		obj = xmlXPathEvalExpression(BAD_CAST "//dmodule", ctx);

		processDmodules(obj->nodesetval);

		xmlXPathFreeObject(obj);
		xmlXPathFreeContext(ctx);
	}

	if (delDispText) {
		deleteDisplayText(doc);
	} else if (genDispText) {
		generateDisplayText(doc, all_acts, all_ccts, style);
	}

	if (tags) {
		addTags(doc, tags);
	}

	save_xml_doc(doc, out);

	/* The next data module could reference a different ACT/CCT, so
	 * the list must be cleared. */
	if (findcts) {
		xmlFreeNode(all_acts);
		xmlFreeNode(all_ccts);
	}

	xmlFreeDoc(doc);
}

static void process_list(const char *path, bool overwrite, bool process,
	bool genDispText, bool delDispText, xmlNodePtr acts, xmlNodePtr ccts,
	bool findcts, xsltStylesheetPtr style, const char *tags)
{
	FILE *f;
	char line[PATH_MAX];

	if (path) {
		if (!(f = fopen(path, "r"))) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_BAD_LIST, path);
			}
			return;
		}
	} else {
		f = stdin;
	}

	while (fgets(line, PATH_MAX, f)) {
		strtok(line, "\t\r\n");
		processFile(line, overwrite ? line : "-", process, genDispText, delDispText, acts, ccts, findcts, style, tags);
	}

	if (path) {
		fclose(f);
	}
}

static void show_help(void)
{
	puts("Usage:");
	puts("  " PROG_NAME " [options] [<object> ...]");
	puts("");
	puts("Options:");
	puts("  -., --dump-disptext   Dump the built-in .disptext file.");
	puts("  -,, --dump-xsl        Dump the built-in XSLT for generating display text.");
	puts("  -A, --act <ACT>       Use <ACT> when generating display text.");
	puts("  -a, --id <ID>  Use <ID> for DM-level applic.");
	puts("  -C, --cct <CCT>       Use <CCT> when generating display text.");
	puts("  -c, --search          Search for ACT/CCT data modules.");
	puts("  -D, --delete          Remove all display text.");
	puts("  -d, --dir <dir>       Directory to start search for ACT/CCT in.");
	puts("  -F, --format <fmt>    Use a custom format string for generating display text.");
	puts("  -f, --overwrite       Overwrite input file(s).");
	puts("  -G, --disptext        Specify .disptext file.");
	puts("  -g, --generate        Generate display text for applicability annotations.");
	puts("  -k, --keep            Do not overwrite existing display text.");
	puts("  -l, --list            Treat input as list of modules.");
	puts("  -N, --omit-issue      Assume issue/inwork number are omitted.");
	puts("  -p, --presentation    Convert semantic applicability to presentation applicability.");
	puts("  -q, --quiet           Quiet mode.");
	puts("  -r, --recursive       Search for ACT/CCT recursively.");
	puts("  -t, --tags <mode>     Add display text tags before elements with applicability.");
	puts("  -v, --verbose         Verbose output.");
	puts("  -x, --xsl <XSL>       Use custom XSLT script to generate display text.");
	puts("  -h, -?, --help        Show help/usage message.");
	puts("  --version             Show version information.");
	puts("  <object> ...          CSDB objects to process.");
	LIBXML2_PARSE_LONGOPT_HELP
}

static void show_version(void)
{
	printf("%s (s1kd-tools) %s\n", PROG_NAME, VERSION);
	printf("Using libxml %s, libxslt %s and libexslt %s\n",
		xmlParserVersion, xsltEngineVersion, exsltLibraryVersion);
}

int main(int argc, char **argv)
{
	int i;
	bool overwrite = false;
	bool genDispText = false;
	bool process = false;
	bool delDispText = false;
	bool findcts = false;
	bool islist = false;
	char *format = NULL;
	char *tags = NULL;
	char *customGenDispTextFile = NULL;
	xmlDocPtr disptext = NULL;
	xmlDocPtr styledoc;
	xsltStylesheetPtr style;
	
	xmlNodePtr acts, ccts;

	const char *sopts = ".,A:a:C:cDd:F:fG:gklNpqrt:vx:h?";
	struct option lopts[] = {
		{"version"      , no_argument      , 0, 0},
		{"help"         , no_argument      , 0, 'h'},
		{"dump-disptext", no_argument      , 0, '.'},
		{"dump-xsl"     , no_argument      , 0, ','},
		{"act"          , required_argument, 0, 'A'},
		{"id"           , required_argument, 0, 'a'},
		{"cct"          , required_argument, 0, 'C'},
		{"search"       , no_argument      , 0, 'c'},
		{"delete"       , no_argument      , 0, 'D'},
		{"dir"          , required_argument, 0, 'd'},
		{"format"       , required_argument, 0, 'F'},
		{"overwrite"    , no_argument      , 0, 'f'},
		{"disptext"     , required_argument, 0, 'G'},
		{"generate"     , no_argument      , 0, 'g'},
		{"keep"         , no_argument      , 0, 'k'},
		{"list"         , no_argument      , 0, 'l'},
		{"omit-issue"   , no_argument      , 0, 'N'},
		{"presentation" , no_argument      , 0, 'p'},
		{"quiet"        , no_argument      , 0, 'q'},
		{"recursive"    , no_argument      , 0, 'r'},
		{"tags"         , required_argument, 0, 't'},
		{"verbose"      , no_argument      , 0, 'v'},
		{"xsl"          , required_argument, 0, 'x'},
		LIBXML2_PARSE_LONGOPT_DEFS
		{0, 0, 0, 0}
	};
	int loptind = 0;

	exsltRegisterAll();

	dmApplicId = xmlStrdup(DEFAULT_DM_APPLIC_ID);

	applicElemsXPath = xmlStrndup(elements_list, elements_list_len);

	acts = xmlNewNode(NULL, BAD_CAST "acts");
	ccts = xmlNewNode(NULL, BAD_CAST "ccts");

	search_dir = strdup(".");

	while ((i = getopt_long(argc, argv, sopts, lopts, &loptind)) != -1) {
		switch (i) {
			case 0:
				if (strcmp(lopts[loptind].name, "version") == 0) {
					show_version();
					return 0;
				}
				LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
				break;
			case '.':
				dumpDispText();
				return 0;
			case ',':
				dumpGenDispTextXsl();
				return 0;
			case 'A':
				xmlNewChild(acts, NULL, BAD_CAST "act", BAD_CAST optarg);
				findcts = false;
				break;
			case 'a':
				xmlFree(dmApplicId);
				dmApplicId = xmlStrdup(BAD_CAST optarg);
				break;
			case 'C':
				xmlNewChild(ccts, NULL, BAD_CAST "cct", BAD_CAST optarg);
				findcts = false;
				break;
			case 'c':
				findcts = true;
				break;
			case 'D':
				delDispText = true;
				break;
			case 'd':
				free(search_dir);
				search_dir = strdup(optarg);
				break;
			case 'F':
				genDispText = true;
				free(format);
				format = strdup(optarg);
				break;
			case 'f':
				overwrite = true;
				break;
			case 'G':
				genDispText = true;
				xmlFreeDoc(disptext);
				disptext = read_xml_doc(optarg);
				break;
			case 'g':
				genDispText = true;
				break;
			case 'k':
				overwriteDispText = false;
				break;
			case 'l':
				islist = true;
				break;
			case 'N':
				no_issue = true;
				break;
			case 'p':
				process = true;
				break;
			case 'q':
				--verbosity;
				break;
			case 'r':
				recursive_search = true;
				break;
			case 't':
				free(tags);
				tags = strdup(optarg);
				break;
			case 'v':
				++verbosity;
				break;
			case 'x':
				genDispText = true;
				free(customGenDispTextFile);
				customGenDispTextFile = strdup(optarg);
				break;
			case 'h':
			case '?':
				show_help();
				return 0;
		}
	}

	if (customGenDispTextFile == NULL) {
		if (disptext == NULL) {
			char disptext_fname[PATH_MAX];

			if (find_config(disptext_fname, DEFAULT_DISPTEXT_FNAME)) {
				disptext = read_xml_doc(disptext_fname);
			} else {
				disptext = read_xml_mem((const char *) disptext_xml, disptext_xml_len);
			}
		}

		styledoc = parse_disptext(disptext);
	} else {
		styledoc = read_xml_doc(customGenDispTextFile);
	}

	if (format) {
		apply_format_str(styledoc, format);
	}
	style = xsltParseStylesheetDoc(styledoc);

	if (optind >= argc) {
		if (islist) {
			process_list(NULL, overwrite, process, genDispText, delDispText, acts, ccts, findcts, style, tags);
		} else {
			processFile("-", "-", process, genDispText, delDispText, acts, ccts, findcts, style, tags);
		}
	} else {
		for (i = optind; i < argc; ++i) {
			if (islist) {
				process_list(argv[i], overwrite, process, genDispText, delDispText, acts, ccts, findcts, style, tags);
			} else {
				processFile(argv[i], overwrite ? argv[i] : "-", process, genDispText, delDispText, acts, ccts, findcts, style, tags);
			}
		}
	}

	xmlFree(dmApplicId);
	xmlFree(applicElemsXPath);

	xmlFreeNode(acts);
	xmlFreeNode(ccts);

	free(customGenDispTextFile);
	free(search_dir);
	free(format);
	free(tags);
	xmlFreeDoc(disptext);
	xsltFreeStylesheet(style);

	xsltCleanupGlobals();
	xmlCleanupParser();

	return 0;
}