/*

 * Copyright 2002-2006 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.util.xml;

import java.util.*;

import java.util.prefs.*;

import java.io.*;

/**

 * Simplified XML Support for java.util.prefs. Methods to import and export preference

 * nodes and subtrees.

 *

 * @author  Jaroslav Tulach

 * @since   1.7

 */

public class DefaultPrefsXmlSupport extends sun.util.xml.PrefsXmlSupport {

    public void export(OutputStream os, final Preferences p, boolean subTree)

        throws IOException, BackingStoreException {

        if (isRemoved(p))

            throw new IllegalStateException("Node has been removed");

        PrintWriter w = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));

        w.println("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>");

        w.println("<!DOCTYPE preferences SYSTEM \"http://java.sun.com/dtd/preferences.dtd\">");

        w.println("<preferences EXTERNAL_XML_VERSION=\"1.0\">");

        w.print("  <root type=\"");

        w.print(p.isUserNode() ? "user" : "system");

        w.println("\">");

        LinkedList<Preferences> ancestors = new LinkedList<Preferences>();

        for (Preferences kid = p, dad = kid.parent(); dad != null;

                kid = dad, dad = kid.parent()) {

            ancestors.addFirst(kid);

        }

        String indent = "  ";

        for (Preferences pref : ancestors) {

            indent = "  " + indent;

            w.print(indent); w.println("<map/>");

            w.print(indent); w.print("<node name=\""); w.print(pref.name()); w.println("\">");

        }

        putPreferencesInXml(w, indent + "  ", p, subTree);

        for (Preferences pref : ancestors) {

            w.print(indent); w.println("</node>");

            indent = indent.substring(2);

        }

        w.println("  </root>");

        w.println("</preferences>");

        w.flush();

    }

    private static void putPreferencesInXml(

        PrintWriter w, String indent, Preferences prefs, boolean subTree

    ) throws BackingStoreException {

        Preferences[] kidsCopy = null;

        String[] kidNames = null;

        // Node is locked to export its contents and get a

        // copy of children, then lock is released,

        // and, if subTree = true, recursive calls are made on children

        synchronized (lock(prefs)) {

            // Check if this node was concurrently removed. If yes

            // don't print it

            if (isRemoved(prefs)) {

                return;

            }

            // Put map in xml element

            String[] keys = prefs.keys();

            if (keys.length == 0) {

                w.print(indent); w.println("<map/>");

            } else {

                w.print(indent); w.println("<map>");

                for (int i=0; i<keys.length; i++) {

                    w.print(indent); w.print("  <entry key=\"");

                    w.print(keys[i]);

                    w.print("\" value=\"");

                    w.print(prefs.get(keys[i], null));

                    w.println("\"/>");

                }

                w.print(indent); w.println("</map>");

            }

            // Recurse if appropriate

            if (subTree) {

                /* Get a copy of kids while lock is held */

                kidNames = prefs.childrenNames();

                kidsCopy = new Preferences[kidNames.length];

                for (int i = 0; i <  kidNames.length; i++)

                    kidsCopy[i] = prefs.node(kidNames[i]);

            }

            // release lock

        }

        if (subTree) {

            for (int i=0; i < kidNames.length; i++) {

                w.print(indent); w.print("<node name=\"");

                w.print(kidNames[i]);

                w.println("\">");

                putPreferencesInXml(w, "  " + indent, kidsCopy[i], subTree);

                w.print(indent); w.println("</node>");

            }

        }

    }

    /**

     * Import preferences from the specified input stream, which is assumed

     * to contain an XML document in the format described in the Preferences

     * spec.

     *

     * @throws IOException if reading from the specified output stream

     *         results in an <tt>IOException</tt>.

     * @throws InvalidPreferencesFormatException Data on input stream does not

     *         constitute a valid XML document with the mandated document type.

     */

    public void importPreferences(InputStream is)

        throws IOException, InvalidPreferencesFormatException

    {

        /*

        try {

            Document doc = loadPrefsDoc(is);

            String xmlVersion =

                doc.getDocumentElement().getAttribute("EXTERNAL_XML_VERSION");

            if (xmlVersion.compareTo(EXTERNAL_XML_VERSION) > 0)

                throw new InvalidPreferencesFormatException(

                "Exported preferences file format version " + xmlVersion +

                " is not supported. This java installation can read" +

                " versions " + EXTERNAL_XML_VERSION + " or older. You may need" +

                " to install a newer version of JDK.");

            Element xmlRoot = (Element) doc.getDocumentElement().

                                               getChildNodes().item(0);

            Preferences prefsRoot =

                (xmlRoot.getAttribute("type").equals("user") ?

                            Preferences.userRoot() : Preferences.systemRoot());

            ImportSubtree(prefsRoot, xmlRoot);

        } catch(SAXException e) {

            throw new InvalidPreferencesFormatException(e);

        }

         */

    }

    /**

     * Create a new prefs XML document.

     *

    private static Document createPrefsDoc( String qname ) {

        try {

            DOMImplementation di = DocumentBuilderFactory.newInstance().

                newDocumentBuilder().getDOMImplementation();

            DocumentType dt = di.createDocumentType(qname, null, PREFS_DTD_URI);

            return di.createDocument(null, qname, dt);

        } catch(ParserConfigurationException e) {

            throw new AssertionError(e);

        }

    }

    /**

     * Load an XML document from specified input stream, which must

     * have the requisite DTD URI.

     *

    private static Document loadPrefsDoc(InputStream in)

        throws SAXException, IOException

    {

        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

        dbf.setIgnoringElementContentWhitespace(true);

        dbf.setValidating(true);

        dbf.setCoalescing(true);

        dbf.setIgnoringComments(true);

        try {

            DocumentBuilder db = dbf.newDocumentBuilder();

            db.setEntityResolver(new Resolver());

            db.setErrorHandler(new EH());

            return db.parse(new InputSource(in));

        } catch (ParserConfigurationException e) {

            throw new AssertionError(e);

        }

    }

    /**

     * Write XML document to the specified output stream.

     *

    private static final void writeDoc(Document doc, OutputStream out)

        throws IOException

    {

        try {

            TransformerFactory tf = TransformerFactory.newInstance();

            try {

                tf.setAttribute("indent-number", new Integer(2));

            } catch (IllegalArgumentException iae) {

                //Ignore the IAE. Should not fail the writeout even the

                //transformer provider does not support "indent-number".

            }

            Transformer t = tf.newTransformer();

            t.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doc.getDoctype().getSystemId());

            t.setOutputProperty(OutputKeys.INDENT, "yes");

            //Transformer resets the "indent" info if the "result" is a StreamResult with

            //an OutputStream object embedded, creating a Writer object on top of that

            //OutputStream object however works.

            t.transform(new DOMSource(doc),

                        new StreamResult(new BufferedWriter(new OutputStreamWriter(out, "UTF-8"))));

        } catch(TransformerException e) {

            throw new AssertionError(e);

        }

    }

    /**

     * Recursively traverse the specified preferences node and store

     * the described preferences into the system or current user

     * preferences tree, as appropriate.

     *

    private static void ImportSubtree(Preferences prefsNode, Element xmlNode) {

        NodeList xmlKids = xmlNode.getChildNodes();

        int numXmlKids = xmlKids.getLength();

        /*

         * We first lock the node, import its contents and get

         * child nodes. Then we unlock the node and go to children

         * Since some of the children might have been concurrently

         * deleted we check for this.

         * /

        Preferences[] prefsKids;

        /* Lock the node * /

        synchronized (lock(prefsNode)) {

            //If removed, return silently

            if (isRemoved(prefsNode))

                return;

            // Import any preferences at this node

            Element firstXmlKid = (Element) xmlKids.item(0);

            ImportPrefs(prefsNode, firstXmlKid);

            prefsKids = new Preferences[numXmlKids - 1];

            // Get involved children

            for (int i=1; i < numXmlKids; i++) {

                Element xmlKid = (Element) xmlKids.item(i);

                prefsKids[i-1] = prefsNode.node(xmlKid.getAttribute("name"));

            }

        } // unlocked the node

        // import children

        for (int i=1; i < numXmlKids; i++)

            ImportSubtree(prefsKids[i-1], (Element)xmlKids.item(i));

    }

    /**

     * Import the preferences described by the specified XML element

     * (a map from a preferences document) into the specified

     * preferences node.

     * /

    private static void ImportPrefs(Preferences prefsNode, Element map) {

        NodeList entries = map.getChildNodes();

        for (int i=0, numEntries = entries.getLength(); i < numEntries; i++) {

            Element entry = (Element) entries.item(i);

            prefsNode.put(entry.getAttribute("key"),

                          entry.getAttribute("value"));

        }

    }

    /**

     * Export the specified Map<String,String> to a map document on

     * the specified OutputStream as per the prefs DTD.  This is used

     * as the internal (undocumented) format for FileSystemPrefs.

     *

     * @throws IOException if writing to the specified output stream

     *         results in an <tt>IOException</tt>.

     */

    public void exportMap(OutputStream os, Map map) throws IOException {

        /*

        Document doc = createPrefsDoc("map");

        Element xmlMap = doc.getDocumentElement( ) ;

        xmlMap.setAttribute("MAP_XML_VERSION", MAP_XML_VERSION);

        for (Iterator i = map.entrySet().iterator(); i.hasNext(); ) {

            Map.Entry e = (Map.Entry) i.next();

            Element xe = (Element)

                xmlMap.appendChild(doc.createElement("entry"));

            xe.setAttribute("key",   (String) e.getKey());

            xe.setAttribute("value", (String) e.getValue());

        }

        writeDoc(doc, os);

         */

    }

    /**

     * Import Map from the specified input stream, which is assumed

     * to contain a map document as per the prefs DTD.  This is used

     * as the internal (undocumented) format for FileSystemPrefs.  The

     * key-value pairs specified in the XML document will be put into

     * the specified Map.  (If this Map is empty, it will contain exactly

     * the key-value pairs int the XML-document when this method returns.)

     *

     * @throws IOException if reading from the specified output stream

     *         results in an <tt>IOException</tt>.

     * @throws InvalidPreferencesFormatException Data on input stream does not

     *         constitute a valid XML document with the mandated document type.

     */

    public void importMap(InputStream is, Map m)

        throws IOException, InvalidPreferencesFormatException

    {

        /*

        try {

            Document doc = loadPrefsDoc(is);

            Element xmlMap = doc.getDocumentElement();

            // check version

            String mapVersion = xmlMap.getAttribute("MAP_XML_VERSION");

            if (mapVersion.compareTo(MAP_XML_VERSION) > 0)

                throw new InvalidPreferencesFormatException(

                "Preferences map file format version " + mapVersion +

                " is not supported. This java installation can read" +

                " versions " + MAP_XML_VERSION + " or older. You may need" +

                " to install a newer version of JDK.");

            NodeList entries = xmlMap.getChildNodes();

            for (int i=0, numEntries=entries.getLength(); i<numEntries; i++) {

                Element entry = (Element) entries.item(i);

                m.put(entry.getAttribute("key"), entry.getAttribute("value"));

            }

        } catch(SAXException e) {

            throw new InvalidPreferencesFormatException(e);

        }

         */

    }

/*

    private static class Resolver implements EntityResolver {

        public InputSource resolveEntity(String pid, String sid)

            throws SAXException

        {

            if (sid.equals(PREFS_DTD_URI)) {

                InputSource is;

                is = new InputSource(new StringReader(PREFS_DTD));

                is.setSystemId(PREFS_DTD_URI);

                return is;

            }

            throw new SAXException("Invalid system identifier: " + sid);

        }

    }

    private static class EH implements ErrorHandler {

        public void error(SAXParseException x) throws SAXException {

            throw x;

        }

        public void fatalError(SAXParseException x) throws SAXException {

            throw x;

        }

        public void warning(SAXParseException x) throws SAXException {

            throw x;

        }

    }

*/

    private static boolean isRemoved(Preferences p) {

        try {

            p.parent(); // throws IllegalStateException if removed;

            return false;

        } catch (IllegalStateException ex) {

            return true;

        }

    }

    private static Object lock(Preferences p) {

        /** JST-XXX: Needs reflection or accessor:

         * http://wiki.apidesign.org/wiki/FriendPackages

        return ((AbstractPreferences)prefs).lock;

         */

        return p;

    }

}