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.set.Set;
import components.set.Set1L;
import components.tree.Tree;
import components.tree.Tree1;

/**
 * {@code XMLTree} represented as a {@link Tree}, with implementations of all
 * methods.
 */
public class XMLTree2 extends XMLTreeSecondary {

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

    /**
     * Node for the tree representation.
     */
    private static final class TreeNode {

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

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

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

    }

    /**
     * Tree representation for the {@code XMLTree}.
     */
    private final Tree<TreeNode> rep;

    /**
     * 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 103?
                throw new AssertionError("Violation of: input is valid XML");
            }
        }
        return doc.getDocumentElement();
    }

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

            NodeList nl = root.getChildNodes();
            for (int pos = 0; pos < nl.getLength(); pos++) {
                Node child = nl.item(pos);
                Tree<TreeNode> subtree = constructTree(child, trimWhitespace);
                if (subtree.root().isTag) {
                    children.add(children.length(), subtree);
                } else {
                    if (!subtree.root().label.equals("")) {
                        children.add(children.length(), subtree);
                    }
                }
            }
        }
        tree.assemble(tNode, children);
        return tree;
    }

    /**
     * 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 static 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;
    }

    /**
     * Constructor to be used by {@code child}.
     *
     * @param rep
     *            the representation for the new {@code XMLTree}
     */
    private XMLTree2(Tree<TreeNode> rep) {
        this.rep = rep;
    }

    /*
     * 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 XMLTree2(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 XMLTree2(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.rep = constructTree(root, trimWhitespace);
    }

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

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

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

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

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

    @Override
    public final int numberOfChildren() {
        assert this.rep.root().isTag
                : "Violation of: the label of the root of this is a tag";
        Sequence<Tree<TreeNode>> children = this.rep.newSequenceOfTree();
        TreeNode root = this.rep.disassemble(children);
        int length = children.length();
        this.rep.assemble(root, children);
        return length;
    }

    @Override
    public final XMLTree child(int k) {
        assert this.rep.root().isTag
                : "Violation of: the label of the root of this is a tag";
        assert k >= 0 : "Violation of: 0 <= k";
        assert k < this.rep.numberOfSubtrees()
                : "Violation of: k < the number of subtrees of the root of this";
        Sequence<Tree<TreeNode>> children = this.rep.newSequenceOfTree();
        TreeNode root = this.rep.disassemble(children);
        Tree<TreeNode> child = children.entry(k);
        this.rep.assemble(root, children);
        return new XMLTree2(child);
    }

    @Override
    public final Iterable<String> attributeNames() {
        assert this.rep.root().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.rep.root().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);
    }

}