/* $Id: XmiReaderImpl.java 18631 2010-08-08 06:49:47Z linus $

  *****************************************************************************

  * Copyright (c) 2005,2010 Contributors - see below

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *    Bob Tarling

  *    Tom Morris

  *    euluis

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 1996-2009 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies.  This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason.  IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.model.mdr;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.net.URL;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.List;

 import java.util.Map;

 import javax.jmi.reflect.InvalidObjectException;

 import javax.jmi.reflect.RefObject;

 import javax.jmi.reflect.RefPackage;

 import javax.jmi.xmi.MalformedXMIException;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.parsers.SAXParser;

 import javax.xml.parsers.SAXParserFactory;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.sax.SAXSource;

 import javax.xml.transform.sax.SAXTransformerFactory;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import org.apache.log4j.Logger;

 import org.argouml.model.UmlException;

 import org.argouml.model.XmiException;

 import org.argouml.model.XmiReader;

 import org.netbeans.api.mdr.MDRepository;

 import org.netbeans.api.xmi.XMIReader;

 import org.netbeans.api.xmi.XMIReaderFactory;

 import org.netbeans.lib.jmi.xmi.InputConfig;

 import org.netbeans.lib.jmi.xmi.UnknownElementsListener;

 import org.netbeans.lib.jmi.xmi.XMIHeaderConsumer;

 import org.omg.uml.UmlPackage;

 import org.openide.ErrorManager;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.xml.sax.XMLFilter;

 import org.xml.sax.XMLReader;

 /**

  * A wrapper around the genuine XmiReader that provides public access with no

  * knowledge of actual UML implementation.

  *

  * @author Bob Tarling

  */

 class XmiReaderImpl implements XmiReader, UnknownElementsListener,

         XMIHeaderConsumer {

     /**

      * Logger.

      */

     private static final Logger LOG = Logger.getLogger(XmiReaderImpl.class);

     private MDRModelImplementation modelImpl;

     private XmiReferenceResolverImpl resolver;

     /**

      * Flag indicating unknown element was found in XMI file.

      */

     private boolean unknownElement;

     /**

      * Name of first unknown element found (if not a UML 1.3 name).

      */

     private String unknownElementName;

     /**

      * Flag indicating that we think unknown element was due to a UML 1.3 file.

      */

     private boolean uml13;

     /**

      * Elements to ignore errors on if they aren't found in the metamodel.

      */

     private String[] ignoredElements = new String[] {};

     /**

      * Flag indicating that we stripped at least one diagram during the import.

      */

     private int ignoredElementCount;

     /**

      * String that we pulled from the header of the XMI file

      */

     private String xmiHeader;

     /**

      * Constructor for XMIReader.

      * @param parentModelImplementation The ModelImplementation

      */

     XmiReaderImpl(MDRModelImplementation parentModelImplementation) {

         modelImpl = parentModelImplementation;

     }

     public Collection parse(InputSource inputSource, boolean readOnly)

         throws UmlException {

         Collection<RefObject> newElements = Collections.emptyList();

         String extentBase = inputSource.getPublicId();

         if (extentBase == null) {

             extentBase = inputSource.getSystemId();

         }

         if (extentBase == null) {

             extentBase = MDRModelImplementation.MODEL_EXTENT_NAME;

         }

         String extentName = extentBase;

         UmlPackage extent = 

             (UmlPackage) modelImpl.getRepository().getExtent(extentName);

         int serial = 1;

         while (extent != null) {

             extentName = extentBase + " " + serial;

             serial++;

             extent = (UmlPackage) modelImpl.getRepository().getExtent(

                     extentName);

         }

         extent = (UmlPackage) modelImpl.createExtent(extentName, readOnly);

         if (extent == null) {

             LOG.error("Failed to create extent " + extentName);

         }

         try {

             LOG.info("Loading to extent '" + extentName + "' " + extent);

             InputConfig config = new InputConfig();

             config.setUnknownElementsListener(this);

             config.setUnknownElementsIgnored(true);

             String pId = inputSource.getPublicId();

             String sId = modelImpl.getPublic2SystemIds().get(pId);

             if (sId != null) {

                 if (sId.equals(inputSource.getSystemId())) {

                     LOG.info("Attempt to reread profile - ignoring - "

                             + "publicId = \"" + pId + "\";  systemId = \""

                             + sId + "\".");

                     return Collections.emptySet();

                 } else {

                     throw new UmlException("Profile with the duplicate publicId "

                             + "is being loaded! publicId = \"" + pId

                             + "\"; existing systemId = \""

                             + modelImpl.getPublic2SystemIds().get(pId)

                             + "\"; new systemId = \"" + sId + "\".");

                 }

             }

             resolver = new XmiReferenceResolverImpl(new RefPackage[] {extent},

                     config, modelImpl.getObjectToId(), 

                     modelImpl.getPublic2SystemIds(), modelImpl.getIdToObject(), 

                     modelImpl.getSearchPath(), 

                     readOnly, 

                     inputSource.getPublicId(), inputSource.getSystemId(),

                     modelImpl);

             config.setReferenceResolver(resolver);

             config.setHeaderConsumer(this);

             XMIReader xmiReader =

                     XMIReaderFactory.getDefault().createXMIReader(config);

             /*

              * MDR has a hardcoded printStackTrace on all exceptions,

              * even if they're caught, which is unsightly, so we handle

              * unknown elements ourselves rather than letting MDR throw

              * an exception for us to catch.

              * 

              * org/netbeans/lib/jmi/util/Logger.java

              * 

              * This can be uses to disable logging.  Default output is 

              * System.err

              * setProperty("org.netbeans.lib.jmi.Logger.fileName", "")

              *              org.netbeans.mdr.Logger

              * 

              * The property org.netbeans.lib.jmi.Logger controls the minimum 

              * severity level for logging

              */

             // Turn off NetBeans logging to System.err

 //            System.setProperty("org.netbeans.lib.jmi.Logger.fileName", "");

             // Set minimum severity level for MDR

 //            System.setProperty("org.netbeans.lib.jmi.Logger", 

 //                    Integer.toString(ErrorManager.INFORMATIONAL));

             InputConfig config2 = (InputConfig) xmiReader.getConfiguration();

             config2.setUnknownElementsListener(this);

             config2.setUnknownElementsIgnored(true);

             unknownElement = false;

             uml13 = false;

             ignoredElementCount = 0;

             // Disable event delivery during model load

             modelImpl.getModelEventPump().stopPumpingEvents();

             try {

                 String systemId = inputSource.getSystemId();

                 // If we've got a streaming input, copy it to make sure we'll

                 // be able to rewind it if necessary

                 if (inputSource.getByteStream() != null

                         || inputSource.getCharacterStream() != null) {

                     File file = copySource(inputSource);

                     systemId = file.toURI().toURL().toExternalForm();

                     String publicId = inputSource.getPublicId();

                     inputSource = new InputSource(systemId);

                     inputSource.setPublicId(publicId);                    

                 }

                 MDRepository repository = modelImpl.getRepository();

                 // Use a transaction to avoid the performance penalty (3x) of 

                 // MDR's autocommit mode

                 repository.beginTrans(true);

                 newElements = xmiReader.read(inputSource.getByteStream(),

                         systemId, extent);

                 // If a UML 1.3 file, attempt to upgrade it to UML 1.4

                 if (uml13) {

                     // Roll back transaction from first attempt & start new one

                     repository.endTrans(true);

                     repository.beginTrans(true);

                     // Clear the associated ID maps & reset starting collection

                     resolver.clearIdMaps();

                     newElements = convertAndLoadUml13(inputSource.getSystemId(),

                             extent, xmiReader, inputSource);

                 }

                 // Commit our transaction

                 repository.endTrans();

             } catch (Throwable e) {

                 // Roll back transaction to remove any partial results read

                 try {

                     modelImpl.getRepository().endTrans(true);

                 } catch (Throwable e2) {

                     // Ignore any error.  The transaction may already have

                     // been unwound as part of exception processing by MDR

                 }

                 if (e instanceof MalformedXMIException) {

                     throw (MalformedXMIException) e;

                 } else if (e instanceof IOException) {

                     throw (IOException) e;

                 } else {

                     // We shouldn't get here, but just in case...

                     // We want a wide exception catcher to make sure our

                     // transaction always gets ended

                     e.printStackTrace();

                     throw new MalformedXMIException();

                 }

             } finally {

                 modelImpl.getModelEventPump().startPumpingEvents();

             }

             if (unknownElement) {

                 modelImpl.deleteExtent(extent);

                 throw new XmiException("Unknown element in XMI file : "

                         + unknownElementName);

             }

             if (ignoredElementCount > 0) {

                 LOG.warn("Ignored one or more elements from list "

                         + ignoredElements);

             }

         } catch (MalformedXMIException e) {

             // If we can find a nested SAX exception, it will have information

             // on the line number, etc.

             ErrorManager.Annotation[] annotations = 

                 ErrorManager.getDefault().findAnnotations(e);

             for (ErrorManager.Annotation annotation : annotations) {

                 Throwable throwable = annotation.getStackTrace();

                 if (throwable instanceof SAXParseException) {

                     SAXParseException spe = (SAXParseException) throwable;

                     throw new XmiException(spe.getMessage(), spe.getPublicId(),

                             spe.getSystemId(), spe.getLineNumber(), 

                             spe.getColumnNumber(), e);

                 } else if (throwable instanceof SAXException) {

                     SAXException se = (SAXException) throwable;

                     Exception e1 = se.getException();

                     if (e1 instanceof org.argouml.model.XmiReferenceRuntimeException) {

                         String href = 

                             ((org.argouml.model.XmiReferenceRuntimeException) e1)

                                 .getReference();

                         throw new org.argouml.model.XmiReferenceException(href,

                                 e);

                     }

                     throw new XmiException(se.getMessage(), se);

                 }

             }

             modelImpl.deleteExtent(extent);

             throw new XmiException(e);

         } catch (IOException e) {

             try {

                 modelImpl.deleteExtent(extent);

             } catch (InvalidObjectException e2) {

                 // Ignore if the extent never got created or has been deleted

             }

             throw new XmiException(e);

         }

         return newElements;

     }

     private Collection<RefObject> convertAndLoadUml13(String systemId,

             RefPackage extent, XMIReader xmiReader, InputSource input)

         throws FileNotFoundException, UmlException, IOException,

             MalformedXMIException {

         LOG.info("XMI file doesn't appear to be UML 1.4 - "

                 + "attempting UML 1.3->UML 1.4 conversion");

         final String[] transformFiles = new String[] { 

             "NormalizeNSUML.xsl",

             "uml13touml14.xsl", };

         unknownElement = false;

         // InputSource xformedInput = chainedTransform(transformFiles, pIs);

         InputSource xformedInput = serialTransform(transformFiles,

                 input);

         xformedInput.setPublicId(input.getPublicId());

         return xmiReader.read(xformedInput.getByteStream(), xformedInput

                 .getSystemId(), extent);

     }

     /*

      * @see org.argouml.model.XmiReader#getXMIUUIDToObjectMap()

      */

     public Map<String, Object> getXMIUUIDToObjectMap() {

         if (resolver != null) {

             return resolver.getIdToObjectMap();

         }

         return null;

     }

     private static final String STYLE_PATH =

         "/org/argouml/model/mdr/conversions/";

     /*

      * A near clone of this code works fine outside of ArgoUML, but throws a

      * null pointer exception during the transform when run within ArgoUML I

      * think it's something to do with the class libraries being used, but I

      * can't figure out what, so I've done a simpler, less efficient stepwise

      * translation below in serialTransform

      */

     private InputSource chainedTransform(String[] styles, InputSource input)

         throws XmiException {

         SAXTransformerFactory stf =

             (SAXTransformerFactory) TransformerFactory.newInstance();

         // TODO: Reconfigure exception handling to distinguish between errors

         // that are possible due to bad input data and those that represent

         // unexpected processing errors.

         try {

             // Set up reader to be first filter in chain

             SAXParserFactory spf = SAXParserFactory.newInstance();

             SAXParser parser = spf.newSAXParser();

             XMLReader last = parser.getXMLReader();

             // Create filter for each style sheet and chain to previous

             // filter/reader

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

                 String xsltFileName = STYLE_PATH + styles[i];

                 URL xsltUrl = getClass().getResource(xsltFileName);

                 if (xsltUrl == null) {

                     throw new IOException("Error opening XSLT style sheet : "

                             + xsltFileName);

                 }

                 StreamSource xsltStreamSource =

                     new StreamSource(xsltUrl.openStream());

                 xsltStreamSource.setSystemId(xsltUrl.toExternalForm());

                 XMLFilter filter = stf.newXMLFilter(xsltStreamSource);

                 filter.setParent(last);

                 last = filter;

             }

             SAXSource transformSource = new SAXSource(last, input);

             // Create temporary file for output

             // TODO: we should be able to chain this directly to XMI reader

             File tmpFile = File.createTempFile("zargo_model_", ".xmi");

             tmpFile.deleteOnExit();

             StreamResult result =

                 new StreamResult(

                     new FileOutputStream(tmpFile));

             Transformer transformer = stf.newTransformer();

             transformer.transform(transformSource, result);

             return new InputSource(new FileInputStream(tmpFile));

         } catch (SAXException e) {

             throw new XmiException(e);

         } catch (ParserConfigurationException e) {

             throw new XmiException(e);

         } catch (IOException e) {

             throw new XmiException(e);

         } catch (TransformerConfigurationException e) {

             throw new XmiException(e);

         } catch (TransformerException e) {

             throw new XmiException(e);

         }

     }

     private InputSource serialTransform(String[] styles, InputSource input)

         throws UmlException {

         SAXSource myInput = new SAXSource(input);

         SAXTransformerFactory stf =

             (SAXTransformerFactory) TransformerFactory.newInstance();

         try {

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

                 // Set up source for style sheet

                 String xsltFileName = STYLE_PATH + styles[i];

                 if (LOG.isInfoEnabled()) {

                     LOG.info("Transforming with " + xsltFileName);

                 }

                 URL xsltUrl = getClass().getResource(xsltFileName);

                 if (xsltUrl == null) {

                     throw new UmlException("Error opening XSLT style sheet : "

                             + xsltFileName);

                 }

                 StreamSource xsltStreamSource =

                     new StreamSource(xsltUrl.openStream());

                 xsltStreamSource.setSystemId(xsltUrl.toExternalForm());

                 // Create & set up temporary output file

                 File tmpOutFile = File.createTempFile("zargo_model_", ".xmi");

                 tmpOutFile.deleteOnExit();

                 StreamResult result =

                     new StreamResult(new FileOutputStream(

                         tmpOutFile));

                 // Create transformer and do transformation

                 Transformer transformer = stf.newTransformer(xsltStreamSource);

                 transformer.transform(myInput, result);

                 LOG.info("Wrote converted XMI file - " + tmpOutFile

                         + " converted using : " + xsltFileName);

                 // Set up for next iteration

                 myInput =

                     new SAXSource(new InputSource(new FileInputStream(

                         tmpOutFile)));

                 myInput.setSystemId(tmpOutFile.toURI().toURL().toExternalForm());

             }

             return myInput.getInputSource();

         } catch (IOException e) {

             throw new UmlException(e);

         } catch (TransformerConfigurationException e) {

             throw new UmlException(e);

         } catch (TransformerException e) {

             throw new UmlException(e);

         }

     }

     private File copySource(InputSource input) throws IOException {

         byte[] buf = new byte[2048];

         int len;

         // Create & set up temporary output file

         File tmpOutFile = File.createTempFile("zargo_model_", ".xmi");

         tmpOutFile.deleteOnExit();

         FileOutputStream out = new FileOutputStream(tmpOutFile);

         // TODO: Bob says - Coding by use of side effect here.

         // Maybe this should be done in a clearer way but it fixes

         // http://argouml.tigris.org/issues/show_bug.cgi?id=4978

         // It seems that when loading an XMI that is not contained in a zip

         // file then the InputStream given as the argument to this method

         // can't be reused as it is at the end of the stream. In that case

         // systemId appears to be none-null at this stage.

         // So if systemId is not null we recreate the InputSource.

         String systemId = input.getSystemId();

         if (systemId != null) {

             input = new InputSource(new URL(systemId).openStream());

         }

         InputStream in = input.getByteStream();

         while ((len = in.read(buf)) >= 0) {

             out.write(buf, 0, len);

         }

         out.close();

         LOG.debug("Wrote copied XMI file to " + tmpOutFile);

         return tmpOutFile;

     }

     private static final String UML_13_ELEMENTS[] = 

     {

         "TaggedValue.value",

         "TaggedValue.tag",

         "ModelElement.templateParameter2",

         "ModelElement.templateParameter3",

         "Classifier.structuralFeature",

         "Classifier.parameter",

         "AssociationEnd.type",

         "Node.resident",

         "ElementResidence.implementationLocation",

         "TemplateParameter.modelElement",

         "TemplateParameter.modelElement2",

         "Constraint.constrainedElement2",

         "UseCase.include2",

         "StateMachine.subMachineState",

         "ClassifierRole.message1",

         "ClassifierRole.message2",

         "Message.message3",

         "Message.message4",

         "ElementImport.modelElement",

         "ModelElement.elementResidence",

         "ModelElement.presentation",

         "ModelElement.supplierDependency",

         "ModelElement.templateParameter2",

         "ModelElement.templateParameter3",

         "ModelElement.binding",

         "GeneralizableElement.specialization",

         "Classifier.associationEnd",

         "Classifier.participant",

         "Operation.method",

         "Stereotype.extendedElement",

         "Stereotype.requiredTag",

         "TaggedValue.stereotype",

         "Signal.context",

         "Signal.reception",

         "Signal.sendAction",

         "UseCase.include2",

         "UseCase.extend2",

         "ExtensionPoint.extend",

         "Link.stimulus",

         "Instance.attributeLink",

         "Action.stimulus",

         "Event.state",

         "Event.transition",

         "Transition.state",

         "ClassifierRole.message1",

         "ClassifierRole.message2",

         "Message.message3",

         "Message.message4",

         "Action.state1",

         "Action.state2",

         "Action.state3",

         "Instance.stimulus1",

         "Instance.stimulus2",

         "Instance.stimulus3",

     };

     public void elementFound(String name) {

         // Silently ignore anything specified by caller attempt to continue

         if (ignoredElements != null) {

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

                 if (name.equals(ignoredElements[i])) {

                     ignoredElementCount++;

                     return;

                 }

             }

         }

         if (name.startsWith("Foundation.")) {

             uml13 = true;

             return;

         }

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

             if (name.endsWith(UML_13_ELEMENTS[i])) {

                 uml13 = true;

                 return;

             }

         }

         unknownElement = true;

         if (unknownElementName == null) {

             unknownElementName = name;

         }

         LOG.error("Unknown XMI element named : " + name);

     }

     public boolean setIgnoredElements(String[] elementNames) {

         if (elementNames == null) {

             ignoredElements = new String[] {};

         } else {

             ignoredElements = elementNames;

         }

         return true;

     }

     public String[] getIgnoredElements() {

         return ignoredElements;

     }

     public int getIgnoredElementCount() {

         return ignoredElementCount;

     }

     public String getTagName() {

         return "XMI";

     }

     public void addSearchPath(String path) {

         modelImpl.addSearchPath(path);

     }

     public void removeSearchPath(String path) {

         modelImpl.removeSearchPath(path);

     }

     public List<String> getSearchPath() {

         return modelImpl.getSearchPath();

     }

     public void consumeHeader(InputStream stream) {

         try {

             int length = stream.available();

             byte[] bytes = new byte[length];

             stream.read(bytes, 0, length);

             // we presume the stream is encoded using the default char encoding

             xmiHeader = new String(bytes);

         } catch (IOException e) {

             LOG.error("Exception reading XMI file header", e);

         }

     }

     public String getHeader() {

         return xmiHeader;

     }

 }