package components.xmltree;

import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.Charset;

import javax.swing.JFrame;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import components.map.Map;
import components.map.Map1L;
import components.sequence.Sequence;
import components.sequence.Sequence1L;
import components.set.Set;
import components.set.Set1L;

/**
 * {@code XMLTree} represented as a recursive data structure, done
 * "bare-handed", with implementations of all methods.
 */
public class XMLTree1 extends XMLTreeSecondary {

    /*
     * Private members --------------------------------------------------------
     */

    /**
     * The root label (a tag or plain text).
     */
    private String label;

    /**
     * Flag to record whether root label is a tag.
     */
    private boolean isTag;

    /**
     * Map from attribute name to attribute value for root tag.
     */
    private Map<String, String> attributes;

    /**
     * Sequence of nested {@code XMLTree}s.
     */
    private Sequence<XMLTree> children;

    /**
     * The window to display the {@code XMLTree}.
     */
    private JFrame frame;

    /**
     * Parses the XML input and constructs (and returns) the corresponding DOM
     * tree.
     *
     * @param url
     *            the XML source (either a file or web URL)
     * @return the XML DOM tree
     */
    private Node getXML(URL url) {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = null;
        Document doc = null;
        try {
            db = dbf.newDocumentBuilder();
            InputSource is = new InputSource(url.toString());
            doc = db.parse(is);
        } catch (ParserConfigurationException e) {
            throw new AssertionError("Violation of: input is valid XML");
        } catch (SAXException e) {
            throw new AssertionError("Violation of: input is valid XML");
        } catch (IOException e) {
            // problem reading input: it may be an encoding issue
            try {
                String encoding = "UTF-8";
                if (Charset.defaultCharset().toString().equals(encoding)) {
                    encoding = "windows-1252";
                }
                Reader reader = new InputStreamReader(url.openStream(), encoding);
                InputSource is = new InputSource(reader);
                doc = db.parse(is);
                try {
                    reader.close();
                } catch (IOException e1) {
                    throw new AssertionError(
                            "Violation of: " + url.getFile() + " can be closed");
                }
            } catch (MalformedURLException e1) {
                throw new AssertionError("Violation of: input is valid XML");
            } catch (SAXException e1) {
                throw new AssertionError("Violation of: input is valid XML");
            } catch (IOException e1) {
                throw new AssertionError("Violation of: input is valid XML");
            } catch (NullPointerException e1) { // could occur on line 95?
                throw new AssertionError("Violation of: input is valid XML");
            }
        }
        return doc.getDocumentElement();
    }

    /**
     * Constructs the {@code XMLTree} representation from the given {@code Node}
     * .
     *
     * @param root
     *            the DOM tree from which to construct this {@code XMLTree}
     * @param trimWhitespace
     *            flag to indicate whether leading and trailing whitespace
     *            should be trimmed from text leaves
     */
    private void constructTree(Node root, boolean trimWhitespace) {
        if ((root.getNodeType() == Node.TEXT_NODE)
                || (root.getNodeType() == Node.CDATA_SECTION_NODE)) {
            String text = root.getTextContent();
            if (trimWhitespace) {
                text = text.trim();
            }
            this.label = text;
        } else {
            this.label = root.getNodeName();
            this.isTag = true;
            this.attributes = this.constructAttributes(root);
            this.children = new Sequence1L<XMLTree>();

            NodeList nl = root.getChildNodes();
            for (int pos = 0; pos < nl.getLength(); pos++) {
                XMLTree1 xmlChild = new XMLTree1();
                Node child = nl.item(pos);
                xmlChild.constructTree(child, trimWhitespace);
                if (xmlChild.isTag) {
                    this.children.add(this.children.length(), xmlChild);
                } else {
                    if (!xmlChild.label.equals("")) {
                        this.children.add(this.children.length(), xmlChild);
                    }
                }
            }
        }
    }

    /**
     * Returns attribute map constructed from the given {@code Node}.
     *
     * @param root
     *            the DOM tree whose root's attributes will be returned in the
     *            attribute map
     * @return the map of attribute (name, value) pairs
     */
    private Map<String, String> constructAttributes(Node root) {
        Map<String, String> map = new Map1L<String, String>();
        NamedNodeMap nnm = root.getAttributes();
        if (nnm != null) {
            for (int i = 0; i < nnm.getLength(); i++) {
                Node a = nnm.item(i);
                map.add(a.getNodeName(), a.getNodeValue());
            }
        }
        return map;
    }

    /**
     * Empty no-argument constructor to be used by constructTree.
     */
    private XMLTree1() {
    }

    /*
     * Constructors -----------------------------------------------------------
     */

    /**
     * Constructs an {@code XMLTree} from input {@code source} (could be a file
     * or a URL). Leading and trailing whitespace is trimmed from text nodes.
     *
     * @param source
     *            XML input
     * @requires source is the name of a file or a URL
     * @ensures <pre>
     * this = [the XMLTree corresponding to the given input source,
     *         with whitespace trimmed]
     * </pre>
     */
    public XMLTree1(String source) {
        this(source, true);
    }

    /**
     * Constructs an {@code XMLTree} from input {@code source} (could be a file
     * or a URL).
     *
     * @param source
     *            XML input
     * @param trimWhitespace
     *            flag to indicate whether leading and trailing whitespace
     *            should be trimmed from text nodes
     * @requires source is the name of a file or a URL
     * @ensures <pre>
     * this = [the XMLTree corresponding to the given input source,
     *         with whitespace trimmed only if trimWhitespace]
     * </pre>
     */
    public XMLTree1(String source, boolean trimWhitespace) {
        assert source != null : "Violation of: source is not null";
        URL url = null;
        try {
            url = new URI(source).toURL();
        } catch (URISyntaxException | MalformedURLException e) {
            if (source.indexOf("://") != -1) {
                // assume it was a URL
                throw new AssertionError("Violation of: " + source + " is a valid URL");
            }
            try {
                File file = new File(source);
                if (!file.exists()) {
                    throw new AssertionError("Violation of: " + source + " exists");
                }
                if (!file.isFile()) {
                    throw new AssertionError("Violation of: " + source + " is a file");
                }
                if (!file.canRead()) {
                    throw new AssertionError("Violation of: " + source + " is readable");
                }
                url = file.toURI().toURL();
            } catch (MalformedURLException e1) {
                throw new AssertionError(
                        "Violation of: " + source + " is a valid XML source");
            }
        }

        Node root = this.getXML(url);
        this.constructTree(root, trimWhitespace);
    }

    /*
     * Kernel methods ---------------------------------------------------------
     */

    @Override
    public final String label() {
        return this.label;
    }

    @Override
    public final boolean isTag() {
        return this.isTag;
    }

    @Override
    public final boolean hasAttribute(String name) {
        assert name != null : "Violation of: name is not null";
        assert this.isTag : "Violation of: the label of the root of this is a tag";
        return this.attributes.hasKey(name);
    }

    @Override
    public final String attributeValue(String name) {
        assert name != null : "Violation of: name is not null";
        assert this.isTag : "Violation of: the label of the root of this is a tag";
        assert this.attributes.hasKey(name)
                : "Violation of: the root of this has an attribute called " + name;
        return this.attributes.value(name);
    }

    @Override
    public final int numberOfChildren() {
        assert this.isTag : "Violation of: the label of the root of this is a tag";
        return this.children.length();
    }

    @Override
    public final XMLTree child(int k) {
        assert this.isTag : "Violation of: the label of the root of this is a tag";
        assert k >= 0 : "Violation of: 0 <= k";
        assert k < this.children.length()
                : "Violation of: k < the number of subtrees of the root of this";
        return this.children.entry(k);
    }

    @Override
    public final Iterable<String> attributeNames() {
        assert this.isTag : "Violation of: the label of the root of this is a tag";
        Set<String> set = new Set1L<>();
        for (Map.Pair<String, String> pair : this.attributes) {
            set.add(pair.key());
        }
        return set;
    }

    @Override
    public final void display() {
        this.display(XMLTreeFrame.DEFAULT_TITLE);
    }

    @Override
    public final void display(String title) {
        if (this.frame == null) {
            this.frame = new XMLTreeFrame(this, title);
        }
        this.frame.setVisible(true);
    }

}