/*

  * 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;

     }

 }