#include <stdio.h>

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

#define PROG_NAME "xml-format"
#define VERSION "2.6.0"

/* Formatter options */
#define FORMAT_OVERWRITE 0x01
#define FORMAT_REMWSONLY 0x02
#define FORMAT_OMIT_DECL 0x04
#define FORMAT_COMPACT 0x08
#define FORMAT_INDENT 0x10

/* Determine whether the node is a textual node. Textual nodes are never
* subject to formatting or indenting.
*/
static bool is_text(const xmlNodePtr node)
{
return
node->type == XML_TEXT_NODE ||
node->type == XML_CDATA_SECTION_NODE;
}

/* The blank text node children in an element are considered removable only if
* ALL the text node children of that element are blank (no mixed content), or
* there are no text node children at all.
*
* If there is only a single blank text node child, it is considered removable
* only if FORMAT_REMWSONLY is set.
*/
static bool blanks_are_removable(xmlNodePtr node, int opts)
{
xmlNodePtr cur;
int i;

if (xmlNodeGetSpacePreserve(node) == 1) {
return false;
}

for (cur = node->children, i = 0; cur; cur = cur->next, ++i) {
if (is_text(cur) && !xmlIsBlankNode(cur)) {
return false;
}
}

return i > 1 || (node->children && !is_text(node->children)) || optset(opts, FORMAT_REMWSONLY);
}

/* Remove blank children. */
static void remove_blanks(xmlNodePtr node)
{
xmlNodePtr cur;

cur = node->children;

while (cur) {
xmlNodePtr next;
next = cur->next;

if (xmlIsBlankNode(cur)) {
xmlUnlinkNode(cur);
xmlFreeNode(cur);
}

cur = next;
}
}

/* Add indentation to nodes within non-blank nodes. */
static void indent(xmlNodePtr node)
{
xmlNodePtr cur;
int n = 0, i;

for (cur = node->parent; cur; cur = cur->parent) {
++n;
}

if (!node->prev) {
xmlAddPrevSibling(node, xmlNewText(BAD_CAST "\n"));
for (i = 1; i < n; ++i) {
xmlAddPrevSibling(node, xmlNewText(BAD_CAST xmlTreeIndentString));
}
}

for (i = node->next ? 1 : 2; i < n; ++i) {
xmlAddNextSibling(node, xmlNewText(BAD_CAST xmlTreeIndentString));
}
xmlAddNextSibling(node, xmlNewText(BAD_CAST "\n"));
}

/* Format XML nodes. */
static void format(xmlNodePtr node, int opts)
{
bool remblanks;

if ((remblanks = blanks_are_removable(node, opts))) {
remove_blanks(node);
}

if (remblanks || optset(opts, FORMAT_INDENT)) {
xmlNodePtr cur = node->children;

while (cur) {
xmlNodePtr next = cur->next;

format(cur, opts);

if (remblanks && optset(opts, FORMAT_INDENT) && !optset(opts, FORMAT_COMPACT)) {
indent(cur);
}

cur = next;
}
}
}

/* Format an XML file. */
static void format_file(const char *path, const char *out, int opts)
{
xmlDocPtr doc;
xmlSaveCtxtPtr save;
int saveopts = 0;

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

format(xmlDocGetRootElement(doc), opts);

if (!optset(opts, FORMAT_COMPACT)) {
saveopts |= XML_SAVE_FORMAT;
}
if (optset(opts, FORMAT_OMIT_DECL)) {
saveopts |= XML_SAVE_NO_DECL;
}

if (out) {
save = xmlSaveToFilename(out, NULL, saveopts);
} else if (optset(opts, FORMAT_OVERWRITE)) {
save = xmlSaveToFilename(path, NULL, saveopts);
} else {
save = xmlSaveToFilename("-", NULL, saveopts);
}

xmlSaveDoc(save, doc);
xmlSaveClose(save);

xmlFreeDoc(doc);
}

/* Show usage message. */
static void show_help(void)
{
puts("Usage: " PROG_NAME " [-cfIOwh?] [-i <str>] [-o <path>] [<file>...]");
puts("");
puts("Options:");
puts(" -c, --compact Compact output.");
puts(" -f, --overwrite Overwrite input XML files.");
puts(" -h, -?, --help Show usage message.");
puts(" -I, --indent-all Indent nodes within non-blank nodes.");
puts(" -i, --indent <str> Set the indentation string.");
puts(" -O, --omit-decl Omit XML declaration.");
puts(" -o, --out <path> Output to <path> instead of stdout.");
puts(" -w, --empty Treat elements containing only whitespace as empty.");
puts(" --version Show version information.");
puts(" <file> XML file(s) to format. Otherwise, read from stdin.");
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;
const char *sopts = "cfIi:Oo:wh?";
struct option lopts[] = {
{"version" , no_argument , 0, 0},
{"help" , no_argument , 0, 'h'},
{"compact" , no_argument , 0, 'c'},
{"overwrite" , no_argument , 0, 'f'},
{"indent-all", no_argument , 0, 'I'},
{"indent" , required_argument, 0, 'i'},
{"omit-decl" , no_argument , 0, 'O'},
{"out" , required_argument, 0, 'o'},
{"empty" , no_argument , 0, 'w'},
LIBXML2_PARSE_LONGOPT_DEFS
{0, 0, 0, 0}
};
int loptind = 0;

int opts = 0;
char *indent = NULL;
char *out = NULL;

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 'c':
opts |= FORMAT_COMPACT;
break;
case 'f':
opts |= FORMAT_OVERWRITE;
break;
case 'I':
opts |= FORMAT_INDENT;
break;
case 'i':
indent = strdup(optarg);
break;
case 'O':
opts |= FORMAT_OMIT_DECL;
break;
case 'o':
out = strdup(optarg);
break;
case 'w':
opts |= FORMAT_REMWSONLY;
break;
case 'h':
case '?':
show_help();
return 0;
}
}

if (indent) {
xmlTreeIndentString = indent;
}

if (optind < argc) {
for (i = optind; i < argc; ++i) {
format_file(argv[i], out, opts);
}
} else {
format_file("-", out, opts);
}

free(indent);
free(out);

xmlCleanupParser();

return 0;
}