/*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
  *
  * Copyright 2014 Mike Becker. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   1. Redistributions of source code must retain the above copyright
  *      notice, this list of conditions and the following disclaimer.
  *
  *   2. Redistributions in binary form must reproduce the above copyright
  *      notice, this list of conditions and the following disclaimer in the
  *      documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 package de.uapcore.sigred.doc.base;
 
 import de.uapcore.sigred.doc.Resources;
 import de.uapcore.sigrapi.impl.Digraph;
 import de.uapcore.sigrapi.impl.Graph;
 import de.uapcore.sigrapi.IGraph;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import org.apache.xerces.impl.Constants;
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.DocumentHelper;
 import org.dom4j.Element;
 import org.dom4j.Namespace;
 import org.dom4j.QName;
 import org.dom4j.io.OutputFormat;
 import org.dom4j.io.SAXReader;
 import org.dom4j.io.XMLWriter;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 
 public abstract class AbstractGraphDocument<T extends IGraph>
         extends FileBackedDocument {
     
     protected static final Namespace NAMESPACE = Namespace.get("sigred",
         "http://develop.uap-core.de/sigred/");
     
     private static final
         QName TAG_GRAPHDOC = QName.get("graph-document", NAMESPACE);
     private static final
         QName TAG_GRAPH = QName.get("graph", NAMESPACE);
     private static final
         QName TAG_DIGRAPH = QName.get("digraph", NAMESPACE);
     private static final
         QName TAG_METADATA = QName.get("metadata", NAMESPACE);
     
     protected final T graph;
     
     private final GraphDocumentMetadata metadata;
     
     public AbstractGraphDocument(Class<T> graphType) {
         T g;
         try {
             g = graphType.newInstance();
         } catch (ReflectiveOperationException e) {
             assert false;
             g = null; // for the compiler
         }
         graph = g;
         metadata = new GraphDocumentMetadata();
     }
 
     public T getGraph() {
         return graph;
     }
     
     public GraphDocumentMetadata getMetadata() {
         return metadata;
     }
 
     protected abstract void writeGraph(Element rootNode) throws IOException;
     protected abstract void readGraph(Element rootNode) throws IOException;
 
     @Override
     public void writeTo(OutputStream out) throws IOException {
         Document doc = DocumentHelper.createDocument();
 
         Element rootNode = doc.addElement(TAG_GRAPHDOC);
 
         Element metadataNode = rootNode.addElement(TAG_METADATA);
 
         metadata.write(metadataNode);
 
         if (graph instanceof Graph) {
             writeGraph(rootNode.addElement(TAG_GRAPH));
         } else if (graph instanceof Digraph) {
             writeGraph(rootNode.addElement(TAG_DIGRAPH));
         } else {
             throw new IOException("unsupported graph type");
         }
 
         XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
         writer.write(doc);
         writer.flush();
     }
 
     @Override
     public void readFrom(InputStream in) throws IOException {
         try {
             SAXReader reader = new SAXReader(true);
             reader.setStripWhitespaceText(true);
             
             reader.setFeature(Constants.XERCES_FEATURE_PREFIX+
                 Constants.SCHEMA_VALIDATION_FEATURE, true);
             reader.setProperty(Constants.XERCES_PROPERTY_PREFIX +
                 Constants.SCHEMA_LOCATION, String.format("%s %s",
                     NAMESPACE.getURI(), Resources.class.getResource(
                         "graph-document.xsd").toExternalForm()));
             
             final AtomicBoolean passed = new AtomicBoolean(true);
             final AtomicReference<SAXParseException> xmlerror = new AtomicReference<>();
             // TODO: we should do more detailed error handling here
             reader.setErrorHandler(new ErrorHandler() {
                 @Override
                 public void warning(SAXParseException exception) throws SAXException {
                 }
 
                 @Override
                 public void error(SAXParseException exception) throws SAXException {
                     xmlerror.set(exception);
                     passed.set(false);
                 }
 
                 @Override
                 public void fatalError(SAXParseException exception) throws SAXException {
                     xmlerror.set(exception);
                     passed.set(false);
                 }
                 
             });
             Document doc = reader.read(in);
             if (!passed.get()) {
                 // TODO: provide details (maybe via separate error object?)
                 throw xmlerror.get();
             }
             
             doc.normalize();
             
             Element root = doc.getRootElement();
             metadata.read(root.element(TAG_METADATA));
             
             if (graph instanceof Graph) {
                 readGraph(root.element(TAG_GRAPH));
             } else if (graph instanceof Digraph) {
                 readGraph(root.element(TAG_DIGRAPH));
             } else {
                 throw new IOException("unsupported graph type");
             }
         } catch (DocumentException | SAXException ex) {
             throw new IOException(ex);
         }
     }
 }