package org.unicode.cldr.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import org.unicode.cldr.draft.FileUtilities;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.DeclHandler;

import com.ibm.icu.impl.Relation;
import com.ibm.icu.text.UTF16;

/**
 * @deprecated
 */
public class FindDTDOrder implements DeclHandler, ContentHandler, ErrorHandler {
    static final boolean SHOW_PROGRESS = CldrUtility.getProperty("verbose", false);
    static final boolean SHOW_ALL = CldrUtility.getProperty("show_all", false);
    private static final boolean DEBUG = false;

    private static FindDTDOrder INSTANCE;

    private boolean recordingAttributeElements;

    public static void main(String[] args) throws IOException {
        System.out.println("Outdated, no longer used");
        FindDTDOrder me = getInstance();
        me.showData();
    }

    public static FindDTDOrder getInstance() {
        synchronized (FindDTDOrder.class) {
            if (INSTANCE == null) {
                try {
                    FindDTDOrder me = new FindDTDOrder();
                    XMLReader xmlReader = CLDRFile.createXMLReader(true);
                    xmlReader.setContentHandler(me);
                    xmlReader.setErrorHandler(me);
                    xmlReader.setProperty(
                        "http://xml.org/sax/properties/declaration-handler", me);

                    FileInputStream fis;
                    InputSource is;
                    me.recordingAttributeElements = true;
                    String filename = CLDRPaths.MAIN_DIRECTORY + "/root.xml";
                    File file = new File(filename);
                    if (DEBUG) {
                        System.out.println("Opening " + file.getCanonicalFile());
                    }
                    File dtd = new File(file.getCanonicalPath() + "/../" + "../../common/dtd/ldml.dtd");
                    if (DEBUG) {
                        System.out.println("Opening " + dtd.getCanonicalFile());
                    }

                    fis = new FileInputStream(filename);
                    if (DEBUG) {
                        BufferedReader b = new BufferedReader(new InputStreamReader(fis));
                        for (int i = 0; i < 30; ++i) {
                            String line = b.readLine();
                            System.out.println(line);
                        }
                        throw new IllegalArgumentException("just testing");
                    }
                    is = new InputSource(fis);
                    is.setSystemId(file.getCanonicalPath() + "/../");
                    xmlReader.parse(is);
                    fis.close();

                    me.recordingAttributeElements = false;
                    filename = CLDRPaths.DEFAULT_SUPPLEMENTAL_DIRECTORY
                        + "/supplementalData.xml";
                    File file2 = new File(filename);
                    if (DEBUG) {
                        System.out.println("Opening " + file2.getCanonicalFile());
                    }

                    fis = new FileInputStream(filename);
                    is = new InputSource(fis);
                    is.setSystemId(file.getCanonicalPath() + "/../");
                    xmlReader.parse(is);
                    fis.close();
                    // Then Attributes
                    List<String> rawDtdAttributeOrder = Collections.unmodifiableList(new ArrayList<String>(me.attributeSet));
                    List<String> cldrFileAttributeOrder = CLDRFile.getAttributeOrder();

                    LinkedHashSet<String> modifiedDtdOrder = new LinkedHashSet<String>(cldrFileAttributeOrder);
                    // add items, keeping the ordering stable
                    modifiedDtdOrder.retainAll(rawDtdAttributeOrder); // remove any superfluous stuff
                    modifiedDtdOrder.addAll(rawDtdAttributeOrder);

                    // certain stuff always goes at the end
                    modifiedDtdOrder.removeAll(me.getCommonAttributes());
                    modifiedDtdOrder.addAll(me.getCommonAttributes());

                    // now make a list for comparison
                    List<String> dtdAttributeOrder = new ArrayList<String>(modifiedDtdOrder);

                    // fix to and from
                    dtdAttributeOrder.remove("from");
                    dtdAttributeOrder.add(dtdAttributeOrder.indexOf("to"), "from");

                    me.attributeList = Collections.unmodifiableList(dtdAttributeOrder);
                    me.checkData();
                    me.orderingList = Collections.unmodifiableList(me.orderingList);

                    // me.writeAttributeElements();
                    INSTANCE = me;
                } catch (Exception e) {
                    throw (IllegalArgumentException) new IllegalArgumentException().initCause(e);
                }
            }
        }
        return INSTANCE;
    }

    public void writeAttributeElements() {
        System.out.println(CldrUtility.LINE_SEPARATOR + "======== Start Attributes to Elements (unblocked) "
            + CldrUtility.LINE_SEPARATOR);
        for (String attribute : attributeToElements.keySet()) {
            Set<String> filtered = new TreeSet<String>();
            for (String element : attributeToElements.getAll(attribute)) {
                if (!isBlocked(element)) {
                    filtered.add(element);
                }
            }
            System.out.println(attribute + "\t" + CldrUtility.join(filtered, " "));
        }
        System.out.println(CldrUtility.LINE_SEPARATOR + "======== End Attributes to Elements"
            + CldrUtility.LINE_SEPARATOR);
        System.out.println(CldrUtility.LINE_SEPARATOR + "======== Start Elements to Children (skipping alias, special)"
            + CldrUtility.LINE_SEPARATOR);
        showElementTree("ldml", "", new HashSet<String>());
        System.out.println(CldrUtility.LINE_SEPARATOR + "======== End Elements to Children"
            + CldrUtility.LINE_SEPARATOR);
    }

    private void showElementTree(String element, String indent, HashSet<String> seenSoFar) {
        // skip blocking elements
        if (isBlocked(element)) {
            return;
        }
        Set<String> children = elementToChildren.getAll(element);
        if (seenSoFar.contains(element)) {
            System.out.println(indent + element
                + (children == null || children.size() == 0 ? "" : "\t*dup*\t" + children));
            return;
        }
        System.out.println(indent + element);
        seenSoFar.add(element);
        if (children != null) {
            indent += "\t";
            for (String child : children) {
                showElementTree(child, indent, seenSoFar);
            }
        }
    }

    private boolean isBlocked(String element) {
        return isAncestorOf("supplementalData", element)
            || isAncestorOf("collation", element)
            || isAncestorOf("cldrTest", element)
            || isAncestorOf("transform", element);
    }

    Relation<String, String> ancestorToDescendant = null;

    private boolean isAncestorOf(String possibleAncestor, String possibleDescendent) {
        if (ancestorToDescendant == null) {
            ancestorToDescendant = Relation.of(new TreeMap<String, Set<String>>(), TreeSet.class);
            buildPairwiseRelations(new ArrayList<String>(), "ldml");
        }
        Set<String> possibleDescendents = ancestorToDescendant.getAll(possibleAncestor);
        if (possibleDescendents == null) return false;
        return possibleDescendents.contains(possibleDescendent);
    }

    private void buildPairwiseRelations(List<String> parents, String current) {
        Set<String> children = elementToChildren.getAll(current);
        if (children == null || children.size() == 0) return;

        // we make a new list, since otherwise the iteration fails in recursion (because of the modification)
        // if this were performance-sensitive we'd do it differently
        ArrayList<String> newParents = new ArrayList<String>(parents);
        newParents.add(current);

        for (String child : children) {
            for (String ancestor : newParents) {
                ancestorToDescendant.put(ancestor, child);
                buildPairwiseRelations(newParents, child);
            }
        }
    }

    PrintWriter log = null;

    Set elementOrderings = new LinkedHashSet(); // set of orderings

    Set<String> allDefinedElements = new LinkedHashSet<String>();

    boolean showReason = false;

    Object DONE = new Object(); // marker

    Relation<String, String> elementToChildren = Relation.of(new TreeMap<String, Set<String>>(),
        TreeSet.class);

    FindDTDOrder() {
        log = new PrintWriter(System.out);
    }

    private List<String> orderingList = new ArrayList<String>();

    public void checkData() {
        // verify that the ordering is the consistent for all child elements
        // do this by building an ordering from the lists.
        // The first item has no greater item in any set. So find an item that is
        // only first
        MergeLists<String> mergeLists = new MergeLists<String>(new TreeSet<String>(new UTF16.StringComparator(true,
            false, 0)))
                .add(Arrays.asList("ldml"))
                .addAll(elementOrderings); //
        List<String> result = mergeLists.merge();
        Collection badOrder = MergeLists.hasConsistentOrderWithEachOf(result, elementOrderings);
        if (badOrder != null) {
            throw new IllegalArgumentException("Failed to find good order: " + badOrder);
        }

        showReason = false;
        orderingList.add("ldml");
        if (SHOW_PROGRESS) {
            log.println("SHOW_PROGRESS ");
            for (Iterator it = elementOrderings.iterator(); it.hasNext();) {
                Object value = it.next();
                log.println(value);
            }
        }
        while (true) {
            Object first = getFirst();
            if (first == DONE)
                break;
            if (first != null) {
                // log.println("Adding:\t" + first);
                if (orderingList.contains(first)) {
                    throw new IllegalArgumentException("Already present: " + first);
                }
                orderingList.add(first.toString());
            } else {
                showReason = true;
                getFirst();
                if (SHOW_PROGRESS)
                    log.println();
                if (SHOW_PROGRESS)
                    log.println("Failed ordering. So far:");
                for (Iterator<String> it = orderingList.iterator(); it.hasNext();)
                    if (SHOW_PROGRESS)
                        log.print("\t" + it.next());
                if (SHOW_PROGRESS)
                    log.println();
                if (SHOW_PROGRESS)
                    log.println("Items:");
                // for (Iterator it = element_childComparator.keySet().iterator();
                // it.hasNext();) showRow(it.next(), true);
                if (SHOW_PROGRESS)
                    log.println();
                break;
            }
        }

        if (DEBUG) {
            System.out.println("New code in CLDRFile:\n" + result);
            System.out.println("Old code in CLDRFile:\n" + orderingList);
        }
        // System.out.println("New code2: " + CldrUtility.breakLines(CldrUtility.join(result, " "), sep,
        // FIRST_LETTER_CHANGE.matcher(""), 80));

        Set<String> missing = new TreeSet<String>(allDefinedElements);
        missing.removeAll(orderingList);
        orderingList.addAll(missing);

        attributeEquivalents = new XEquivalenceClass(null);
        for (Iterator it = attribEquiv.keySet().iterator(); it.hasNext();) {
            Object ename = it.next();
            Set s = attribEquiv.get(ename);
            Iterator it2 = s.iterator();
            Object first = it2.next();
            while (it2.hasNext()) {
                attributeEquivalents.add(first, it2.next(), ename);
            }
        }

    }

    String sep = CldrUtility.LINE_SEPARATOR + "\t\t\t";

    private void showData() throws IOException {

        // finish up
        String oldAttributeOrder = breakLines(CLDRFile.getAttributeOrder());
        log.println("Successful Ordering...");
        log.println();
        log.println("Old Attribute Ordering: ");
        log.println(oldAttributeOrder);

        String newAttributeOrder = breakLines(attributeList);

        if (newAttributeOrder.equals(oldAttributeOrder)) {
            log.println("*** New Attribute Ordering: <same>");
            log.println("*** No changes required...");
        } else {
            log.println("*** New Attribute Ordering: ");
            log.println(newAttributeOrder);
            log.println("*** Replace in CLDRFile elementOrdering  & supplementalMetadata ***");
        }

        log.println("Attribute Eq: ");
        for (Iterator it = attributeEquivalents.getSamples().iterator(); it.hasNext();) {
            log.println("\t"
                + getJavaList(new TreeSet(attributeEquivalents.getEquivalences(it.next()))));
        }
        if (SHOW_PROGRESS) {
            for (Iterator it = attributeEquivalents.getEquivalenceSets().iterator(); it.hasNext();) {
                Object last = null;
                Set s = (Set) it.next();
                for (Iterator it2 = s.iterator(); it2.hasNext();) {
                    Object temp = it2.next();
                    if (last != null)
                        log.println(last + " ~ " + temp + "\t" + attributeEquivalents.getReasons(last, temp));
                    last = temp;
                }
                log.println();
            }
        }

        String oldOrder = getJavaList(CLDRFile.getElementOrder());
        log.println("Old Element Ordering:\n"
            + oldOrder);

        String newOrder = '"' + breakLines(orderingList) + '"';
        if (newOrder.equals(oldOrder)) {
            log.println("*** New Element Ordering: <same>");
            log.println("*** No changes required...");
        } else {
            log.println("*** New Element Ordering:\n" + newOrder);
            log.println("*** Replace in CLDRFile elementOrdering  & supplementalMetadata ***");
        }

        if (SHOW_ALL) {
            log.println("Old Size: " + CLDRFile.getElementOrder().size());
            Set temp = new HashSet(CLDRFile.getElementOrder());
            temp.removeAll(orderingList);
            log.println("Old - New: " + temp);
            log.println("New Size: " + orderingList.size());
            temp = new HashSet(orderingList);
            temp.removeAll(CLDRFile.getElementOrder());
            log.println("New - Old: " + temp);

            Differ differ = new Differ(200, 1);
            Iterator oldIt = CLDRFile.getElementOrder().iterator();
            Iterator newIt = orderingList.iterator();
            while (oldIt.hasNext() || newIt.hasNext()) {
                if (oldIt.hasNext())
                    differ.addA(oldIt.next());
                if (newIt.hasNext())
                    differ.addB(newIt.next());
                differ.checkMatch(!oldIt.hasNext() && !newIt.hasNext());

                if (differ.getACount() != 0 || differ.getBCount() != 0) {
                    log.println("Same: " + differ.getA(-1));
                    for (int i = 0; i < differ.getACount(); ++i) {
                        log.println("\tOld: " + differ.getA(i));
                    }
                    for (int i = 0; i < differ.getBCount(); ++i) {
                        log.println("\t\tNew: " + differ.getB(i));
                    }
                    log.println("Same: " + differ.getA(differ.getACount()));
                }
            }
            log.println("Done with differences");
        }

        log.flush();

        writeNewSupplemental(CLDRPaths.SUPPLEMENTAL_DIRECTORY, "supplementalMetadata.xml",
            "<attributeOrder>", "</attributeOrder>",
            "<elementOrder>", "</elementOrder>", "\t\t\t", CldrUtility.LINE_SEPARATOR + "\t\t");
        writeNewSupplemental(CLDRPaths.BASE_DIRECTORY + "/tools/java/org/unicode/cldr/util/",
            "CLDRFile.java",
            "// START MECHANICALLY attributeOrdering GENERATED BY FindDTDOrder",
            "// END MECHANICALLY attributeOrdering GENERATED BY FindDTDOrder",
            "// START MECHANICALLY elementOrdering GENERATED BY FindDTDOrder",
            "// END MECHANICALLY elementOrdering GENERATED BY FindDTDOrder",
            "\t\t\t\t\t\"",
            '"' + CldrUtility.LINE_SEPARATOR + "\t\t\t\t\t");
    }

    private void writeNewSupplemental(String dir, String filename, String startAttributeTag, String endAttributeTag,
        String startElementTag, String endElementTag, String startSep, String endSep) throws IOException {
        BufferedReader oldFile = FileUtilities.openUTF8Reader(dir, filename);
        Log.setLogNoBOM(CLDRPaths.GEN_DIRECTORY + "/DTDOrder/" + filename);

        // CldrUtility.copyUpTo(oldFile, PatternCache.get("\\s*" +
        // startAttributeTag +
        // "\\s*"), Log.getLog(), true);
        // Log.println(startSep + breakLines(attributeSet) + endSep + endAttributeTag);
        // CldrUtility.copyUpTo(oldFile, PatternCache.get("\\s*" +
        // endAttributeTag +
        // "\\s*"), null, true);

        CldrUtility.copyUpTo(oldFile, PatternCache.get("\\s*" +
            startElementTag +
            "\\s*"), Log.getLog(), true);
        Log.println(startSep + breakLines(orderingList) + endSep + endElementTag);
        CldrUtility.copyUpTo(oldFile, PatternCache.get("\\s*" +
            endElementTag +
            "\\s*"), null, true);

        CldrUtility.copyUpTo(oldFile, null, Log.getLog(), false); // copy to end

        Log.close();
        oldFile.close();
    }

    private String breakLines(Collection orderingList) {
        final String joined = CldrUtility.join(orderingList, " ");
        return joined; // return Utility.breakLines(joined, sep, FIRST_LETTER_CHANGE.matcher(""), 80);
    }

    private String getJavaList(Collection orderingList) {
        boolean first2 = true;
        StringBuffer result = new StringBuffer();
        result.append('"');
        for (Iterator it = orderingList.iterator(); it.hasNext();) {
            if (first2)
                first2 = false;
            else
                result.append(" ");
            result.append(it.next().toString());
        }
        result.append('"');
        return result.toString();
    }

    /**
     * @param parent
     * @param skipEmpty
     *            TODO
     */
    // private void showRow(Object parent, boolean skipEmpty) {
    // List items = (List) element_childComparator.get(parent);
    // if (skipEmpty && items.size() == 0) return;
    // if (SHOW_PROGRESS) log.print(parent);
    // for (Iterator it2 = items.iterator(); it2.hasNext();) if (SHOW_PROGRESS)
    // log.print("\t" + it2.next());
    // if (SHOW_PROGRESS) log.println();
    // }
    /**
     * @param orderingList
     */
    private Object getFirst() {
        Set firstItems = new TreeSet();
        Set nonFirstItems = new TreeSet();
        for (Iterator it = elementOrderings.iterator(); it.hasNext();) {
            List list = (List) it.next();
            if (list.size() != 0) {
                firstItems.add(list.get(0));
                for (int i = 1; i < list.size(); ++i) {
                    nonFirstItems.add(list.get(i));
                }
            }
        }
        if (firstItems.size() == 0 && nonFirstItems.size() == 0)
            return DONE;
        firstItems.removeAll(nonFirstItems);
        if (firstItems.size() == 0)
            return null; // failure
        Object result = firstItems.iterator().next();
        removeEverywhere(result);
        return result;
    }

    /**
     * @param possibleFirst
     */
    private void removeEverywhere(Object possibleFirst) {
        // and remove from all the lists
        for (Iterator it2 = elementOrderings.iterator(); it2.hasNext();) {
            List list2 = (List) it2.next();
            if (SHOW_PROGRESS && list2.contains(possibleFirst)) {
                log.println("Removing " + possibleFirst + " from " + list2);
            }
            while (list2.remove(possibleFirst))
                ; // repeat until returns false
        }
    }

    // private boolean isNeverNotFirst(Object possibleFirst) {
    // if (showReason) if (SHOW_PROGRESS) log.println("Trying: " + possibleFirst);
    // for (Iterator it2 = element_childComparator.keySet().iterator();
    // it2.hasNext();) {
    // Object key = it2.next();
    // List list2 = (List) element_childComparator.get(key);
    // int pos = list2.indexOf(possibleFirst);
    // if (pos > 0) {
    // if (showReason) {
    // if (SHOW_PROGRESS) log.print("Failed at:\t");
    // showRow(key, false);
    // }
    // return false;
    // }
    // }
    // return true;
    // }

    static final Set<String> ELEMENT_SKIP_LIST = new HashSet<String>(Arrays.asList(new String[] {
        "collation", "base", "settings", "suppress_contractions", "optimize",
        "rules", "reset", "context", "p", "pc", "s", "sc", "t", "tc",
        "i", "ic", "extend", "x" }));

    static final Set<String> SUBELEMENT_SKIP_LIST = new HashSet<String>(Arrays
        .asList(new String[] { "PCDATA", "EMPTY", "ANY" }));

    // refine later; right now, doesn't handle multiple elements well.
    public void elementDecl(String name, String model) throws SAXException {
        // if (ELEMENT_SKIP_LIST.contains(name)) return;
        if (name.indexOf("contractions") >= 0
            || model
                .indexOf("[alias, base, settings, suppress, contractions, optimize, rules, special]") >= 0) {
        }
        allDefinedElements.add(name);
        if (SHOW_PROGRESS) {
            log.println("Element\t" + name + "\t" + model);
        }
        String[] list = model.split("[^-_A-Z0-9a-z]+");
        List<String> mc = new ArrayList<String>();
        /*
         * if (name.equals("currency")) { mc.add("alias"); mc.add("symbol");
         * mc.add("pattern"); }
         */
        for (int i = 0; i < list.length; ++i) {
            if (list[i].length() == 0)
                continue;
            if (list[i].equals("ANY") && !name.equals("special")) {
                System.err.println("WARNING- SHOULD NOT HAVE 'ANY': " + name + "\t"
                    + model);
            }
            if (SUBELEMENT_SKIP_LIST.contains(list[i]))
                continue;
            // if (SHOW_PROGRESS) log.print("\t" + list[i]);
            if (mc.contains(list[i])) {
                if (name.equals("currency") && list[i].equals("displayName") || list[i].equals("symbol")
                    || list[i].equals("pattern")) {
                    // do nothing, exception
                } else if (name.equals("rules") && (list[i].equals("reset") || list[i].equals("import"))) {
                    // do nothing, exception
                } else {
                    throw new IllegalArgumentException("Duplicate element in definition of  " + name
                        + ":\t" + list[i] + ":\t" + Arrays.asList(list) + ":\t" + mc);
                }
            } else {
                mc.add(list[i]);
            }
        }
        if (recordingAttributeElements) {
            Set<String> children = new TreeSet<String>(mc);
            children.remove("alias");
            children.remove("special");
            children.remove("cp");
            elementToChildren.putAll(name, children);
        }
        allDefinedElements.addAll(mc);

        if (mc.size() < 1) {
            if (SHOW_PROGRESS) {
                log.println("\tSKIPPING\t" + name + "\t" + mc);
            }
        } else {
            if (SHOW_PROGRESS) {
                log.println("\t" + name + "\t" + mc);
            }
            elementOrderings.add(mc);
        }

        // if (SHOW_PROGRESS) log.println();
    }

    Set<String> skipCommon = new LinkedHashSet<String>(Arrays.asList(new String[] { "validSubLocales",
        "standard", "references",
        "alt", "draft",
    }));

    Set<String> attributeSet = new TreeSet<String>();
    {
        attributeSet.add("_q");
        attributeSet.addAll(skipCommon);
    }
    List<String> attributeList;

    Map<String, Set<String>> attribEquiv = new TreeMap<String, Set<String>>();

    Relation<String, String> attributeToElements = Relation.of(new TreeMap<String, Set<String>>(),
        TreeSet.class);
    private XEquivalenceClass attributeEquivalents;

    public void attributeDecl(String eName, String aName, String type,
        String mode, String value) throws SAXException {
        if (SHOW_ALL)
            log.println("attributeDecl");
        // if (SHOW_ALL) log.println("Attribute\t" + eName + "\t" +
        // aName + "\t" + type + "\t" + mode + "\t" + value);
        if (SHOW_PROGRESS) System.out.println("Attribute\t" + eName + "\t" + aName + "\t" + type
            + "\t" + mode + "\t" + value);
        if (!skipCommon.contains(aName)) {
            attributeSet.add(aName);
            Set<String> l = attribEquiv.get(eName);
            if (l == null)
                attribEquiv.put(eName, l = new TreeSet<String>());
            l.add(aName);
        }
        if (recordingAttributeElements) {
            attributeToElements.put(aName, eName);
        }
    }

    public void internalEntityDecl(String name, String value) throws SAXException {
        if (SHOW_ALL)
            log.println("internalEntityDecl");
        // if (SHOW_ALL) log.println("Internal Entity\t" + name +
        // "\t" + value);
    }

    public void externalEntityDecl(String name, String publicId, String systemId)
        throws SAXException {
        if (SHOW_ALL)
            log.println("externalEntityDecl");
        // if (SHOW_ALL) log.println("Internal Entity\t" + name +
        // "\t" + publicId + "\t" + systemId);
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#endDocument()
     */
    public void endDocument() throws SAXException {
        if (SHOW_ALL)
            log.println("endDocument");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#startDocument()
     */
    public void startDocument() throws SAXException {
        if (SHOW_ALL)
            log.println("startDocument");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#characters(char[], int, int)
     */
    public void characters(char[] ch, int start, int length) throws SAXException {
        if (SHOW_ALL)
            log.println("characters");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
     */
    public void ignorableWhitespace(char[] ch, int start, int length)
        throws SAXException {
        if (SHOW_ALL)
            log.println("ignorableWhitespace");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#endPrefixMapping(java.lang.String)
     */
    public void endPrefixMapping(String prefix) throws SAXException {
        if (SHOW_ALL)
            log.println("endPrefixMapping");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#skippedEntity(java.lang.String)
     */
    public void skippedEntity(String name) throws SAXException {
        if (SHOW_ALL)
            log.println("skippedEntity");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#setDocumentLocator(org.xml.sax.Locator)
     */
    public void setDocumentLocator(Locator locator) {
        if (SHOW_ALL)
            log.println("setDocumentLocator");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#processingInstruction(java.lang.String,
     * java.lang.String)
     */
    public void processingInstruction(String target, String data)
        throws SAXException {
        if (SHOW_ALL)
            log.println("processingInstruction");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#startPrefixMapping(java.lang.String,
     * java.lang.String)
     */
    public void startPrefixMapping(String prefix, String uri) throws SAXException {
        if (SHOW_ALL)
            log.println("startPrefixMapping");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#endElement(java.lang.String,
     * java.lang.String, java.lang.String)
     */
    public void endElement(String namespaceURI, String localName, String qName)
        throws SAXException {
        if (SHOW_ALL)
            log.println("endElement");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ContentHandler#startElement(java.lang.String,
     * java.lang.String, java.lang.String, org.xml.sax.Attributes)
     */
    public void startElement(String namespaceURI, String localName, String qName,
        Attributes atts) throws SAXException {
        if (SHOW_ALL)
            log.println("startElement");
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException)
     */
    public void error(SAXParseException exception) throws SAXException {
        if (SHOW_ALL)
            log.println("error");
        throw exception;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException)
     */
    public void fatalError(SAXParseException exception) throws SAXException {
        if (SHOW_ALL)
            log.println("fatalError");
        throw exception;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException)
     */
    public void warning(SAXParseException exception) throws SAXException {
        if (SHOW_ALL)
            log.println("warning");
        throw exception;
    }

    public List<String> getAttributeOrder() {
        return attributeList;
    }

    public List<String> getElementOrder() {
        return orderingList;
    }

    public Set<String> getCommonAttributes() {
        return skipCommon;
    }

}
