#include <stdio.h>

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <dirent.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxslt/transform.h>
#include "s1kd_tools.h"
#include "xsl.h"

/* Program information. */
#define PROG_NAME "s1kd-repcheck"
#define VERSION "1.10.0"

/* Message prefixes. */
#define ERR_PREFIX PROG_NAME ": ERROR: "
#define WRN_PREFIX PROG_NAME ": WARNING: "
#define INF_PREFIX PROG_NAME ": INFO: "
#define SUC_PREFIX PROG_NAME ": SUCCESS: "
#define FLD_PREFIX PROG_NAME ": FAILED: "

/* Error messages. */
#define E_MAX_OBJECTS ERR_PREFIX "Out of memory\n"
#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"
#define E_NOT_FOUND ERR_PREFIX "%s (%ld): %s not found.\n"
#define E_UNHANDLED_REF ERR_PREFIX "Unhandled CIR ref type: %s\n"

/* Warning messages. */
#define W_MISSING_REF_DM WRN_PREFIX "Could not read referenced object: %s\n"

/* Informational messages. */
#define I_CHECK INF_PREFIX "Checking CIR references in %s...\n"
#define I_SEARCH_PART INF_PREFIX "Searching for %s in CIR %s...\n"
#define I_FOUND INF_PREFIX "Found %s in CIR %s\n"
#define I_NOT_FOUND INF_PREFIX "Not found in CIR %s\n"
#define I_FIND_CIR INF_PREFIX "Searching for CIRs in \"%s\"...\n"
#define I_FIND_CIR_FOUND INF_PREFIX "Found CIR %s...\n"
#define I_FIND_CIR_ADD INF_PREFIX "Added CIR %s\n"

/* Success messages. */
#define S_VALID SUC_PREFIX "All CIR references were resolved in %s.\n"

/* Failure messages. */
#define F_INVALID FLD_PREFIX "Could not resolve some CIR references in %s.\n"

/* Exit status codes. */
#define EXIT_MAX_OBJECTS 2

/* Progress formats. */
#define PROGRESS_OFF 0
#define PROGRESS_CLI 1
#define PROGRESS_ZENITY 2

/* Namespace for special attributes used to extract CIR references. */
#define S1KD_REPCHECK_NS BAD_CAST "urn:s1kd-tools:s1kd-repcheck"

/* Verbosity of messages. */
enum verbosity { QUIET, NORMAL, VERBOSE, DEBUG };

/* List of CSDB objects. */
struct objects {
char (*paths)[PATH_MAX];
unsigned count;
unsigned max;
};

enum show_filenames { SHOW_NONE, SHOW_INVALID, SHOW_VALID };

/* Program options. */
struct opts {
enum verbosity verbosity;
enum show_filenames show_filenames;
char *search_dir;
bool recursive;
bool no_issue;
bool search_all_objs;
bool output_valid;
bool list_refs;
bool rem_delete;
xmlDocPtr cir_refs_xsl;
char *type;
struct objects objects;
struct objects cirs;
xmlNodePtr report;
};

/* Match a CIR ref to a CIR spec in a given CIR data module. */
static xmlNodePtr find_ref_in_cir(xmlNodePtr ref, const xmlChar *ident, const xmlChar *xpath, const char *cirpath, struct opts *opts)
{
xmlDocPtr doc;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;
xmlNodePtr node = NULL;

if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_SEARCH_PART, ident, cirpath);
}

if (!(doc = read_xml_doc(cirpath))) {
return NULL;
}

if (opts->rem_delete) {
rem_delete_elems(doc);
}

ctx = xmlXPathNewContext(doc);

if ((obj = xmlXPathEvalExpression(xpath, ctx))) {
if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_NOT_FOUND, cirpath);
}
} else {
node = obj->nodesetval->nodeTab[0];

if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_FOUND, ident, cirpath);
}
}
}

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);

xmlFreeDoc(doc);

return node;
}

/* Add a reference to the XML report. */
static void add_ref_to_report(xmlNodePtr rpt, xmlNodePtr ref, const xmlChar *type, const xmlChar *ident, long int lineno, const char *cir, struct opts *opts)
{
xmlNodePtr node;
xmlChar line_s[16], *xpath;

/* Check if XML report is enabled. */
if (!rpt) {
return;
}

node = xmlNewChild(rpt, NULL, BAD_CAST "ref", NULL);

xmlSetProp(node, BAD_CAST "type", type);
xmlSetProp(node, BAD_CAST "name", ident);

xmlStrPrintf(line_s, 16, "%ld", lineno);
xmlSetProp(node, BAD_CAST "line", BAD_CAST line_s);

xpath = xpath_of(ref);
xmlSetProp(node, BAD_CAST "xpath", xpath);
xmlFree(xpath);

if (cir) {
xmlSetProp(node, BAD_CAST "cir", BAD_CAST cir);
}

node = xmlAddChild(node, xmlCopyNode(ref, 1));
}

/* Find a data module filename in the current directory based on the dmRefIdent
* element. */
static bool find_dmod_fname(char *dst, xmlNodePtr dmRefIdent, struct opts *opts)
{
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 = xpath_first_node(NULL, dmRefIdent, BAD_CAST "dmCode|avee");
issueInfo = xpath_first_node(NULL, dmRefIdent, BAD_CAST "issueInfo|issno");
language = xpath_first_node(NULL, dmRefIdent, BAD_CAST "language");

model_ident_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "modelic|@modelIdentCode");
system_diff_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "sdc|@systemDiffCode");
system_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "chapnum|@systemCode");
sub_system_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "section|@subSystemCode");
sub_sub_system_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "subsect|@subSubSystemCode");
assy_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "subject|@assyCode");
disassy_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "discode|@disassyCode");
disassy_code_variant = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "discodev|@disassyCodeVariant");
info_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "incode|@infoCode");
info_code_variant = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "incodev|@infoCodeVariant");
item_location_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "itemloc|@itemLocationCode");
learn_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "@learnCode");
learn_event_code = (char *) xpath_first_value(NULL, dmCode, BAD_CAST "@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 (!opts->no_issue) {
if (issueInfo) {
char *issue_number;
char *in_work;
char iss[8];

issue_number = (char *) xpath_first_value(NULL, issueInfo, BAD_CAST "@issno|@issueNumber");
in_work = (char *) xpath_first_value(NULL, issueInfo, BAD_CAST "@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 *) xpath_first_value(NULL, language, BAD_CAST "@language|@languageIsoCode");
country_iso_code = (char *) xpath_first_value(NULL, language, BAD_CAST "@country|@countryIsoCode");

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

xmlFree(language_iso_code);
xmlFree(country_iso_code);
}

/* Look for DM in the directory hierarchy. */
if (find_csdb_object(dst, opts->search_dir, code, is_dm, opts->recursive)) {
return true;
}

/* Look for DM in the list of CIRs. */
if (find_csdb_object_in_list(dst, opts->cirs.paths, opts->cirs.count, code)) {
return true;
}

/* Look for DM in the list of objects to check. */
if (find_csdb_object_in_list(dst, opts->objects.paths, opts->objects.count, code)) {
return true;
}

fprintf(stderr, W_MISSING_REF_DM, code);
return false;
}

/* Remove namespace declaration added by tool. */
static void remove_repcheck_ns(xmlNodePtr node)
{
xmlNsPtr cur, prev;

cur = node->nsDef;
prev = NULL;

while (cur) {
xmlNsPtr next;

next = cur->next;

if (xmlStrcmp(cur->href, S1KD_REPCHECK_NS) == 0) {
if (prev == NULL) {
node->nsDef = next;
} else {
prev->next = next;
}

xmlFreeNode((xmlNodePtr) cur);
} else {
prev = cur;
}

cur = next;
}
}

/* Remove attributes added by tool. */
static void remove_repcheck_attrs(xmlNodePtr ref, xmlNsPtr ns)
{
xmlUnsetNsProp(ref, ns, BAD_CAST "type");
xmlUnsetNsProp(ref, ns, BAD_CAST "name");
xmlUnsetNsProp(ref, ns, BAD_CAST "test");
remove_repcheck_ns(ref);
}

/* Check a specific CIR reference. */
static int check_cir_ref(xmlNodePtr ref, const char *path, xmlNodePtr rpt, struct opts *opts)
{
int i, err = 0;
xmlAttrPtr type_attr, ident_attr, xpath_attr;
xmlChar *type, *ident, *xpath;
long int lineno;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;

lineno = xmlGetLineNo(ref);

type_attr = xmlHasNsProp(ref, BAD_CAST "type", S1KD_REPCHECK_NS);
ident_attr = xmlHasNsProp(ref, BAD_CAST "name", S1KD_REPCHECK_NS);
xpath_attr = xmlHasNsProp(ref, BAD_CAST "test", S1KD_REPCHECK_NS);

type = xmlNodeGetContent((xmlNodePtr) type_attr);
ident = xmlNodeGetContent((xmlNodePtr) ident_attr);
xpath = xmlNodeGetContent((xmlNodePtr) xpath_attr);

remove_repcheck_attrs(ref, ident_attr->ns);

/* Check if there is an explicit CIR reference. */
ctx = xmlXPathNewContext(ref->doc);
xmlXPathSetContextNode(ref, ctx);
obj = xmlXPathEvalExpression(BAD_CAST "refs/dmRef/dmRefIdent|refs/refdm", ctx);

/* If there is not, use any of the specified/found CIRs. */
if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
/* Search in all CIRs. */
for (i = 0; i < opts->cirs.count; ++i) {
if (find_ref_in_cir(ref, ident, xpath, opts->cirs.paths[i], opts)) {
add_ref_to_report(rpt, ref, type, ident, lineno, opts->cirs.paths[i], opts);
goto done;
}
}

/* Search in all other specified objects, if allowed. */
if (opts->search_all_objs) {
for (i = 0; i < opts->objects.count; ++i) {
if (find_ref_in_cir(ref, ident, xpath, opts->objects.paths[i], opts)) {
add_ref_to_report(rpt, ref, type, ident, lineno, opts->objects.paths[i], opts);
goto done;
}
}
}
/* If there is an explicit reference, only check against that. */
} else {
for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
char fname[PATH_MAX];

if (find_dmod_fname(fname, obj->nodesetval->nodeTab[i], opts)) {
if (find_ref_in_cir(ref, ident, xpath, fname, opts)) {
add_ref_to_report(rpt, ref, type, ident, lineno, fname, opts);
goto done;
}
}
}
}

if (opts->verbosity >= NORMAL) {
fprintf(stderr, E_NOT_FOUND, path, lineno, ident);
}
add_ref_to_report(rpt, ref, type, ident, lineno, NULL, opts);
err = 1;

done:
xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);
xmlFree(type);
xmlFree(ident);
xmlFree(xpath);

return err;
}

/* List a CIR reference without validating it. */
static void list_cir_ref(const xmlNodePtr ref, const char *path, xmlNodePtr rpt, struct opts *opts)
{
xmlAttrPtr type_attr, ident_attr;
xmlChar *type, *ident;
long int lineno;

lineno = xmlGetLineNo(ref);

type_attr = xmlHasNsProp(ref, BAD_CAST "type", S1KD_REPCHECK_NS);
ident_attr = xmlHasNsProp(ref, BAD_CAST "name", S1KD_REPCHECK_NS);

type = xmlNodeGetContent((xmlNodePtr) type_attr);
ident = xmlNodeGetContent((xmlNodePtr) ident_attr);

remove_repcheck_attrs(ref, ident_attr->ns);

if (rpt) {
add_ref_to_report(rpt, ref, type, ident, lineno, NULL, opts);
} else {
printf("%s:%ld:%s\n", path, lineno, (char *) ident);
}

xmlFree(type);
xmlFree(ident);
}

/* Check all CIR references in a document. */
static int check_cir_refs(xmlDocPtr doc, const char *path, struct opts *opts)
{
int err = 0;
xmlDocPtr styledoc, res;
xsltStylesheetPtr style;
xmlNodePtr rpt;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;

/* Add object to report. */
if (opts->report) {
rpt = xmlNewChild(opts->report, NULL, BAD_CAST "object", NULL);
xmlSetProp(rpt, BAD_CAST "path", BAD_CAST path);
} else {
rpt = NULL;
}

styledoc = xmlCopyDoc(opts->cir_refs_xsl, 1);
style = xsltParseStylesheetDoc(styledoc);

res = xsltApplyStylesheet(style, doc, NULL);

ctx = xmlXPathNewContext(res);
xmlXPathRegisterNs(ctx, BAD_CAST "s1kd-repcheck", S1KD_REPCHECK_NS);
if (opts->type) {
xmlXPathRegisterVariable(ctx, BAD_CAST "type", xmlXPathNewString(BAD_CAST opts->type));
obj = xmlXPathEval(BAD_CAST "//*[@s1kd-repcheck:test and @s1kd-repcheck:type=$type]", ctx);
} else {
obj = xmlXPathEval(BAD_CAST "//*[@s1kd-repcheck:test]", ctx);
}

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

for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
if (opts->list_refs) {
list_cir_ref(obj->nodesetval->nodeTab[i], path, rpt, opts);
} else if (check_cir_ref(obj->nodesetval->nodeTab[i], path, rpt, opts) != 0) {
err = 1;
}
}
}

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);

xmlFreeDoc(res);
xsltFreeStylesheet(style);

if (!opts->list_refs) {
if (err) {
xmlSetProp(rpt, BAD_CAST "valid", BAD_CAST "no");
} else {
xmlSetProp(rpt, BAD_CAST "valid", BAD_CAST "yes");
}
}

return err;
}

/* Check all CIR references in the specified CSDB object. */
static int check_cir_refs_in_file(const char *path, struct opts *opts)
{
xmlDocPtr doc;
int err = 0;
xmlDocPtr validtree = NULL;

if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_CHECK, path);
}

if (!(doc = read_xml_doc(path))) {
return 1;
}

/* Make a copy of the XML tree before performing additional
* processing on it. */
if (opts->output_valid) {
validtree = xmlCopyDoc(doc, 1);
}

if (opts->rem_delete) {
rem_delete_elems(doc);
}

err = check_cir_refs(doc, path, opts);

if (opts->verbosity >= VERBOSE) {
if (err) {
fprintf(stderr, F_INVALID, path);
} else {
fprintf(stderr, S_VALID, path);
}
}

if ((err && opts->show_filenames == SHOW_INVALID) || (!err && opts->show_filenames == SHOW_VALID)) {
puts(path);
}

if (opts->output_valid) {
if (err == 0) {
save_xml_doc(validtree, "-");
}
xmlFreeDoc(validtree);
}

xmlFreeDoc(doc);

return err;
}

/* Add a CSDB object to a list. */
static void add_object(struct objects *objects, const char *path, struct opts *opts)
{
if (objects->count == objects->max) {
if (!(objects->paths = realloc(objects->paths, (objects->max *= 2) * PATH_MAX))) {
if (opts->verbosity > QUIET) {
fprintf(stderr, E_MAX_OBJECTS);
}
exit(EXIT_MAX_OBJECTS);
}
}

strcpy(objects->paths[(objects->count)++], path);
}

/* Add a list of CSDB objects to a list. */
static void add_object_list(struct objects *objects, const char *list, struct opts *opts)
{
FILE *f;
char path[PATH_MAX];

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

while (fgets(path, PATH_MAX, f)) {
strtok(path, "\t\r\n");
add_object(objects, path, opts);
}

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

/* Initialize a list of CSDB objects. */
static void init_objects(struct objects *objects)
{
objects->paths = malloc(PATH_MAX);
objects->max = 1;
objects->count = 0;
}

/* Free a list of CSDB objects. */
static void free_objects(struct objects *objects)
{
free(objects->paths);
}

/* Find CIRs in directories and add them to the list. */
static void find_cirs(struct objects *cirs, char *search_dir, struct opts *opts)
{
DIR *dir;
struct dirent *cur;
char fpath[PATH_MAX], cpath[PATH_MAX];

if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_FIND_CIR, search_dir);
}

if (!(dir = opendir(search_dir))) {
return;
}

/* Clean up the directory string. */
if (strcmp(search_dir, ".") == 0) {
strcpy(fpath, "");
} else if (search_dir[strlen(search_dir) - 1] != '/') {
strcpy(fpath, search_dir);
strcat(fpath, "/");
} else {
strcpy(fpath, search_dir);
}

/* Search for CIRs. */
while ((cur = readdir(dir))) {
strcpy(cpath, fpath);
strcat(cpath, cur->d_name);

if (opts->recursive && isdir(cpath, true)) {
find_cirs(cirs, cpath, opts);
} else if (is_dm(cur->d_name) && is_cir(cpath, opts->rem_delete)) {
if (opts->verbosity >= DEBUG) {
fprintf(stderr, I_FIND_CIR_FOUND, cpath);
}
add_object(cirs, cpath, opts);
}
}

closedir(dir);
}

/* Use only the latest issue of a CIR. */
static void extract_latest_cirs(struct objects *cirs)
{
struct objects latest;

qsort(cirs->paths, cirs->count, PATH_MAX, compare_basename);

latest.paths = malloc(cirs->count * PATH_MAX);
latest.count = extract_latest_csdb_objects(latest.paths, cirs->paths, cirs->count);

free(cirs->paths);
cirs->paths = latest.paths;
cirs->count = latest.count;
}

/* Show a summary of the check. */
static void print_stats(xmlDocPtr doc)
{
xmlDocPtr styledoc;
xsltStylesheetPtr style;
xmlDocPtr res;

styledoc = read_xml_mem((const char *) xsl_stats_xsl, xsl_stats_xsl_len);
style = xsltParseStylesheetDoc(styledoc);

res = xsltApplyStylesheet(style, doc, NULL);

fprintf(stderr, "%s", (char *) res->children->content);

xmlFreeDoc(res);
xsltFreeStylesheet(style);
}

/* Show usage message. */
static void show_help(void)
{
puts("Usage: " PROG_NAME " [options] [<object>...]");
puts("");
puts("Options:");
puts(" -A, --all-refs Validate indirect CIR references.");
puts(" -a, --all Resolve against CIRs specified as objects to check.");
puts(" -d, --dir <dir> Search for CIRs in <dir>.");
puts(" -F, --valid-filenames List valid files.");
puts(" -f, --filenames List invalid files.");
puts(" -h, -?, --help Show help/usage message.");
puts(" -L, --list-refs List CIR refs instead of validating them.");
puts(" -l, --list Treat input as list of CSDB objects.");
puts(" -N, --omit-issue Assume issue/inwork numbers are omitted.");
puts(" -o, --output-valid Output valid CSDB objects to stdout.");
puts(" -p, --progress Display a progress bar.");
puts(" -q, --quiet Quiet mode.");
puts(" -R, --cir <CIR> Check references against the given CIR.");
puts(" -r, --recursive Search for CIRs recursively.");
puts(" -T, --summary Print a summary of the check.");
puts(" -t, --type <type> Type of CIR references to check.");
puts(" -v, --verbose Verbose output.");
puts(" -X, --xsl <file> Custom XSLT for extracting CIR references.");
puts(" -x, --xml Output XML report.");
puts(" -^, --remove-deleted Validate with elements marked as \"delete\" removed.");
puts(" --version Show version information.");
puts(" --zenity-progress Print progress information in the zenity --progress format.");
puts(" <object> CSDB object(s) to check.");
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 and libxslt %s\n", xmlParserVersion, xsltEngineVersion);
}

int main(int argc, char **argv)
{
int i, err = 0;

const char *sopts = "AaDd:FfLlNopqR:rTt:vX:x^h?";
struct option lopts[] = {
{"version" , no_argument , 0, 0},
{"help" , no_argument , 0, 'h'},
{"all-refs" , no_argument , 0, 'A'},
{"all" , no_argument , 0, 'a'},
{"dump-xsl" , no_argument , 0, 'D'},
{"dir" , required_argument, 0, 'd'},
{"valid-filenames", no_argument , 0, 'F'},
{"filenames" , no_argument , 0, 'f'},
{"list-refs" , no_argument , 0, 'L'},
{"list" , no_argument , 0, 'l'},
{"omit-issue" , no_argument , 0, 'N'},
{"output-valid" , no_argument , 0, 'o'},
{"progress" , no_argument , 0, 'p'},
{"quiet" , no_argument , 0, 'q'},
{"cir" , required_argument, 0, 'R'},
{"recursive" , no_argument , 0, 'r'},
{"summary" , no_argument , 0, 'T'},
{"type" , required_argument, 0, 't'},
{"verbose" , no_argument , 0, 'v'},
{"xsl" , required_argument, 0, 'X'},
{"xml" , no_argument , 0, 'x'},
{"remove-deleted" , no_argument , 0, '^'},
{"zenity-progress", no_argument , 0, 0},
LIBXML2_PARSE_LONGOPT_DEFS
{0, 0, 0, 0}
};
int loptind = 0;

struct opts opts;
bool is_list = false;
int show_progress = PROGRESS_OFF;
bool find_cir = false;
bool show_stats = false;
bool xml_report = false;
bool all_refs = false;
bool dump_xsl = false;

xmlDocPtr report_doc = NULL;

/* Initialize program options. */
opts.verbosity = NORMAL;
opts.show_filenames = SHOW_NONE;
opts.recursive = false;
opts.no_issue = false;
opts.search_all_objs = false;
opts.output_valid = false;
opts.list_refs = false;
opts.rem_delete = false;
opts.cir_refs_xsl = NULL;
opts.type = NULL;

init_objects(&opts.objects);
init_objects(&opts.cirs);

opts.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();
goto cleanup;
} else if (strcmp(lopts[loptind].name, "zenity-progress") == 0) {
show_progress = PROGRESS_ZENITY;
}
LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
break;
case 'A':
all_refs = true;
break;
case 'a':
opts.search_all_objs = true;
break;
case 'D':
dump_xsl = true;
break;
case 'd':
free(opts.search_dir);
opts.search_dir = strdup(optarg);
break;
case 'F':
opts.show_filenames = SHOW_VALID;
break;
case 'f':
opts.show_filenames = SHOW_INVALID;
break;
case 'L':
opts.list_refs = true;
break;
case 'l':
is_list = true;
break;
case 'N':
opts.no_issue = true;
break;
case 'o':
opts.output_valid = true;
break;
case 'p':
show_progress = PROGRESS_CLI;
break;
case 'q':
--opts.verbosity;
break;
case 'R':
if (strcmp(optarg, "*") == 0) {
find_cir = true;
} else {
add_object(&opts.cirs, optarg, &opts);
}
break;
case 'r':
opts.recursive = true;
break;
case 'T':
show_stats = true;
break;
case 't':
free(opts.type);
opts.type = strdup(optarg);
break;
case 'v':
++opts.verbosity;
break;
case 'X':
free(opts.cir_refs_xsl);
opts.cir_refs_xsl = read_xml_doc(optarg);
break;
case 'x':
xml_report = true;
break;
case '^':
opts.rem_delete = true;
break;
case 'h':
case '?':
show_help();
goto cleanup;
}
}

/* Load XSLT to extract CIR refs. */
if (opts.cir_refs_xsl == NULL) {
if (all_refs) {
opts.cir_refs_xsl = read_xml_mem((const char *) xsl_cirrefsall_xsl, xsl_cirrefsall_xsl_len);
} else {
opts.cir_refs_xsl = read_xml_mem((const char *) xsl_cirrefs_xsl, xsl_cirrefs_xsl_len);
}
}

/* Dump built-in XSLT if the -D option is specified. */
if (dump_xsl) {
save_xml_doc(opts.cir_refs_xsl, "-");
goto cleanup;
}

/* Initialize the XML report if the -x option is specified. */
if (xml_report || show_stats) {
report_doc = xmlNewDoc(BAD_CAST "1.0");
opts.report = xmlNewNode(NULL, BAD_CAST "repCheck");
xmlDocSetRootElement(report_doc, opts.report);
} else {
opts.report = NULL;
}

/* Search for CIRs when -R* is specified. */
if (find_cir) {
find_cirs(&opts.cirs, opts.search_dir, &opts);

extract_latest_cirs(&opts.cirs);

/* Print the final CIR list in DEBUG mode. */
if (opts.verbosity >= DEBUG) {
int i;
for (i = 0; i < opts.cirs.count; ++i) {
fprintf(stderr, I_FIND_CIR_ADD, opts.cirs.paths[i]);
}
}
}

/* Read specified objects into a list in memory. */
if (optind < argc) {
for (i = optind; i < argc; ++i) {
if (is_list) {
add_object_list(&opts.objects, argv[i], &opts);
} else {
add_object(&opts.objects, argv[i], &opts);
}
}
} else if (is_list) {
add_object_list(&opts.objects, NULL, &opts);
} else {
add_object(&opts.objects, "-", &opts);
}

/* Check CIR references in the objects in the list. */
for (i = 0; i < opts.objects.count; ++i) {
if (check_cir_refs_in_file(opts.objects.paths[i], &opts) != 0) {
err = 1;
}

switch (show_progress) {
case PROGRESS_OFF:
break;
case PROGRESS_CLI:
print_progress_bar(i, opts.objects.count);
break;
case PROGRESS_ZENITY:
print_zenity_progress("Performing repository check...", i, opts.objects.count);
break;
}
}

if (opts.objects.count > 0) {
switch (show_progress) {
case PROGRESS_OFF:
break;
case PROGRESS_CLI:
print_progress_bar(i, opts.objects.count);
break;
case PROGRESS_ZENITY:
print_zenity_progress("Repository check complete.", i, opts.objects.count);
break;
}
}

if (xml_report) {
save_xml_doc(report_doc, "-");
}

if (show_stats) {
print_stats(report_doc);
}

cleanup:
free_objects(&opts.objects);
free_objects(&opts.cirs);
free(opts.search_dir);
xmlFreeDoc(opts.cir_refs_xsl);
free(opts.type);
xmlFreeDoc(report_doc);

xmlCleanupParser();
xsltCleanupGlobals();

return err;
}