/*
    * 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.util.Collection;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import org.apache.commons.io.FileUtils;
  import sk.baka.ikslibs.SourceEnum;
  import sk.baka.xml.gene.CoordinatorInfo;
  import sk.baka.xml.gene.ExportException;
  import sk.baka.xml.gene.ICoordinator;
  import sk.baka.xml.gene.controller.ExportController;
  import sk.baka.xml.gene.exportgraph.ExportGraph;
  import sk.baka.xml.gene.exportgraph.ExportGraphBuilder;
  import sk.baka.xml.gene.exportgraph.GraphNode;
  import sk.baka.xml.gene.exportgraph.INamespaceAcceptor;
  import sk.baka.xml.gene.exportgraph.NamespaceMapAcceptor;
  import sk.baka.xml.gene.exportgraph.TransformGraph;
  import sk.uniba.euromath.editor.EditorSite;
  import sk.uniba.euromath.editor.RendererSelector;
  import sk.uniba.euromath.gene.GeneDataProvider;
  /***
   * Represents one presentation of document.
   * @author Martin Vysny
   */
  public final class DocumentView {
  	/***
  	 * Graph containing graph nodes for all namespaces present in the document.
  	 */
  	private final ExportGraph editGraph;
  	/***
  	 * The graph builder.
  	 */
  	private final ExportGraphBuilder builder = new ExportGraphBuilder();
  	/***
  	 * The data provider instance.
  	 */
  	private final GeneDataProvider provider;
  	/***
  	 * The document instance.
  	 */
  	private final XMLAccess doc;
  	/***
  	 * Constructs the instance of object.
  	 * @param doc document to view
  	 * @param selector selects preferred renderers. May be <code>null</code> -
  	 * in such case no renderers are preferred.
  	 * @param site the transformed data receiver.
  	 */
  	public DocumentView(final XMLAccess doc, final RendererSelector selector,
  			final EditorSite site) {
  		super();
  		this.doc = doc;
  		provider = new GeneDataProvider(
  				selector == null ? new RendererSelector() : selector, doc, site);
  		final INamespaceAcceptor sourceNamespaces = ExportGraphBuilder
  				.getDocumentNamespaces(doc.getSplittedDoc());
  		editGraph = builder.newGraph(sourceNamespaces, provider
  				.getCoordinatorInfo(), true);
  	}
  	/***
  	 * The transformation graph, set in {@link #initialize(TransformGraph)}.
  	 */
  	private TransformGraph transformGraph = null;
  	/***
  	 * Initializes the view, performing the transformation. If an exception is
  	 * thrown during export, view is automatically closed and it must not be
  	 * further used.
  	 * @param graph transform graph.
  	 * @throws ExportException if error occurs during the transformation.
  	 * @throws IOException if i/o error occurs during the transformation.
  	 */
  	public void initialize(final TransformGraph graph) throws ExportException,
  			IOException {
  		checkNotClosed();
  		if (isInitialized())
  			throw new IllegalStateException("View is already initialized."); //$NON-NLS-1$
  		// check if all namespaces are present.
  		final Set<String> namespaces = new HashSet<String>(editGraph
  				.getAllNodesAsMap().keySet());
  		namespaces.removeAll(graph.allNamespaces());
  		if (!namespaces.isEmpty())
  			throw new ExportException(
  					"Missing transformers for namespaces: " + namespaces); //$NON-NLS-1$
  		transformGraph = new TransformGraph(graph);
  		boolean initializedProperly = false;
 		try {
 			export();
 			initializedProperly = true;
 		} finally {
 			if (!initializedProperly)
 				close();
 		}
 	}
 	/***
 	 * Constructs graph for given set of namespaces.
 	 * @param namespaces namespaces
 	 * @return graph containing export nodes for all namespaces.
 	 */
 	public ExportGraph getGraphFor(
 			final Collection< ? extends String> namespaces) {
 		checkNotClosed();
 		// create new graph nodes only for new namespaces
 		final Map<String, GraphNode> allNodes = editGraph.getAllNodesAsMap();
 		final Map<String, EnumSet<SourceEnum>> newNamespaces = new HashMap<String, EnumSet<SourceEnum>>();
 		for (final String ns : namespaces) {
 			if (!allNodes.containsKey(ns))
 				newNamespaces.put(ns, EnumSet.of(SourceEnum.DOM));
 		}
 		// construct graph for these new namespaces.
 		final CoordinatorInfo info = provider.getCoordinatorInfo();
 		final ExportGraph result = builder.newGraph(new NamespaceMapAcceptor(
 				newNamespaces), info, true);
 		// add known graph nodes from the editGraph
 		for (final String ns : namespaces) {
 			final GraphNode node = allNodes.get(ns);
 			final boolean isRegular = editGraph.isRegular(node);
 			if (node != null)
 				result.addNode(node, isRegular, false);
 		}
 		return result;
 	}
 	/***
 	 * Returns the current exporter graph. The graph must not be modified!
 	 * @return the exporter graph.
 	 */
 	public ExportGraph getEditGraph() {
 		checkNotClosed();
 		return editGraph;
 	}
 	/***
 	 * Registers new transformers, ignoring transformers already registered.
 	 * @param graph graph to register.
 	 */
 	public void addTransformers(final TransformGraph graph) {
 		checkNotClosed();
 		transformGraph.addAll(graph, false);
 	}
 	/***
 	 * Exports the document.
 	 * @throws ExportException if shit happens.
 	 * @throws IOException if i/o error occurs.
 	 */
 	void export() throws ExportException, IOException {
 		checkInitialized();
 		checkNotClosed();
 		final ICoordinator editorDataReceiver = provider.getCoordinator();
 		final ExportController controller = new ExportController(FileUtils
 				.toFile(doc.getDocumentURL()), doc.getSplittedDoc(),
 				transformGraph, editorDataReceiver);
 		controller.export(null);
 	}
 	/***
 	 * Checks if this view is initialized. Unintialized views are not subjects
 	 * for GENE transformation.
 	 * @return <code>true</code> if this view is initialized,
 	 * <code>false</code> otherwise.
 	 */
 	public boolean isInitialized() {
 		return transformGraph != null;
 	}
 	/***
 	 * Checks if this view is initialized. If not, exception is thrown.
 	 */
 	private void checkInitialized() {
 		if (!isInitialized())
 			throw new IllegalStateException("Not initialized."); //$NON-NLS-1$
 	}
 	/***
 	 * The editor data provider coordinator info.
 	 * @return info.
 	 */
 	public CoordinatorInfo getCoordinatorInfo() {
 		checkNotClosed();
 		return provider.getCoordinatorInfo();
 	}
 	/***
 	 * Closes and invalidates this view. Closing an already closed view has no
 	 * effect.
 	 */
 	void close() {
 		if (isClosed())
 			return;
 		provider.getCoordinator().dispose();
 		closed = true;
 	}
 	/***
 	 * <code>true</code> if this view is closed.
 	 */
 	private boolean closed = false;
 	/***
 	 * Returns <code>true</code> if this view is closed. If the view is
 	 * closed, it becomes invalid and must not be used.
 	 * @return <code>true</code> if this view is closed
 	 */
 	public boolean isClosed() {
 		return closed;
 	}
 	/***
 	 * Checks if this view is closed. If yes then exception is thrown.
 	 */
 	private void checkNotClosed() {
 		if (isClosed())
 			throw new IllegalStateException("The view is closed."); //$NON-NLS-1$
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#finalize()
 	 */
 	@Override
 	protected void finalize() throws Throwable {
 		close();
 		super.finalize();
 	}
 }