/*
 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package test.gaptest;

import static jaxp.library.JAXPTestUtilities.filenameToURL;
import static org.testng.Assert.assertEquals;
import static test.gaptest.GapTestConst.GOLDEN_DIR;
import static test.gaptest.GapTestConst.XML_DIR;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.stream.StreamSource;

import jaxp.library.JAXPFileBaseTest;

import org.testng.annotations.Test;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/*
 * @bug 4858685 4894410
 * @summary test transforming text node
 */

public class Bug4858685 extends JAXPFileBaseTest {
    @Test
    public void test() throws TransformerException, IOException {
        String uri = XML_DIR + "certificate.xml";
        TransformerFactory transformerFactory = TransformerFactory.newInstance();

        Transformer transformer = transformerFactory.newTransformer();

        // use URI as a StreamSource
        StreamSource streamSource = new StreamSource(filenameToURL(uri));

        DOMResult domResult = new DOMResult();

        // StreamSource -> DOMResult
        transformer.transform(streamSource, domResult);

        // dump DOM in a human readable form
        String gotString = DOMDump.dumpDom(domResult.getNode());

        String goldenString = new String(Files.readAllBytes(Paths.get(GOLDEN_DIR + "Bug4858685.txt")));

        assertEquals(gotString, goldenString);

    }

    /**
     * DOMDump: dump a DOM to a String in human readable form. method dumpDOM()
     * is static for easy calling:
     */
    private static class DOMDump {

        /**
         * the maximum level to indent with blanks
         */
        private static final int BLANKS_LEN = 64;

        /**
         * each level of the tree will be indented with blanks for readability
         */
        private static final String BLANKS = "                                                              ";

        /**
         * dumpDOM will dump the DOM into a String for human readability
         *
         * @param domNode
         *            the DOM Node to dump
         * @return human readabile DOM as a String
         */
        public static String dumpDom(Node domNode) {
            return dumpInternal(domNode, 0);
        }

        /**
         * dumpInternal is used internaly to recursively dump DOM Nodes
         *
         * @param domNode
         *            to dump
         * @param indent
         *            level
         * @return domNode as human readable String
         */
        private static String dumpInternal(Node domNode, int indent) {

            String result = "";

            // indent for readability
            result += indentBlanks(indent);
            indent += 2;

            // protect against null
            if (domNode == null) {
                result = result + "[null]" + "\n";
                return result;
            }

            // what to output depends on NodeType
            short type = domNode.getNodeType();
            switch (type) {
                case Node.ATTRIBUTE_NODE: {
                    result += "[attribute] " + domNode.getNodeName() + "=\"" + domNode.getNodeValue() + "\"";
                    break;
                }
                case Node.CDATA_SECTION_NODE: {
                    result += "[cdata] " + domNode.getNodeValue();
                    break;
                }
                case Node.COMMENT_NODE: {
                    result += "[comment] " + domNode.getNodeValue();
                    break;
                }
                case Node.DOCUMENT_FRAGMENT_NODE: {
                    result += "[document fragment]";
                    break;
                }
                case Node.DOCUMENT_NODE: {
                    result += "[document]";
                    break;
                }
                case Node.DOCUMENT_TYPE_NODE: {
                    result += "[document type] " + domNode.getNodeName();
                    break;
                }
                case Node.ELEMENT_NODE: {
                    result += "[element] " + domNode.getNodeName();
                    // output all attributes for Element
                    if (domNode.hasAttributes()) {
                        NamedNodeMap attributes = domNode.getAttributes();
                        for (int onAttribute = 0; onAttribute < attributes.getLength(); onAttribute++) {

                            // seprate each attribute with a space
                            result += " ";

                            Node attribute = attributes.item(onAttribute);
                            String namespaceURI = attribute.getNamespaceURI();
                            String prefix = attribute.getPrefix();
                            String localName = attribute.getLocalName();
                            String name = attribute.getNodeName();
                            String value = attribute.getNodeValue();

                            // using Namespaces?
                            if (namespaceURI != null) {
                                result += "{" + namespaceURI + "}";
                            }
                            if (prefix != null) {
                                result += prefix + ":";
                            }

                            // name="value"
                            result += attribute.getNodeName() + "=\"" + attribute.getNodeValue() + "\"";
                        }
                    }

                    break;
                }
                case Node.ENTITY_NODE: {
                    result += "[entity] " + domNode.getNodeName();
                    break;
                }
                case Node.ENTITY_REFERENCE_NODE: {
                    result += "[entity reference] " + domNode.getNodeName();
                    break;
                }
                case Node.NOTATION_NODE: {
                    result += "[notation] " + domNode.getNodeName();
                    break;
                }
                case Node.PROCESSING_INSTRUCTION_NODE: {
                    result += "[pi] target=\"" + domNode.getNodeName() + "\" content=\"" + domNode.getNodeValue() + "\"";
                    break;
                }
                case Node.TEXT_NODE: {
                    result += "[text] " + domNode.getNodeValue();
                    break;
                }
                default: {
                    result += "[unknown]";
                    break;
                }
            }

            // humans read in lines
            result += "\n";

            // process children
            NodeList children = domNode.getChildNodes();
            for (int onChild = 0; onChild < children.getLength(); onChild++) {
                Node child = children.item(onChild);
                result += dumpInternal(child, indent);
            }

            // return human readable DOM as String
            return result;
        }

        /**
         * indentBlanks will return a String of indent blanks
         *
         * @param indent
         *            level
         * @return String of blanks
         */
        private static String indentBlanks(int indent) {
            if (indent == 0) {
                return "";
            }

            if (indent > BLANKS_LEN) {
                return BLANKS;
            }

            return BLANKS.substring(0, indent + 1);
        }

    }
}