#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <time.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include "s1kd_tools.h"

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

/* Message prefixes. */
#define ERR_PREFIX PROG_NAME ": ERROR: "
#define INF_PREFIX PROG_NAME ": INFO: "

/* Error messages. */
#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"
#define E_ICN_INWORK ERR_PREFIX "ICNs cannot have inwork issues.\n"
#define E_BAD_FILENAME ERR_PREFIX "Filename does not contain issue info and -N not specified.\n"
#define E_ISSUE_TOO_LARGE ERR_PREFIX "%s is at the max issue number.\n"
#define E_INWORK_TOO_LARGE ERR_PREFIX "%s is at the max inwork number.\n"
#define E_NON_XML_STDIN ERR_PREFIX "Cannot use -m, -N or read from stdin when file does not contain issue info metadata.\n"
#define E_FILE_EXISTS ERR_PREFIX "%s already exists. Use -f to overwrite.\n"

/* Info messages. */
#define I_UPISSUE INF_PREFIX "Upissued %s to %s\n"

/* Exit codes. */
#define EXIT_NO_FILE 1
#define EXIT_NO_OVERWRITE 2
#define EXIT_BAD_FILENAME 3
#define EXIT_BAD_DATE 4
#define EXIT_ICN_INWORK 5
#define EXIT_ISSUE_TOO_LARGE 6

/* Verbosity of the output. */
static enum verbosity { QUIET, NORMAL, VERBOSE } verbosity = NORMAL;

/* Show help/usage information. */
static void show_help(void)
{
	puts("Usage: " PROG_NAME " [-045defHilmNQqRrsuvw^] [-1 <type>] [-2 <type>] [-c <reason>] [-I <date>] [-t <urt>] [-z <type>] [<file>...]");
	putchar('\n');
	puts("Options:");
	puts("  -0, --unverified             Set the quality assurance to unverified.");
	puts("  -1, --first-ver <type>       Set first verification type.");
	puts("  -2, --second-ver <type>      Set second verification type.");
	puts("  -4, --remove-marks           Remove change marks (but not RFUs).");
	puts("  -5, --print                  Print filenames of upissued objects.");
	puts("  -c, --reason <reason>        Add an RFU to the upissued object.");
	puts("  -d, --dry-run                Do not create or modify any files.");
	puts("  -e, --erase                  Remove old issue.");
	puts("  -f, --overwrite              Overwrite existing upissued object.");
	puts("  -H, --highlight              Highlight the last RFU.");
	puts("  -h, -?, --help               Show usage message.");
	puts("  -I, --date <date>            The issue date to use for the upissued objects.");
	puts("  -i, --official               Increase issue number instead of inwork.");
	puts("  -l, --list                   Treat input as list of objects.");
	puts("  -m, --modify                 Modify metadata without upissuing.");
	puts("  -N, --omit-issue             Omit issue/inwork numbers from filename.");
	puts("  -Q, --keep-qa                Keep quality assurance from old issue.");
	puts("  -q, --quiet                  Quiet mode.");
	puts("  -R, --keep-unassoc-marks     Only delete change marks associated with an RFU.");
	puts("  -r, --(keep|remove)-changes  Keep RFUs and change marks from old issue. In -m mode, remove them.");
	puts("  -s, --(keep|change)-date     Do not change issue date. In -m mode, change issue date.");
	puts("  -t, --type <urt>             Set the updateReasonType of the last RFU.");
	puts("  -u, --clean-rfus             Remove unassociated RFUs.");
	puts("  -w, --lock                   Make old and official issues read-only.");
	puts("  -z, --issue-type <type>      Set the issue type of the new issue.");
	puts("  -^, --remove-deleted         Remove \"delete\"d elements.");
	puts("  --version                    Show version information");
	LIBXML2_PARSE_LONGOPT_HELP
}

/* Show version information. */
static void show_version(void)
{
	printf("%s (s1kd-tools) %s\n", PROG_NAME, VERSION);
	printf("Using libxml %s\n", xmlParserVersion);
}

/* Remove change markup attributes from elements referencing old RFUs */
static void del_assoc_rfu_attrs(xmlNodePtr rfu, xmlXPathContextPtr ctx)
{
	xmlXPathObjectPtr obj;
	char *rfuid;

	rfuid = (char *) xmlGetProp(rfu, BAD_CAST "id");

	obj = xmlXPathEvalExpression(BAD_CAST "//*[@reasonForUpdateRefIds]", ctx);

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		int i;

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			char *ids, *id = NULL;
			bool used = false;

			ids = (char *) xmlGetProp(obj->nodesetval->nodeTab[i], BAD_CAST "reasonForUpdateRefIds");

			while ((id = strtok(id ? NULL : ids, " "))) {
				if (strcmp(id, rfuid) == 0) {
					used = true;
					break;
				}
			}

			xmlFree(ids);

			if (used) {
				xmlUnsetProp(obj->nodesetval->nodeTab[i], BAD_CAST "changeType");
				xmlUnsetProp(obj->nodesetval->nodeTab[i], BAD_CAST "changeMark");
				xmlUnsetProp(obj->nodesetval->nodeTab[i], BAD_CAST "reasonForUpdateRefIds");
			}
		}
	}

	xmlXPathFreeObject(obj);
	xmlFree(rfuid);
}

/* Determine if an RFU is ever referenced */
static bool rfu_used(xmlNodePtr rfu, xmlXPathContextPtr ctx)
{
	xmlXPathObjectPtr obj;
	bool ret = false;
	char *rfuid;

	rfuid = (char *) xmlGetProp(rfu, BAD_CAST "id");

	obj = xmlXPathEvalExpression(BAD_CAST "//@reasonForUpdateRefIds", ctx);

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		int i;

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			char *ids, *id = NULL;

			ids = (char *) xmlNodeGetContent(obj->nodesetval->nodeTab[i]);

			while ((id = strtok(id ? NULL : ids, " "))) {
				if (strcmp(id, rfuid) == 0) {
					ret = true;
					break;
				}
			}

			xmlFree(ids);

			if (ret) {
				break;
			}
		}
	}

	xmlXPathFreeObject(obj);
	xmlFree(rfuid);

	return ret;
}

/* Remove RFUs which are never referenced */
static void rem_unassoc_rfus(xmlDocPtr doc)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;

	ctx = xmlXPathNewContext(doc);
	obj = xmlXPathEvalExpression(BAD_CAST "//reasonForUpdate", ctx);

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		int i;

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			if (!rfu_used(obj->nodesetval->nodeTab[i], ctx)) {
				xmlUnlinkNode(obj->nodesetval->nodeTab[i]);
				xmlFreeNode(obj->nodesetval->nodeTab[i]);
				obj->nodesetval->nodeTab[i] = NULL;
			}
		}
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);
}

/* Remove all change markup attributes */
static void del_rfu_attrs(xmlXPathContextPtr ctx, bool iss30)
{
	xmlXPathObjectPtr obj;
	const xmlChar *change, *mark, *rfc;

	if (iss30) {
		change = BAD_CAST "change";
		mark = BAD_CAST "mark";
		rfc = BAD_CAST "rfc";
		obj = xmlXPathEvalExpression(BAD_CAST "//*[@change or @mark or @rfc or @level]", ctx);
	} else {
		change = BAD_CAST "changeType";
		mark = BAD_CAST "changeMark";
		rfc = BAD_CAST "reasonForUpdateRefIds";
		obj = xmlXPathEvalExpression(BAD_CAST "//*[@changeType or @changeMark or @reasonForUpdateRefIds]", ctx);
	}

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		int i;

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			xmlChar *type;

			type = xmlGetProp(obj->nodesetval->nodeTab[i], change);

			if (xmlStrcmp(type, BAD_CAST "delete") == 0) {
				xmlUnlinkNode(obj->nodesetval->nodeTab[i]);
				xmlFreeNode(obj->nodesetval->nodeTab[i]);
				obj->nodesetval->nodeTab[i] = NULL;
			} else {
				xmlUnsetProp(obj->nodesetval->nodeTab[i], change);
				xmlUnsetProp(obj->nodesetval->nodeTab[i], mark);
				xmlUnsetProp(obj->nodesetval->nodeTab[i], rfc);

				if (iss30) {
					xmlUnsetProp(obj->nodesetval->nodeTab[i], BAD_CAST "level");
				}
			}

			xmlFree(type);
		}
	}

	xmlXPathFreeObject(obj);
}

/* Remove changeInline elements. */
static void del_change_inline(xmlNodePtr node, bool iss30)
{
	bool remove;
	xmlNodePtr cur;

	/* Remove <change> (3.0-) or <changeInline> (4.0+) elements only if the
	 * change attributes have been removed (so that in -R mode,
	 * unassociated inline change elements will be kept). */
	if (iss30) {
		remove = xmlStrcmp(node->name, BAD_CAST "change") == 0 && !(xmlHasProp(node, BAD_CAST "mark") || xmlHasProp(node, BAD_CAST "change") || xmlHasProp(node, BAD_CAST "rfc"));
	} else{
		remove = xmlStrcmp(node->name, BAD_CAST "changeInline") == 0 && !(xmlHasProp(node, BAD_CAST "changeMark") || xmlHasProp(node, BAD_CAST "changeType") || xmlHasProp(node, BAD_CAST "reasonForUpdateRefIds"));
	}

	/* Apply to descendants first to remove nested changeInlines. */
	cur = node->children;
	while (cur) {
		xmlNodePtr next = cur->next;
		del_change_inline(cur, iss30);
		cur = next;
	}

	/* Merge children into parent. */
	if (remove) {
		cur = node->last;
		while (cur) {
			xmlNodePtr prev = cur->prev;
			xmlAddNextSibling(node, cur);
			cur = prev;
		}

		xmlUnlinkNode(node);
		xmlFreeNode(node);
	}
}

/* Delete old RFUs */
static void del_rfus(xmlDocPtr doc, bool only_assoc, bool iss30)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;

	ctx = xmlXPathNewContext(doc);
	obj = xmlXPathEvalExpression(BAD_CAST "//reasonForUpdate", ctx);

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		int i;

		if (only_assoc) {
			for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
				del_assoc_rfu_attrs(obj->nodesetval->nodeTab[i], ctx);
				xmlUnlinkNode(obj->nodesetval->nodeTab[i]);
				xmlFreeNode(obj->nodesetval->nodeTab[i]);
				obj->nodesetval->nodeTab[i] = NULL;
			}
		} else {
			for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
				xmlUnlinkNode(obj->nodesetval->nodeTab[i]);
				xmlFreeNode(obj->nodesetval->nodeTab[i]);
				obj->nodesetval->nodeTab[i] = NULL;
			}

			del_rfu_attrs(ctx, iss30);
		}
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);

	del_change_inline(xmlDocGetRootElement(doc), iss30);
}

static void del_marks(xmlDocPtr doc, bool iss30)
{
	xmlXPathContextPtr ctx;

	ctx = xmlXPathNewContext(doc);
	del_rfu_attrs(ctx, iss30);
	xmlXPathFreeContext(ctx);

	del_change_inline(xmlDocGetRootElement(doc), iss30);
}

static void set_unverified(xmlDocPtr doc, bool iss30)
{
	xmlNodePtr qa, cur;

	qa = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//qa" : "//qualityAssurance"));

	if (!qa)
		return;

	cur = qa->children;
	while (cur) {
		xmlNodePtr next = cur->next;
		xmlUnlinkNode(cur);
		xmlFreeNode(cur);
		cur = next;
	}

	xmlNewChild(qa, NULL, BAD_CAST (iss30 ? "unverif" : "unverified"), NULL);
}

static void set_qa(xmlDocPtr doc, char *firstver, char *secondver, bool iss30)
{
	xmlNodePtr qa, unverif, ver1, ver2;

	if (!(firstver || secondver))
		return;

	qa = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//qa" : "//qualityAssurance"));

	if (!qa)
		return;

	unverif = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//unverif" : "//unverified"));

	if (unverif) {
		xmlUnlinkNode(unverif);
		xmlFreeNode(unverif);
	}

	ver1 = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//firstver" : "//firstVerification"));
	ver2 = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//secver" : "//secondVerification"));

	if (firstver) {
		if (!secondver) {
			xmlNodePtr ver2;
			ver2 = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? "//secver" : "//secondVerification"));
			if (ver2) {
				xmlUnlinkNode(ver2);
				xmlFreeNode(ver2);
			}
		}

		if (ver1) {
			xmlUnlinkNode(ver1);
			xmlFreeNode(ver1);
		}

		ver1 = xmlNewChild(qa, NULL, BAD_CAST (iss30 ? "firstver" : "firstVerification"), NULL);
		xmlSetProp(ver1, BAD_CAST (iss30 ? "type" : "verificationType"), BAD_CAST firstver);
	}

	if (secondver) {
		if (!ver1) {
			ver1 = xmlNewChild(qa, NULL, BAD_CAST (iss30 ? "firstver" : "firstVerification"), NULL);
			xmlSetProp(ver1, BAD_CAST (iss30 ? "type" : "verificationType"), BAD_CAST secondver);
		}

		if (ver2) {
			xmlUnlinkNode(ver2);
			xmlFreeNode(ver2);
		}

		ver2 = xmlNewChild(qa, NULL, BAD_CAST (iss30 ? "secver" : "secondVerification"), NULL);
		xmlSetProp(ver2, BAD_CAST (iss30 ? "type" : "verificationType"), BAD_CAST secondver);
	}
}

/* Add RFUs to the upissued object. */
#define ISS_30_RFU_PATH "(//qa|//sbc|//fic|//idstatus//ein|//skill|//rfu)[last()]"
#define ISS_4X_RFU_PATH "(//qualityAssurance|//systemBreakdownCode|//functionalItemCode|//identAndStatusSection//functionalItemRef|//skillLevel|//reasonForUpdate)[last()]"

static void add_rfus(xmlDocPtr doc, xmlNodePtr rfus, bool iss30)
{
	xmlNodePtr node, cur, next;

	node = xpath_first_node(doc, NULL, BAD_CAST (iss30 ? ISS_30_RFU_PATH : ISS_4X_RFU_PATH));

	if (!node) {
		return;
	}

	next = xmlNextElementSibling(node);

	while (next && (
		xmlStrcmp(next->name, BAD_CAST "rfu") == 0 ||
		xmlStrcmp(next->name, BAD_CAST "reasonForUpdate") == 0)) {
		node = next;
		next = xmlNextElementSibling(node);
	}

	for (cur = rfus->last; cur; cur = cur->prev) {
		xmlNodePtr rfu;

		rfu = xmlCopyNode(cur, 1);

		if (iss30) {
			xmlNodeSetName(rfu, BAD_CAST "rfu");
			xmlUnsetProp(rfu, BAD_CAST "updateReasonType");
			xmlUnsetProp(rfu, BAD_CAST "updateHighlight");
		} else {
			xmlChar *content;

			content = xmlNodeGetContent(rfu);
			xmlNodeSetContent(rfu, NULL);
			xmlNewChild(rfu, NULL, BAD_CAST "simplePara", content);
			xmlFree(content);
		}

		xmlAddNextSibling(node, rfu);
	}
}

static void set_iss_date(xmlDocPtr dmdoc, const char *issdate)
{
	char year_s[5], month_s[3], day_s[3];
	xmlNodePtr issueDate;

	issueDate = xpath_first_node(dmdoc, NULL, BAD_CAST "//issueDate|//issdate");

	if (issdate) {
		sscanf(issdate, "%4s-%2s-%2s", year_s, month_s, day_s);
	} else {
		time_t now;
		struct tm *local;
		unsigned short year, month, day;

		time(&now);
		local = localtime(&now);

		year = local->tm_year + 1900;
		month = local->tm_mon + 1;
		day = local->tm_mday;

		if (snprintf(year_s, 5, "%u", year) < 0 ||
		    snprintf(month_s, 3, "%.2u", month) < 0 ||
		    snprintf(day_s, 3, "%.2u", day) < 0)
			exit(EXIT_BAD_DATE);
	}

	xmlSetProp(issueDate, (xmlChar *) "year",  (xmlChar *) year_s);
	xmlSetProp(issueDate, (xmlChar *) "month", (xmlChar *) month_s);
	xmlSetProp(issueDate, (xmlChar *) "day",   (xmlChar *) day_s);
}

static void set_status(xmlDocPtr dmdoc, const char *status, bool iss30, xmlNodePtr issueInfo)
{
	xmlNodePtr dmStatus;

	if (iss30) {
		xmlSetProp(issueInfo, BAD_CAST "type", BAD_CAST status);
	} else {
		if ((dmStatus = xpath_first_node(dmdoc, NULL, BAD_CAST "//dmStatus|//pmStatus"))) {
			xmlSetProp(dmStatus, BAD_CAST "issueType", BAD_CAST status);
		}
	}
}

/* Upissue options */
static bool print_fnames = false;
static bool newissue = false;
static bool overwrite = false;
static char *status = NULL;
static bool no_issue = false;
static bool keep_rfus = false;
static bool set_date = true;
static bool only_assoc_rfus = false;
static bool reset_qa = true;
static bool dry_run = false;
static char *firstver = NULL;
static char *secondver = NULL;
static xmlNodePtr rfus = NULL;
static bool lock = false;
static bool remdel= false;
static bool remold = false;
static bool only_mod = false;
static bool clean_rfus = false;
static char *issdate = NULL;
static bool remove_marks = false;
static bool set_unverif = false;

static void upissue(const char *path)
{
	char *issueNumber = NULL;
	char *inWork = NULL;
	int issueNumber_int = 0;
	int inWork_int = 0;
	char dmfile[PATH_MAX], cpfile[PATH_MAX];
	xmlDocPtr dmdoc;
	xmlNodePtr issueInfo;
	xmlChar *issno_name, *inwork_name;
	bool iss30 = false;
	int up_issueNumber_int = 0;
	int up_inWork_int = 0;
	char upissued_issueNumber[32];
	char upissued_inWork[32];
	char *p, *i = NULL;

	strcpy(dmfile, path);

	if (access(dmfile, F_OK) == -1 && strcmp(dmfile, "-") != 0) {
		if (verbosity >= NORMAL) {
			fprintf(stderr, ERR_PREFIX "Could not read file %s.\n", dmfile);
		}
		exit(EXIT_NO_FILE);
	}

	dmdoc = read_xml_doc(dmfile);

	if (dmdoc) {
		issueInfo = xpath_first_node(dmdoc, NULL, BAD_CAST "//issueInfo|//issno");
	} else {
		issueInfo = NULL;
	}

	if (!issueInfo && no_issue) {
		if (verbosity >= NORMAL) {
			fprintf(stderr, E_NON_XML_STDIN);
		}
		exit(EXIT_NO_OVERWRITE);
	}

	/* Apply modifications without actually upissuing. */
	if (only_mod) {
		iss30 = xmlStrcmp(issueInfo->name, BAD_CAST "issueInfo") != 0;

		if (clean_rfus && !iss30) {
			rem_unassoc_rfus(dmdoc);
		}

		if (remdel) {
			rem_delete_elems(dmdoc);
		}

		if (set_unverif) {
			set_unverified(dmdoc, iss30);
		}

		add_rfus(dmdoc, rfus, iss30);
		set_qa(dmdoc, firstver, secondver, iss30);

		if (status) {
			set_status(dmdoc, status, iss30, issueInfo);
		}

		/* The following options have the opposite effect in -m mode:
		 * -s sets the date
		 * -r removes RFUs
		 */
		if (!set_date) {
			set_iss_date(dmdoc, issdate);
		}
		if (keep_rfus) {
			del_rfus(dmdoc, only_assoc_rfus, iss30);
		} else if (remove_marks) {
			del_marks(dmdoc, iss30);
		}

		if (overwrite) {
			save_xml_doc(dmdoc, dmfile);
		} else {
			save_xml_doc(dmdoc, "-");
		}

		xmlFreeDoc(dmdoc);

		return;
	}

	p = strchr(dmfile, '_');

	/* Issue info from XML */
	if (issueInfo) {
		i = p + 1;

		iss30 = strcmp((char *) issueInfo->name, "issueInfo") != 0;

		if (iss30) {
			issno_name = BAD_CAST "issno";
			inwork_name = BAD_CAST "inwork";
		} else {
			issno_name = BAD_CAST "issueNumber";
			inwork_name = BAD_CAST "inWork";
		}

		issueNumber = (char *) xmlGetProp(issueInfo, issno_name);
		inWork = (char *) xmlGetProp(issueInfo, inwork_name);

		if (!inWork) {
			inWork = strdup("00");
		}
	/* Get issue/inwork from filename only */
	} else if (p) {
		i = p + 1;

		if (i > dmfile + strlen(dmfile) - 6) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_BAD_FILENAME);
			}
			exit(EXIT_BAD_FILENAME);
		}

		issueNumber = calloc(4, 1);
		inWork = calloc(3, 1);

		strncpy(issueNumber, i, 3);
		strncpy(inWork, i + 4, 2);
	/* Get issue from ICN */
	} else if ((p = strchr(dmfile, '-'))) {
		int n, c = 0;
		int l;

		if (!newissue) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_ICN_INWORK);
			}
			exit(EXIT_ICN_INWORK);
		}

		l = strlen(dmfile);

		/* Get second-to-last '-' */
		for (n = l; n >= 0; --n) {
			if (dmfile[n] == '-') {
				if (c == 1) {
					break;
				} else {
					++c;
				}
			}
		}

		i = dmfile + n + 1;

		if (n == -1 || i > dmfile + l - 6) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_BAD_FILENAME);
			}
			exit(EXIT_BAD_FILENAME);
		}

		issueNumber = calloc(4, 1);
		strncpy(issueNumber, i, 3);
	} else {
		if (verbosity >= NORMAL) {
			fprintf(stderr, E_BAD_FILENAME);
		}
		exit(EXIT_BAD_FILENAME);
	}

	if ((issueNumber_int = atoi(issueNumber)) >= 999) {
		if (verbosity >= NORMAL) {
			fprintf(stderr, E_ISSUE_TOO_LARGE, dmfile);
		}
		exit(EXIT_ISSUE_TOO_LARGE);
	}
	if (inWork) {
		if ((inWork_int = atoi(inWork)) >= 99) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_INWORK_TOO_LARGE, dmfile);
			}
			exit(EXIT_ISSUE_TOO_LARGE);
		}
	}

	if (newissue) {
		up_issueNumber_int = issueNumber_int + 1;
		if (inWork) {
			up_inWork_int = 0;
		}
	} else {
		up_issueNumber_int = issueNumber_int;
		if (inWork) {
			up_inWork_int = inWork_int + 1;
		}
	}
	snprintf(upissued_issueNumber, 32, "%.3d", up_issueNumber_int);
	snprintf(upissued_inWork, 32, "%.2d", up_inWork_int);

	if (issueInfo) {
		xmlSetProp(issueInfo, issno_name, BAD_CAST upissued_issueNumber);
		xmlSetProp(issueInfo, inwork_name, BAD_CAST upissued_inWork);

		/* Optionally cleanup unused RFUs */
		if (clean_rfus && !iss30) {
			rem_unassoc_rfus(dmdoc);
		}

		/* When upissuing an official module to first inwork issue... */
		if (strcmp(inWork, "00") == 0) {
				/* Delete RFUs */
				if (!keep_rfus) {
					del_rfus(dmdoc, only_assoc_rfus, iss30);
				}

				/* Set unverified */
				if (reset_qa) {
					set_unverified(dmdoc, iss30);
				}
		/* Or, perform certain actions any time. */
		} else {
			if (remdel) {
				rem_delete_elems(dmdoc);
			}

			if (set_unverif) {
				set_unverified(dmdoc, iss30);
			}
		}

		if (set_date) {
			set_iss_date(dmdoc, issdate);
		}

		set_qa(dmdoc, firstver, secondver, iss30);
		add_rfus(dmdoc, rfus, iss30);

		/* If an issue type is specified, use that. */
		if (status) {
			set_status(dmdoc, status, iss30, issueInfo);
		/* Otherwise:
		 * - if the object is official, default to "status"
		 * - if the object is not official, keep the previous issue type. */
		} else if (inWork_int == 0) {
			set_status(dmdoc, "status", iss30, issueInfo);
		}

		if (remove_marks) {
			del_marks(dmdoc, iss30);
		}
	}

	xmlFree(issueNumber);
	xmlFree(inWork);

	if (!dmdoc) { /* Preserve non-XML filename for copying */
		strcpy(cpfile, dmfile);
	}

	if (!no_issue) {
		if (!dry_run) {
			if (remold && dmdoc) { /* Delete previous issue (XML file) */
				remove(dmfile);
			} else if (lock) { /* Remove write permission from previous issue. */
				mkreadonly(dmfile);
			}
		}

		if (p) {
			memcpy(i, upissued_issueNumber, 3);
			if (inWork) {
				memcpy(i + 4, upissued_inWork, 2);
			}
		}
	}

	if (!dry_run) {
		if (!overwrite && access(dmfile, F_OK) != -1) {
			if (verbosity >= NORMAL) {
				fprintf(stderr, E_FILE_EXISTS, dmfile);
			}
			exit(EXIT_NO_OVERWRITE);
		}

		if (dmdoc) {
			save_xml_doc(dmdoc, dmfile);
		} else { /* Copy non-XML file */
			copy(cpfile, dmfile);

			if (remold) { /* Delete previous issue (non-XML file) */
				remove(cpfile);
			}
		}

		/* Lock official issues. */
		if (lock && newissue) {
			mkreadonly(dmfile);
		}
	}

	if (verbosity >= VERBOSE) {
		fprintf(stderr, I_UPISSUE, path, dmfile);
	}

	if (print_fnames) {
		puts(dmfile);
	}

	if (dmdoc) {
		xmlFreeDoc(dmdoc);
	}
}

static void upissue_list(const char *path)
{
	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");
		upissue(line);
	}

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

int main(int argc, char **argv)
{
	int i;
	bool islist = false;

	const char *sopts = "ivsNfrRI:Qq01:2:45delc:t:Hwmuz:^h?";
	struct option lopts[] = {
		{"version"           , no_argument      , 0, 0},
		{"help"              , no_argument      , 0, 'h'},
		{"unverified"        , no_argument      , 0, '0'},
		{"first-ver"         , required_argument, 0, '1'},
		{"second-ver"        , required_argument, 0, '2'},
		{"remove-marks"      , no_argument      , 0, '4'},
		{"print"             , no_argument      , 0, '5'},
		{"reason"            , required_argument, 0, 'c'},
		{"dry-run"           , no_argument      , 0, 'd'},
		{"erase"             , no_argument      , 0, 'e'},
		{"overwrite"         , no_argument      , 0, 'f'},
		{"keep-date"         , no_argument      , 0, 's'},
		{"change-date"       , no_argument      , 0, 's'},
		{"official"          , no_argument      , 0, 'i'},
		{"list"              , no_argument      , 0, 'l'},
		{"modify"            , no_argument      , 0, 'm'},
		{"omit-issue"        , no_argument      , 0, 'N'},
		{"keep-qa"           , no_argument      , 0, 'Q'},
		{"quiet"             , no_argument      , 0, 'q'},
		{"keep-unassoc-marks", no_argument      , 0, 'R'},
		{"keep-changes"      , no_argument      , 0, 'r'},
		{"remove-changes"    , no_argument      , 0, 'r'},
		{"date"              , required_argument, 0, 'I'},
		{"type"              , required_argument, 0, 't'},
		{"clean-rfus"        , no_argument      , 0, 'u'},
		{"highlight"         , no_argument      , 0, 'H'},
		{"verbose"           , no_argument      , 0, 'v'},
		{"lock"              , no_argument      , 0, 'w'},
		{"issue-type"        , required_argument, 0, 'z'},
		{"remove-deleted"    , no_argument      , 0, '^'},
		LIBXML2_PARSE_LONGOPT_DEFS
		{0, 0, 0, 0}
	};
	int loptind = 0;

	rfus = xmlNewNode(NULL, BAD_CAST "rfus");

	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 '0':
				set_unverif = true;
				break;
			case '1':
				firstver = strdup(optarg);
				break;
			case '2':
				secondver = strdup(optarg);
				break;
			case '4':
				remove_marks = true;
				break;
			case '5':
				print_fnames = true;
				break;
			case 'c':
				xmlNewChild(rfus, NULL, BAD_CAST "reasonForUpdate", BAD_CAST optarg);
				break;
			case 'd':
				dry_run = true;
				break;
			case 'e':
				remold = true;
				break;
			case 'f':
				overwrite = true;
				break;
			case 'I':
				issdate = strdup(optarg);
				break;
			case 'i':
				newissue = true;
				break;
			case 'l':
				islist = true;
				break;
			case 'm':
				only_mod = true;
				no_issue = true;
				break;
			case 'N':
				no_issue = true;
				overwrite = true;
				break;
			case 'Q':
				reset_qa = false;
				break;
			case 'q':
				--verbosity;
				break;
			case 'R':
				only_assoc_rfus = true;
				break;
			case 'r':
				keep_rfus = true;
				break;
			case 's':
				set_date = false;
				break;
			case 't':
				xmlSetProp(rfus->last, BAD_CAST "updateReasonType", BAD_CAST optarg);
				break;
			case 'u':
				clean_rfus = true;
				break;
			case 'H':
				xmlSetProp(rfus->last, BAD_CAST "updateHighlight", BAD_CAST "1");
				break;
			case 'v':
				++verbosity;
				break;
			case 'w':
				lock = true;
				break;
			case 'z':
				status = strdup(optarg);
				if (!(strcmp(status, "changed") == 0 || strcmp(status, "rinstate-changed") == 0)) {
					remove_marks = true;
				}
				break;
			case '^':
				remdel = true;
				break;
			case 'h':
			case '?':
				show_help();
				return 0;
		}
	}

	if (optind < argc) {
		for (i = optind; i < argc; i++) {
			if (islist) {
				upissue_list(argv[i]);
			} else {
				upissue(argv[i]);
			}
		}
	} else if (islist) {
		upissue_list(NULL);
	} else {
		no_issue = true;
		overwrite = true;
		upissue("-");
	}

	free(firstver);
	free(secondver);
	free(status);
	free(issdate);
	xmlFreeNode(rfus);

	xmlCleanupParser();

	return 0;
}