#include <stdio.h>

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "xml-utils.h"

#define PROG_NAME "xml-trim"
#define VERSION "3.5.1"

#define is_space(c) isspace((unsigned char) c)

/* Remove whitespace on left end of string. */
static char *strltrm(char *dst, const char *src)
{
int start;
for (start = 0; is_space(src[start]); ++start);
sprintf(dst, "%s", src + start);
return dst;
}

/* Remove whitespace on right end of string. */
static char *strrtrm(char *dst, const char *src)
{
int len, end;
len = strlen(src);
for (end = len - 1; is_space(src[end]); --end);
sprintf(dst, "%.*s", end + 1, src);
return dst;
}

/* Normalize space by replacing all sequences of whitespace characters with a
* single space.
*/
static char *strnorm(char *dst, const char *src)
{
int i, j;
j = 0;
for (i = 0; src[i]; ++i) {
if (is_space(src[i])) {
dst[j] = ' ';
while (is_space(src[i + 1])) {
++i;
}
} else {
dst[j] = src[i];
}
++j;
}
return dst;
}

/* Register an XML namespace with the XPath context. */
static void register_ns(xmlXPathContextPtr ctx, char *optarg)
{
char *prefix, *uri;

prefix = strtok(optarg, "=");
uri = strtok(NULL, "");

xmlXPathRegisterNs(ctx, BAD_CAST prefix, BAD_CAST uri);
}

/* Trim space in a text node. */
static void trim(xmlNodePtr node, char *(*f)(char *, const char *)) {
char *content, *trimmed;

content = (char *) xmlNodeGetContent(node);

trimmed = calloc(strlen(content) + 1, 1);
f(trimmed, content);
xmlFree(content);

content = strdup(trimmed);
xmlFree(trimmed);

xmlNodeSetContent(node, BAD_CAST content);
xmlFree(content);
}

/* Trim all text nodes in a given set of elements. */
static void trim_nodes(xmlNodeSetPtr nodes, bool normalize)
{
int i;

for (i = 0; i < nodes->nodeNr; ++i) {
xmlNodePtr first, last;

/* If node has no children, no trimming is necessary. */
if (!nodes->nodeTab[i]->children) {
continue;
}

if ((first = nodes->nodeTab[i]->children)->type == XML_TEXT_NODE) {
trim(first, strltrm);
}

if ((last = xmlGetLastChild(nodes->nodeTab[i]))->type == XML_TEXT_NODE) {
trim(last, strrtrm);
}

if (normalize) {
for (first = nodes->nodeTab[i]->children; first; first = first->next) {
if (first->type == XML_TEXT_NODE) {
trim(first, strnorm);
}
}
}
}
}

static void trim_nodes_in_file(const char *path, xmlNodePtr ns, xmlNodePtr elems, bool normalize, bool overwrite)
{
xmlDocPtr doc;
xmlXPathContextPtr ctx;
xmlNodePtr cur;

doc = read_xml_doc(path);
ctx = xmlXPathNewContext(doc);

for (cur = ns->children; cur; cur = cur->next) {
xmlChar *n;
n = xmlNodeGetContent(cur);
register_ns(ctx, (char *) n);
xmlFree(n);
}

for (cur = elems->children; cur; cur = cur->next) {
xmlChar *xpath;
xmlXPathObjectPtr obj;
xmlChar *e;

e = xmlNodeGetContent(cur);

/* If the element specifier contains a /, treat it like a
* literal XPath expression.
*
* Otherwise, match all elements with the same name at any
* position.
*/
if (xmlStrchr(e, '/')) {
xpath = xmlStrdup(e);
} else {
xpath = xmlStrdup(BAD_CAST "//");
xpath = xmlStrcat(xpath, e);
}

xmlFree(e);

obj = xmlXPathEvalExpression(xpath, ctx);

xmlFree(xpath);

if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
trim_nodes(obj->nodesetval, normalize);
}

xmlXPathFreeObject(obj);
}

xmlXPathFreeContext(ctx);

if (overwrite) {
save_xml_doc(doc, path);
} else {
save_xml_doc(doc, "-");
}

xmlFreeDoc(doc);
}

/* Show usage message. */
static void show_help(void)
{
puts("Usage: " PROG_NAME " [-e <elem> ...] [-N <ns=URL> ...] [-fnh?] [<src>...]");
puts("");
puts("Options:");
puts(" -e, --element <elem> Element to trim space on.");
puts(" -f, --overwrite Overwrite input files.");
puts(" -h, -?, --help Show usage message.");
puts(" -N, --namespace <ns=URL> Register a namespace.");
puts(" -n, --normalize Normalize space as well as trim.");
puts(" --version Show version information.");
puts(" <src> XML file to trim.");
LIBXML2_PARSE_LONGOPT_HELP
}

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

int main(int argc, char **argv)
{
int i;
xmlNodePtr ns, elems;
bool normalize = false;
bool overwrite = false;

const char *sopts = "e:fN:nh?";
struct option lopts[] = {
{"version" , no_argument , 0, 0},
{"help" , no_argument , 0, 'h'},
{"element" , required_argument, 0, 'e'},
{"overwrite", no_argument , 0, 'f'},
{"namespace", required_argument, 0, 'N'},
{"normalize", no_argument , 0, 'n'},
LIBXML2_PARSE_LONGOPT_DEFS
{0, 0, 0, 0}
};
int loptind = 0;

ns = xmlNewNode(NULL, BAD_CAST "namespaces");
elems = xmlNewNode(NULL, BAD_CAST "elems");

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 'e':
xmlNewChild(elems, NULL, BAD_CAST "elem", BAD_CAST optarg);
break;
case 'f':
overwrite = true;
break;
case 'N':
xmlNewChild(ns, NULL, BAD_CAST "ns", BAD_CAST optarg);
break;
case 'n':
normalize = true;
break;
case 'h':
case '?':
show_help();
return 0;
}

if (optind < argc) {
for (i = optind; i < argc; ++i) {
trim_nodes_in_file(argv[i], ns, elems, normalize, overwrite);
}
} else {
trim_nodes_in_file("-", ns, elems, normalize, overwrite);
}

xmlFreeNode(ns);
xmlFreeNode(elems);

xmlCleanupParser();

return 0;
}