/*
    * Copyright 1999-2006 Faculty of Mathematics, Physics and Informatics, Comenius
    * University, Bratislava. This file is protected by the Mozilla Public License
    * version 1.1 (the "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at
    * http://euromath2.sourceforge.net/license.html Unless required by applicable
    * law or agreed to in writing, software distributed under the License is
    * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    * KIND, either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.document;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.net.MalformedURLException;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.WeakHashMap;
  import org.apache.commons.lang.StringUtils;
  import org.w3c.dom.CDATASection;
  import org.w3c.dom.CharacterData;
  import org.w3c.dom.Document;
  import org.w3c.dom.DocumentFragment;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  import org.w3c.dom.Text;
  import org.w3c.dom.ls.DOMImplementationLS;
  import org.w3c.dom.ls.LSOutput;
  import org.w3c.dom.ls.LSSerializer;
  import org.w3c.dom.traversal.DocumentTraversal;
  import org.w3c.dom.traversal.NodeFilter;
  import org.w3c.dom.traversal.NodeIterator;
  import sk.baka.ikslibs.UndoManager;
  import sk.baka.ikslibs.ids.FailEnum;
  import sk.baka.ikslibs.ids.IDManager;
  import sk.baka.ikslibs.modify.DOMMutils;
  import sk.baka.ikslibs.ptr.DomPointer;
  import sk.baka.ikslibs.ref.EntityManager;
  import sk.baka.ikslibs.splitted.ISplittedListener;
  import sk.baka.ikslibs.splitted.SplittedDocChangeCollector;
  import sk.baka.ikslibs.splitted.SplittedDocHolder;
  import sk.baka.xml.gene.ExportUtils;
  import sk.baka.xml.schematic.DocumentSchema;
  import sk.baka.xml.schematic.pluginterface.SchemaException;
  import sk.uniba.euromath.document.schema.SchematicUtils;
  import sk.uniba.euromath.tools.URLDir;
  /***
   * Provides access to the document. Accessible from out of document package.
   * Class is not intended to be instantiated by clients.
   * @author Martin Vysny
   */
  public final class XMLAccess {
  	/***
  	 * Enclosed document.
  	 */
  	private final Document doc;
  	/***
  	 * Manages ID for this document.
  	 */
  	private final IDManager idMan;
  	/***
  	 * Manages namespaces and prefixes for this document.
  	 */
  	private final NamespaceManager nsManager;
  	/***
  	 * The document schema instance.
  	 */
  	private final DocumentSchema schema;
  	/***
  	 * The entity manager.
  	 */
  	private final EntityManager entityManager;
  	/***
  	 * Splitted document.
  	 */
  	private final SplittedDocHolder splittedDoc;
  	/***
  	 * Collects changes in the splitted document.
  	 */
  	private final SplittedDocChangeCollector splittedChanges;
  	/***
  	 * Returns object that collects changes in the splitted document.
  	 * @return object that collects changes in the splitted document, never
  	 * <code>null</code>.
  	 */
  	public final SplittedDocChangeCollector getSplittedChanges() {
  		return splittedChanges;
  	}
  	/***
  	 * The name of the document file, including the extension, without the path
  	 * specifier.
  	 */
  	public final String fileName;
  	/***
  	 * The name of the document file, including the extension and full path. URI
 	 * address.
 	 */
 	public final URL fileURL;
 	/***
 	 * URL pointing to the directory where the document is located.
 	 */
 	private final URLDir root;
 	/***
 	 * Table of views, that manages the transformations over the document. Value
 	 * is ignored.
 	 */
 	final Map<DocumentView, Object> views = new WeakHashMap<DocumentView, Object>();
 	/***
 	 * The document modifier instance.
 	 */
 	private final DocumentModifier docModifier;
 	/***
 	 * DocumentModifyHelper instace for clients.
 	 */
 	private final DocumentModifyHelper docModifyHelper;
 	/***
 	 * The document listeners manager instance.
 	 */
 	private final DocumentListeners docListeners;
 	/***
 	 * The undo manager.
 	 */
 	private final UndoManager undoManager;
 	/***
 	 * Constructs a new instance of XMLAccess. For each opened document there is
 	 * exactly one instance. Produced via the {@link DocumentFactory} factory.
 	 * @param doc Document that this object will work with.
 	 * @param textEntities all entities encountered during the parse.
 	 * @param root URL pointing to the directory where the document is located.
 	 * @param fileName the name of the document file, including the extension,
 	 * without the path specifier.
 	 * @throws DocumentException when error occurs during document processing.
 	 */
 	XMLAccess(Document doc, Map<String, String> textEntities, URLDir root,
 			String fileName) throws DocumentException {
 		super();
 		this.doc = doc;
 		this.root = root;
 		this.fileName = fileName;
 		try {
 			this.fileURL = root.resolve(fileName);
 		} catch (URISyntaxException ex) {
 			throw new DocumentException(ex);
 		} catch (MalformedURLException ex) {
 			throw new DocumentException(ex);
 		}
 		idMan = new IDManager(doc, ExportUtils.GENE_ID_ATTRIBUTE_QNAME,
 				FailEnum.FAIL_WHEN_ID_EXISTS);
 		idMan.observe(doc);
 		entityManager = new EntityManager(doc);
 		entityManager.createEntities(textEntities, true);
 		nsManager = new NamespaceManager(doc);
 		nsManager.observe(doc);
 		removeWhitespaces();
 		schema = new DocumentSchema(doc, SchematicUtils.getPool());
 		splittedChanges = new SplittedDocChangeCollector();
 		splittedDoc = SplittedDocHolder.newFromDocument(doc,
 				SplittedDocHolder.PI_GENEREF_TARGET, Collections
 						.singletonList((ISplittedListener) splittedChanges));
 		docListeners = new DocumentListeners(this);
 		undoManager = new UndoManager();
 		docModifier = new DocumentModifier(this, views.keySet(), docListeners);
 		docModifyHelper = new DocumentModifyHelper(this);
 		undoManager.observe(doc);
 	}
 	/***
 	 * Whitespace-normalizes all text nodes.
 	 */
 	private void removeWhitespaces() {
 		if (doc.getDocumentElement() != null) {
 			// remove all whitespaced text nodes.
 			NodeIterator iterator = ((DocumentTraversal) doc)
 					.createNodeIterator(doc.getDocumentElement(),
 							NodeFilter.SHOW_TEXT, null, false);
 			Node actNode = iterator.nextNode();
 			while (actNode != null) {
 				if (isNodeContentEmpty(actNode)) {
 					// the node has empty or whitespace-only content. remove it.
 					iterator.previousNode();
 					actNode.getParentNode().removeChild(actNode);
 				} else {
 					DOMMutils.normalizeWhitespaces(actNode);
 				}
 				// get next element
 				actNode = iterator.nextNode();
 			}
 			iterator.detach();
 		}
 	}
 	/***
 	 * Returns true if node has empty text contents (the <code>Text</code> or
 	 * <code>CDATASection</code> node), or contains whitespaces only (
 	 * <code>Text</code>).
 	 * @param node node to check.
 	 * @return true if <code>node.getData()</code> returns <code>null</code>
 	 * or empty string.
 	 */
 	private boolean isNodeContentEmpty(Node node) {
 		if (!(node instanceof Text) && !(node instanceof CDATASection))
 			return false;
 		final String data = ((CharacterData) node).getData();
 		if (StringUtils.isEmpty(data))
 			return true;
 		if (node instanceof CDATASection)
 			return false;
 		// test for whitespaces
 		for (int i = 0; i < data.length(); i++) {
 			char c = data.charAt(i);
 			if (!Character.isWhitespace(c))
 				return false;
 		}
 		return true;
 	}
 	/***
 	 * Checks the node if it is from our document.
 	 * @param node node to check.
 	 * @throws IllegalArgumentException if node is not from bound document
 	 */
 	public void checkNode(Node node) {
 		if (!isOurNode(node))
 			throw new IllegalArgumentException("Node is not from our document."); //$NON-NLS-1$
 	}
 	/***
 	 * Checks the pointer if it points into our document.
 	 * @param ptr pointer to check.
 	 * @throws IllegalArgumentException if pointer is not from bound document
 	 */
 	public void checkPtr(DomPointer ptr) {
 		if ((ptr.getDocument() == null) || !isOurNode(ptr.getDocument()))
 			throw new IllegalArgumentException(
 					"Pointer is not from our document."); //$NON-NLS-1$
 	}
 	/***
 	 * Checks the node if it is from our document.
 	 * @param node node to check.
 	 * @return true if the node was created by this document, false otherwise.
 	 */
 	public boolean isOurNode(Node node) {
 		if (node.getNodeType() == Node.DOCUMENT_NODE)
 			return node == doc;
 		return (node.getOwnerDocument() == doc);
 	}
 	/***
 	 * Returns <code>IDManager</code> instance for this document.
 	 * @return An <code>IDManager</code> for this document.
 	 */
 	public IDManager getIDManager() {
 		return idMan;
 	}
 	/***
 	 * Returns <code>DomToSplitted</code> instance for this document.
 	 * @return An <code>DomToSplitted</code> for this document.
 	 */
 	public SplittedDocHolder getSplittedDoc() {
 		return splittedDoc;
 	}
 	/***
 	 * Returns the nametree from the original document, that the
 	 * <code>emp:mark</code> element points to.
 	 * @param mark the mark element, or <code>null</code>.
 	 * @return the nametree represented as a document fragment. This fragment
 	 * must not be modified. If <code>null</code> is provided then root
 	 * fragment is returned.
 	 * @throws IllegalArgumentException if the element is not
 	 * <code>emp:mark</code> or the ID does not exist.
 	 */
 	public DocumentFragment getSource(Node mark) {
 		if (mark == null)
 			return splittedDoc.getRootFragment();
 		return splittedDoc.getDomFragment(splittedDoc.getRef(mark));
 	}
 	/***
 	 * Opens new view on the document. The view must be initialized.
 	 * @param view the view to register.
 	 */
 	public void openView(final DocumentView view) {
 		if (!view.isInitialized())
 			throw new IllegalArgumentException("The view is not initialized");//$NON-NLS-1$
 		if (view.isClosed())
 			throw new IllegalArgumentException("The view is closed");//$NON-NLS-1$
 		views.put(view, null);
 	}
 	/***
 	 * Unregisters the view. The view is no more used by the transformation
 	 * engine and is subject to garbage collection.
 	 * @param view the document view to close. Fails if the view was not opened
 	 * for this document.
 	 */
 	public void closeView(final DocumentView view) {
 		if (views.remove(view) == null)
 			throw new IllegalArgumentException("Illegal view."); //$NON-NLS-1$
 		view.close();
 	}
 	/***
 	 * Returns instance of the undo manager for this document.
 	 * @return the undo manager.
 	 */
 	public UndoManager getUndoManager() {
 		return undoManager;
 	}
 	/***
 	 * Returns all namespaces present in the document.
 	 * @return set of namespaces. <code>null</code> namespace (nor empty
 	 * namespace) does not occur in the returned set. Deprecated, use namespace
 	 * manager methods.
 	 */
 	@Deprecated
 	public Set<String> getAllNamespaces() {
 		final Set<String> result = new HashSet<String>(getNsManager()
 				.getAllNamespaces());
 		result.remove(""); //$NON-NLS-1$
 		return result;
 	}
 	/***
 	 * <p>
 	 * Access to the XML document. This document has this special feature: Every
 	 * element has {@link ExportUtils#GENE_ID_ATTRIBUTE_QNAME} attribute,
 	 * denoting ID of that element.
 	 * </p>
 	 * @return the DOM document.
 	 */
 	public Document getDocument() {
 		return doc;
 	}
 	/***
 	 * Validates this document.
 	 * @throws SchemaException if something goes wrong in the process of
 	 * validation.
 	 */
 	public void validate() throws SchemaException {
 		getSchema().validate();
 	}
 	/***
 	 * Returns document modifier, which is used to transparently modify the
 	 * document.
 	 * @return the document modifier instance.
 	 */
 	public DocumentModifier getModifier() {
 		return docModifier;
 	}
 	/***
 	 * Loads global schemas for all namespaces, present in the document, for
 	 * which no local schema was loaded. It must be called before the Schema
 	 * interface is used, to ensure that all schemata are properly loaded.
 	 * @throws SchemaException if error happens during loading of schemas.
 	 * @throws IOException if i/o error occurs
 	 */
 	public void loadGlobalSchemas() throws SchemaException, IOException {
 		final Set<String> allNamespaces = new HashSet<String>(getNsManager()
 				.getAllNamespaces());
 		allNamespaces.remove(""); //$NON-NLS-1$
 		getSchema().getRefs().loadSchemas(allNamespaces);
 	}
 	/***
 	 * Document's content modifier helper. For chosen operation returns all
 	 * possibilities of document modification, that will result in valid
 	 * document.
 	 * @return the document schema instance.
 	 */
 	public DocumentSchema getSchema() {
 		return schema;
 	}
 	/***
 	 * Returns namespace manager for this document.
 	 * @return namespace manager for this document.
 	 */
 	public NamespaceManager getNsManager() {
 		return nsManager;
 	}
 	/***
 	 * Returns entity manager for this document.
 	 * @return entity manager for this document.
 	 */
 	public sk.baka.ikslibs.ref.EntityManager getEntityManager() {
 		return entityManager;
 	}
 	/***
 	 * Serializes in-memory document to specified output stream.
 	 * @param out stream, where to store saved xml.
 	 * @param encoding the encoding. If <code>null</code>, then UTF-8 is
 	 * used.
 	 * @param prettyFormatting if output xml will be pretty-formatted - readable
 	 * by user. Warning: this adds some whitespaces to xml, thus modifying
 	 * result xml. User must be sure that these whitespaces are discardable.
 	 */
 	public void saveDocument(OutputStream out, String encoding,
 			boolean prettyFormatting) {
 		final DOMImplementationLS impl = (DOMImplementationLS) doc
 				.getImplementation();
 		final LSSerializer serializer = impl.createLSSerializer();
 		final LSOutput output = impl.createLSOutput();
 		output.setEncoding(encoding == null ? "UTF-8" : encoding); //$NON-NLS-1$
 		output.setByteStream(out);
 		// duplicates document and prepares it for output.
 		final Document serializeDoc = (Document) doc.cloneNode(true);
 		// removes all emp:ids
 		final NodeIterator i = ((DocumentTraversal) serializeDoc)
 				.createNodeIterator(serializeDoc.getDocumentElement(),
 						NodeFilter.SHOW_ELEMENT, null, false);
 		Element actNode = (Element) i.nextNode();
 		while (actNode != null) {
 			// remove gene:id attribute
 			actNode.removeAttributeNS(ExportUtils.GENE_ID_ATTRIBUTE_QNAME
 					.getNamespaceURI(), ExportUtils.GENE_ID_ATTRIBUTE_QNAME
 					.getLocalPart());
 			// get next element
 			actNode = (Element) i.nextNode();
 		}
 		i.detach();
 		// create namespace nodes
 		getNsManager().createXmlnsAttributes(serializeDoc.getDocumentElement());
 		// serialize to stream
 		serializer.write(serializeDoc, output);
 	}
 	/***
 	 * Returns encoding, in which the document is serialized. May return
 	 * <code>null</code> if the encoding was not specified.
 	 * @return the encoding.
 	 */
 	public String getEncoding() {
 		return doc.getXmlEncoding();
 	}
 	/***
 	 * Serializes transformed document "as-is", no emp:id removal is performed.
 	 * Used only for debug. Serializes only root fragment.
 	 * @param out the outputstream.
 	 */
 	public void serialize(OutputStream out) {
 		final DOMImplementationLS impl = (DOMImplementationLS) doc
 				.getImplementation();
 		final LSSerializer serializer = impl.createLSSerializer();
 		final LSOutput output = impl.createLSOutput();
 		output.setEncoding("UTF-8"); //$NON-NLS-1$
 		output.setByteStream(out);
 		// serialize to stream
 		serializer.write(getSplittedDoc().getRootFragment(), output);
 	}
 	/***
 	 * Returns document listeners manager for this document.
 	 * @return document listeners manager for this document.
 	 */
 	public DocumentListeners getListeners() {
 		return docListeners;
 	}
 	/***
 	 * Returns full URI address of the document.
 	 * @return document location.
 	 */
 	public URL getDocumentURL() {
 		return fileURL;
 	}
 	/***
 	 * Returns the name of the document file, including the extension, without
 	 * the path specifier.
 	 * @return the file name without the path.
 	 */
 	public String getFileName() {
 		return fileName;
 	}
 	/***
 	 * Returns URL pointing to the directory where the document is located.
 	 * @return location of the XML file.
 	 */
 	public URLDir getRoot() {
 		return root;
 	}
 	/***
 	 * Returns clients Helper for modifying.
 	 * @return DocumentModifyHelper instance
 	 */
 	public DocumentModifyHelper getDocumentModifyHelper() {
 		return docModifyHelper;
 	}
 }