/*
    * Created on Apr 8, 2005. 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.editor.wizards.document;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.NoSuchElementException;
  
  import javax.xml.namespace.QName;
  
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.jface.window.Window;
  import org.eclipse.swt.widgets.Shell;
  import org.w3c.dom.Element;
  
  import sk.baka.ikslibs.DOMUtils;
  import sk.baka.ikslibs.ptr.DOMPoint;
  import sk.baka.ikslibs.ptr.DomPointer;
  import sk.uniba.euromath.document.NamespaceManager;
  import sk.uniba.euromath.document.XMLAccess;
  import sk.uniba.euromath.document.schema.ElementLoc;
  import sk.uniba.euromath.document.schema.INameList;
  import sk.uniba.euromath.document.schema.InsertList;
  import sk.uniba.euromath.document.schema.NameListCustom;
  import sk.uniba.euromath.document.schema.NewElementRule;
  import sk.uniba.euromath.document.schema.plug.INewElementRuleP;
  import sk.uniba.euromath.editor.lang.Messages;
  import sk.uniba.euromath.editor.wizards.IMultiWizardProvider;
  import sk.uniba.euromath.editor.wizards.IWizard;
  import sk.uniba.euromath.editor.wizards.MultiWizard;
  import sk.uniba.euromath.editor.wizards.WizardDialog;
  /***
   * A wizard that queries contents of new element(s) that should be inserted at
   * given location. When wizard finishes, these elements are returned as an array
   * of insertpoints and elements. Wizard does not insert those elements itself,
   * you may use
   * {@link sk.uniba.euromath.editor.wizards.document.ElementLoc#insert()} method
   * to do that.
   * @author Martin Vysny
   */
  public class InsertElementWizardProvider implements IMultiWizardProvider {
  	/***
  	 * Helper method that executes the insert element wizard.
  	 * @param parent parent of the wizard dialog. Can be <code>null</code> but
  	 * this is not recommended.
  	 * @param place where to insert new elements.
  	 * @param xmlAccess the document instance.
  	 * @param nsManager the namespace manager instance.
  	 * @param preselected this element was requested by user to appear as first
  	 * element. May be <code>null</code>.
  	 * @return new elements and their locations, or <code>null</code> if user
  	 * cancelled the wizard or no elements are insertable.
  	 */
  	public static sk.uniba.euromath.editor.wizards.document.ElementLoc execute(
  			Shell parent, XMLAccess xmlAccess, DomPointer place,
  			NamespaceManager nsManager, QName preselected) {
  		if (!place.parent.isSameNode(place.parentElement)) {
  			throw new IllegalArgumentException(
  					"Cannot insert elements into an entity.");//$NON-NLS-1$
  		}
  		// compute base insertlist
  		final List<InsertList> insertLists = xmlAccess.getSchema()
  				.getElementRule(place.parentElement).getInsertableElements(
  						place.ip);
  		if (insertLists.size() == 0) {
  			MessageDialog.openInformation(parent, Messages
  					.getString("INFORMATION"), //$NON-NLS-1$
  					Messages.getString("NO_INSERTABLE_ELEMENTS")); //$NON-NLS-1$
  			return null;
  		}
  		// search for an insertlist that may be preselected
  		filterInsertLists(preselected, insertLists, place.ip);
  		// create the provider instance and open the wizard
  		final InsertElementWizardProvider provider = new InsertElementWizardProvider(
  				xmlAccess, insertLists, place.parentElement, nsManager);
  		final MultiWizard w = new MultiWizard(provider);
  		final WizardDialog dlg = new WizardDialog(parent, w, Messages
  				.getString("INSERT_NEW_ELEMENTS"));//$NON-NLS-1$
  		if (dlg.open() != Window.OK)
  			return null;
  		// build result object
  		final List<Element> roots = provider.getElements();
  		final List<DOMPoint> ips = new ArrayList<DOMPoint>(roots.size());
  		final InsertList selected = provider.getInsertList();
  		for (ElementLoc loc : selected) {
  			ips.add(loc.ip);
  		}
  		final sk.uniba.euromath.editor.wizards.document.ElementLoc result = new sk.uniba.euromath.editor.wizards.document.ElementLoc(
 				xmlAccess, place.parentElement, roots, ips);
 		return result;
 	}
 	/***
 	 * Filters out all insertlists whose elementloc does not accept the
 	 * 'preselected' qname. If no such insertlist exists then the list is kept
 	 * intact.
 	 * @param preselected the preselected qname.
 	 * @param insertLists list of insertlists to filter.
 	 * @param ip insertpoint where the element will be inserted.
 	 * @return <code>true</code> if some insertlists were filtered out,
 	 * <code>false</code> otherwise.
 	 */
 	private static boolean filterInsertLists(final QName preselected,
 			final List<InsertList> insertLists, final DOMPoint ip) {
 		if (preselected != null) {
 			// try to find an insertlist containing the 'preselected' rule.
 			boolean isPreselected = false;
 			for (final InsertList list : insertLists) {
 				if (list.canCreate(preselected, ip)) {
 					isPreselected = true;
 					break;
 				}
 			}
 			if (!isPreselected) {
 				// no insertlist can be preselected. leave the list intact.
 				return false;
 			}
 			// filter out the preselected insertlists.
 			for (final Iterator<InsertList> i = insertLists.iterator(); i
 					.hasNext();) {
 				final InsertList il = i.next();
 				final ElementLoc loc = il.getFirstAt(ip, preselected);
 				if (loc == null) {
 					i.remove();
 					continue;
 				}
 				// create namelist with only one rule.
 				final NewElementRule rule = loc.nameList.getRule(preselected,
 						true);
 				assert rule != null;
 				final Map<QName, NewElementRule> rules = Collections
 						.singletonMap(preselected, rule);
 				loc.nameList = new NameListCustom<NewElementRule, INewElementRuleP>(
 						loc.nameList.getNamespaceUri(), rules);
 			}
 			return true;
 		}
 		return false;
 	}
 	/***
 	 * Constructor.
 	 * @param xmlAccess instance of the document.
 	 * @param insertLists list of possible insertlists.
 	 * @param parent the parent element - here all elements will be created.
 	 * @param nsManager the namespace manager instance.
 	 */
 	public InsertElementWizardProvider(XMLAccess xmlAccess,
 			List<InsertList> insertLists, Element parent,
 			NamespaceManager nsManager) {
 		super();
 		if (insertLists.size() == 0)
 			throw new IllegalArgumentException("No insertlists"); //$NON-NLS-1$
 		this.xmlAccess = xmlAccess;
 		this.startNsManager = nsManager;
 		// create first wizard - the insert list chooser.
 		InsertListChooserWizard first = new InsertListChooserWizard(xmlAccess,
 				insertLists, xmlAccess.getNsManager(), DOMUtils
 						.printQName(parent), null, Messages
 						.getString("INSERT_NEW_ELEMENTS")); //$NON-NLS-1$
 		wizards.add(first);
 	}
 	/***
 	 * The document instance.
 	 */
 	protected final XMLAccess xmlAccess;
 	/***
 	 * Wizards that has been activated. Warning: may contain <code>null</code>s
 	 * in order to be consistent with <code>rules</code> and
 	 * <code>roots</code> lists.
 	 */
 	protected final List<IWizard> wizards = new ArrayList<IWizard>();
 	/***
 	 * This manager was given to the constructor.
 	 */
 	protected final NamespaceManager startNsManager;
 	/***
 	 * We are being executed in this multiwizard.
 	 */
 	protected MultiWizard parent;
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#performFinish()
 	 */
 	public void performFinish() {
 		// all data is already available, nothing needs to be done
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#performCancel()
 	 */
 	public void performCancel() {
 		// nothing needs to be done.
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#dispose()
 	 */
 	public void dispose() {
 		wizards.clear();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#setWizard(sk.uniba.euromath.editor.wizards.MultiWizard)
 	 */
 	public void setWizard(MultiWizard wizard) {
 		parent = wizard;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#current()
 	 */
 	public IWizard current() {
 		IWizard result = wizards.get(wizards.size() - 1);
 		assert result != null;
 		return result;
 	}
 	/***
 	 * Contains rules for elements. Last rule is the rule being currently filled
 	 * in. i-th rule fills contents of <code>roots.get(i)</code> using
 	 * <code>wizards.get(i+1)</code> wizard. Note that this wizard may be
 	 * <code>null</code> if element does not require any contents.
 	 */
 	protected final List<NewElementRule> rules = new ArrayList<NewElementRule>();
 	/***
 	 * 'Root' elements - elements that'll be inserted into given parent element.
 	 */
 	protected List<Element> roots = null;
 	/***
 	 * 'Root' elements - elements that'll be inserted into given parent element.
 	 * If wizard shows its first page then <code>null</code> is returned.
 	 * @return list of root elements or <code>null</code> if wizard shows its
 	 * first page.
 	 */
 	public List<Element> getElements() {
 		if (roots == null)
 			return null;
 		return Collections.unmodifiableList(roots);
 	}
 	/***
 	 * Selected insert list.
 	 * @return selected insert list. <code>null</code> if this provider is
 	 * showing first wizard.
 	 */
 	public InsertList getInsertList() {
 		return selected;
 	}
 	/***
 	 * Previous namespace manager. If this provider is showing first wizard,
 	 * then construct-time namespace manager is returned.
 	 * @return current namespace manager. Queried from the last shown wizard
 	 * (i.e. wizard before the currently active wizard).
 	 */
 	public NamespaceManager getPrevNsManager() {
 		if (wizards.size() == 1)
 			return startNsManager;
 		for (int i = wizards.size() - 2; i > 0; i--) {
 			MultiWizard w = (MultiWizard) wizards.get(i);
 			if (w == null)
 				continue;
 			FillNewElementWizardProvider p = (FillNewElementWizardProvider) w
 					.getProvider();
 			return p.newNsManager();
 		}
 		InsertListChooserWizard first = (InsertListChooserWizard) wizards
 				.get(0);
 		return first.newNsManager();
 	}
 	/***
 	 * Current namespace manager.
 	 * @return current namespace manager. Queried from the currently active
 	 * wizard.
 	 */
 	public NamespaceManager newNsManager() {
 		if (wizards.size() == 1) {
 			InsertListChooserWizard first = (InsertListChooserWizard) wizards
 					.get(0);
 			return first.newNsManager();
 		}
 		MultiWizard w = (MultiWizard) wizards.get(wizards.size() - 1);
 		FillNewElementWizardProvider p = (FillNewElementWizardProvider) w
 				.getProvider();
 		return p.newNsManager();
 	}
 	/***
 	 * Selected insert list. <code>null</code> if this provider is showing
 	 * first wizard.
 	 */
 	protected InsertList selected;
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#next()
 	 */
 	public IWizard next() {
 		assert wizards.size() > 0;
 		if (wizards.size() == 1) {
 			InsertListChooserWizard first = (InsertListChooserWizard) wizards
 					.get(0);
 			selected = first.ilcPage.getWidget().getInsertList();
 			// make a list of 'root' elements
 			List<QName> rootsNames = first.getNames();
 			roots = new ArrayList<Element>(rootsNames.size());
 			for (QName rootName : rootsNames) {
 				Element e = xmlAccess.getDocument().createElementNS(
 						rootName.getNamespaceURI(),
                         DOMUtils.printQName(rootName));
 				roots.add(e);
 			}
 		}
 		// get next wizard
 		IWizard next = findNextWizard();
 		if (next == null)
 			throw new NoSuchElementException();
 		return next;
 	}
 	/***
 	 * Finds next wizard for querying contents of an element. Returns
 	 * <code>null</code> if no wizard is needed. All used rules are placed
 	 * into the <code>rules</code> array to mark progress done. The
 	 * <code>wizards</code> array is filled with <code>null</code>s if
 	 * required, to remain consistent with the <code>rules</code> array.
 	 * @return a wizard instance, or <code>null</code> if no wizard is needed.
 	 */
 	protected IWizard findNextWizard() {
 		assert roots != null;
 		if (rules.size() == roots.size())
 			return null;
 		assert wizards.size() == rules.size() + 1;
 		// for each element its contents must be filled. Find first element that
 		// actually requires some content.
 		for (int i = rules.size(); i < roots.size(); i++) {
 			Element root = roots.get(i);
 			INameList<NewElementRule> nameList = selected.get(i).nameList;
 			NewElementRule rule = nameList.getRule(DOMUtils.getQName(root),
 					true);
 			// try to create provider for creating element's contents
 			FillNewElementWizardProvider p = new FillNewElementWizardProvider(
 					root, rule, xmlAccess, newNsManager(), null);
 			MultiWizard wizard;
 			if (p.current() == null) {
 				// no needed contents. set wizard to null
 				wizard = null;
 			} else {
 				wizard = new MultiWizard(p);
 			}
 			wizards.add(wizard);
 			rules.add(rule);
 			if (wizard != null)
 				return wizard;
 		}
 		// no wizard found, return null and cleanup last added null wizards
 		for (int i = wizards.size() - 1; i > 0; i--) {
 			if (wizards.get(i) != null)
 				break;
 			wizards.remove(i);
 			rules.remove(i - 1);
 		}
 		return null;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#previous()
 	 */
 	public IWizard previous() {
 		if (!hasPrevious())
 			throw new NoSuchElementException();
 		// find last non-null wizard, except the very last one.
 		int lastWizard = wizards.size() - 1;
 		wizards.set(lastWizard, null);
 		for (int i = lastWizard; i > 0; i--) {
 			if (wizards.get(i) != null)
 				break;
 			wizards.remove(i);
 			rules.remove(i - 1);
 		}
 		// we got the wizard.
 		assert wizards.size() != 0;
 		if (wizards.size() == 1) {
 			selected = null;
 			roots = null;
 		}
 		return wizards.get(wizards.size() - 1);
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#hasNext()
 	 */
 	public boolean hasNext() {
 		// a simple and uneffective code
 		try {
 			next();
 			previous();
 			return true;
 		} catch (NoSuchElementException ex) {
 			return false;
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#hasPrevious()
 	 */
 	public boolean hasPrevious() {
 		return wizards.size() > 1;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#getName()
 	 */
 	public String getName() {
 		return null;
 	}
 }