/*
    * Created on Mar 15, 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;
  import java.util.ArrayList;
  import java.util.IdentityHashMap;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.NoSuchElementException;
  import org.eclipse.core.runtime.IStatus;
  import org.eclipse.swt.graphics.RGB;
  import sk.uniba.euromath.EuroMath;
  /***
   * <p>
   * Multi-wizard switcher. Each wizard it encapsulates must comply to these
   * rules:
   * </p>
   * <ul>
   * <li><code>getPreviousPage(getNextPage(page)) == page</code> for any page
   * the wizard ever returns, except the last page,</li>
   * <li><code>getPreviousPage(getStartingPage()) == null</code></li>
   * <li><code>getStartingPage()</code> must consistently return same instance
   * of page object</li>
   * <li><code>createPageControls()</code> is not called.</li>
   * <li>it must be able to be cancelled anytime</li>
   * </ul>
   * <p>
   * This wizard guarantees that
   * </p>
   * <ul>
   * <li><code>getNextPage()</code> and <code>getPreviousPage()</code> of
   * enclosed wizard will be called only when <code>this.getNextPage()</code>
   * (or <code>this.getPreviousPage()</code> respectively) is called.</li>
   * <li><code>performFinish()</code> and <code>performCancel()</code> are
   * called only when this wizard's <code>performFinish()</code> (or
   * <code>performCancel()</code> respectively) is called. Thus, if next wizard
   * (in its creation time) depends on results of previous wizard, you can't
   * compute those results in the <code>performFinish()</code> method.</li>
   * </ul>
   * <p>
   * This wizard does not support any dialog settings - setting them has no
   * effect.
   * </p>
   * @author Martin Vysny
   */
  public class MultiWizard implements IWizard {
  	/***
  	 * Creates instance of wizard switcher.
  	 * @param provider provides switcher with wizard instances.
  	 */
  	public MultiWizard(IMultiWizardProvider provider) {
  		super();
  		this.provider = provider;
  		provider.setWizard(this);
  		if (provider.hasPrevious())
  			throw new IllegalArgumentException(
  					"Provider must be able to offer first wizard initially."); //$NON-NLS-1$
  		if (provider.current() == null)
  			throw new IllegalArgumentException(
  					"Provider must be able to offer at least one wizard."); //$NON-NLS-1$
  	}
  	/***
  	 * Provides switcher with wizard instances.
  	 */
  	protected final IMultiWizardProvider provider;
  	/***
  	 * Contains list of wizards. Last wizard is always the active wizard.
  	 */
  	protected final List<IWizard> wizards = new ArrayList<IWizard>();
  	/***
  	 * Contains pages created by the wizards.
  	 */
  	protected final IdentityHashMap<IWizard, List<BaseWizardPage>> pages = new IdentityHashMap<IWizard, List<BaseWizardPage>>();
  	/***
  	 * Returns active wizard - the last item of <code>wizards</code> array.
  	 * @return active wizard.
  	 */
  	protected final IWizard getActiveWizard() {
  		if (wizards.size() == 0) {
  			// instantiate first wizard.
  			assert !provider.hasPrevious();
  			final IWizard wizard = provider.current();
  			wizards.add(wizard);
  			// create its first page.
  			List<BaseWizardPage> wizardPages = new ArrayList<BaseWizardPage>();
  			final BaseWizardPage firstPage = wizard.current();
  			wizardPages.add(firstPage);
  			pages.put(wizard, wizardPages);
  		}
  		return wizards.get(wizards.size() - 1);
  	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.wizard.IWizard#canFinish()
 	 */
 	public boolean canFinish() {
 		return getActiveWizard().canFinish() && (!provider.hasNext());
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.wizard.IWizard#dispose()
 	 */
 	public void dispose() {
 		// dispose all wizards automatically
 		provider.dispose();
 		for (IWizard w : wizards) {
 			w.dispose();
 		}
 		wizards.clear();
 		pages.clear();
 	}
 	/***
 	 * Finds given page and returns its location in the <code>wizards</code>
 	 * and <code>pages</code> properties.
 	 * @param page page to find
 	 * @return the page location, never <code>null</code>.
 	 */
 	protected PageLocator getPage(BaseWizardPage page) {
 		// iterate backwards
 		for (ListIterator<IWizard> i = wizards.listIterator(wizards.size()); i
 				.hasPrevious();) {
 			IWizard wizard = i.previous();
 			List<BaseWizardPage> wizardPages = pages.get(wizard);
 			int index = wizardPages.lastIndexOf(page);
 			if (index >= 0) {
 				return new PageLocator(wizard, i.nextIndex(), index);
 			}
 		}
 		throw new IllegalArgumentException("Page " + page + " cannot be found"); //$NON-NLS-1$ //$NON-NLS-2$
 	}
 	/***
 	 * Locates page.
 	 * @author Martin Vysny
 	 */
 	protected class PageLocator implements Comparable<PageLocator> {
 		/***
 		 * Wizard containing requested page.
 		 */
 		protected final IWizard wizard;
 		/***
 		 * Index of wizard, containing requested page.
 		 */
 		protected final int wizardIndex;
 		/***
 		 * Index of requested page.
 		 */
 		protected final int pageIndex;
 		/***
 		 * Constructor.
 		 * @param wizard the wizard.
 		 * @param wizardIndex index of the wizard in the wizards list.
 		 * @param pageIndex index of requested page.
 		 */
 		protected PageLocator(IWizard wizard, int wizardIndex, int pageIndex) {
 			super();
 			this.wizard = wizard;
 			this.wizardIndex = wizardIndex;
 			this.pageIndex = pageIndex;
 		}
 		/***
 		 * Returns the page instance.
 		 * @return the page instance.
 		 */
 		protected BaseWizardPage getPage() {
 			return pages.get(wizard).get(pageIndex);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Comparable#compareTo(T)
 		 */
 		public int compareTo(PageLocator o) {
 			if ((o == this) || equals(o))
 				return 0;
 			if (wizardIndex < o.wizardIndex)
 				return -1;
 			if (wizardIndex > o.wizardIndex)
 				return 1;
 			if (pageIndex < o.pageIndex)
 				return -1;
 			if (pageIndex > o.pageIndex)
 				return 1;
 			// can't happen
 			throw new AssertionError();
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Object#equals(java.lang.Object)
 		 */
 		@Override
 		public boolean equals(Object obj) {
 			if (obj == null)
 				return false;
 			if (!(obj instanceof PageLocator))
 				return false;
 			PageLocator other = (PageLocator) obj;
 			if ((wizardIndex != other.wizardIndex)
 					|| (pageIndex != other.pageIndex))
 				return false;
 			// sanity check
 			assert other.wizard == wizard;
 			return true;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Object#toString()
 		 */
 		@Override
 		public String toString() {
 			return "Wizard " + wizardIndex + " page " + pageIndex; //$NON-NLS-1$ //$NON-NLS-2$
 		}
 		/***
 		 * Returns locator for previous page.
 		 * @return locator for previous page, or <code>null</code> if this
 		 * locator is first.
 		 */
 		protected PageLocator getPrevious() {
 			if (pageIndex > 0)
 				return new PageLocator(wizard, wizardIndex, pageIndex - 1);
 			if (wizardIndex == 0)
 				return null;
 			IWizard prevWizard = wizards.get(wizardIndex - 1);
 			return new PageLocator(prevWizard, wizardIndex - 1, pages.get(
 					prevWizard).size() - 1);
 		}
 		/***
 		 * Returns locator for next page.
 		 * @return locator for next page, or <code>null</code> if next page is
 		 * not available/created/registered.
 		 */
 		protected PageLocator getNext() {
 			List<BaseWizardPage> pageDelegates = pages.get(wizard);
 			if (pageDelegates.size() - 1 > pageIndex)
 				return new PageLocator(wizard, wizardIndex, pageIndex + 1);
 			if (wizards.size() - 1 > wizardIndex)
 				return new PageLocator(wizards.get(wizardIndex + 1),
 						wizardIndex + 1, 0);
 			return null;
 		}
 	}
 	/***
 	 * Returns active (last) page.
 	 * @return locator of active page.
 	 */
 	protected PageLocator getActivePage() {
 		IWizard wizard = getActiveWizard();
 		// the list of pages must not be empty - if it is then there's a bug
 		// because the wizard should have been disposed... see
 		// deletePagesAfter() for details
 		return new PageLocator(wizard, wizards.size() - 1, pages.get(wizard)
 				.size() - 1);
 	}
 	/***
 	 * Deletes all pages after given page. Disposes all unused wizards
 	 * automatically.
 	 * @param locator the locator of the page.
 	 * @param including if <code>true</code> then page itself will be deleted.
 	 * In this case the locator must not denote starting page.
 	 */
 	protected void deletePagesAfter(PageLocator locator, boolean including) {
 		if (including && (locator.getPage() == getStartingPage()))
 			throw new IllegalArgumentException(
 					"Starting page cannot be deleted."); //$NON-NLS-1$
 		while (true) {
 			PageLocator actPage = getActivePage();
 			final boolean delete = including ? locator.compareTo(actPage) <= 0
 					: locator.compareTo(actPage) < 0;
 			if (!delete) {
 				// bail out, we have deleted all relevant pages
 				return;
 			}
 			if (actPage.pageIndex != 0) {
 				// delete the page normally
 				BaseWizardPage page;
 				try {
 					page = actPage.wizard.previous();
 				} catch (NoSuchElementException ex) {
 					// this should not happen..
 					throw new IllegalStateException(
 							"Wizard violates rules: it modifies shown pages."); //$NON-NLS-1$
 				}
 				// sanity check
 				if (page != actPage.getPrevious().getPage())
 					throw new IllegalStateException(
 							"Wizard violates rules: it modifies shown pages"); //$NON-NLS-1$
 				// passed. remove the page
 				pages.get(actPage.wizard).remove(actPage.pageIndex);
 			} else {
 				// we have to dispose of the wizard.
 				pages.remove(actPage.wizard);
 				wizards.remove(wizards.size() - 1);
 				actPage.wizard.dispose();
 				IWizard prevWizard = provider.previous();
 				// sanity check
 				actPage = getActivePage();
 				if (prevWizard != actPage.wizard)
 					throw new IllegalStateException(
 							"Wizard provider violates rules: it modifies already returned wizards"); //$NON-NLS-1$
 			}
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#hasNext()
 	 */
 	public boolean hasNext() {
 		final PageLocator currentLocator = getActivePage();
 		// page is the page shown on the display. check if this wizard has more
 		// pages
 		if (currentLocator.getPage().hasErrors()) {
 			// page is not complete, we cannot retrieve next page
 			return false;
 		}
 		if (!currentLocator.wizard.canFinish()) {
 			// page is complete but the wizard cannot finish - there are some
 			// pages left
 			return true;
 		}
 		// page is complete and wizard can finish - are there more wizards?
 		return provider.hasNext();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#current()
 	 */
 	public BaseWizardPage current() {
 		return getActivePage().getPage();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#getName()
 	 */
 	public String getName() {
 		if (provider.getName() != null)
 			return provider.getName();
 		return getActivePage().wizard.getName();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#next()
 	 */
 	public BaseWizardPage next() throws ProviderException {
 		if (!hasNext())
 			throw new NoSuchElementException();
 		final PageLocator currentLocator = getActivePage();
 		// get next page from the wizard
 		IWizard nextWizard = currentLocator.wizard;
 		final BaseWizardPage nextPage;
 		if (!nextWizard.hasNext()) {
 			// next page is null. If this wizard can finish then move to a next
 			// wizard, if there's any.
 			if (!currentLocator.wizard.canFinish() || !provider.hasNext()) {
 				// if we can't finish or if there's no next wizard then just
 				// return null.
 				throw new AssertionError(
 						"hasNext() should have checked this possibility.."); //$NON-NLS-1$
 			}
 			// current wizard can finish AND there's next wizard. Register this
 			// next wizard.
 			nextWizard = provider.next();
 			if (nextWizard == null)
 				throw new NullPointerException("provider returned null wizard"); //$NON-NLS-1$
 			wizards.add(nextWizard);
 			List<BaseWizardPage> nextWizardPages = new ArrayList<BaseWizardPage>();
 			pages.put(nextWizard, nextWizardPages);
 			nextPage = nextWizard.current();
 		} else {
 			nextPage = nextWizard.next();
 		}
 		// ok, walk to 'nextPage'
 		pages.get(nextWizard).add(nextPage);
 		return nextPage;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#hasPrevious()
 	 */
 	public boolean hasPrevious() {
 		return getStartingPage() != getActivePage().getPage();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IWizard#previous()
 	 */
 	public BaseWizardPage previous() {
 		if (!hasPrevious())
 			throw new NoSuchElementException();
 		final PageLocator currentLocator = getActivePage();
 		deletePagesAfter(currentLocator, true);
 		return getActivePage().getPage();
 	}
 	/***
 	 * Retrieves the first page of the first wizard.
 	 * @return first page instance.
 	 */
 	final protected BaseWizardPage getStartingPage() {
 		// ensure that first page is created
 		getActiveWizard();
 		final IWizard first = wizards.get(0);
 		final BaseWizardPage firstPage = pages.get(first).get(0);
 		return firstPage;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.wizard.IWizard#getTitleBarColor()
 	 */
 	public RGB getTitleBarColor() {
 		return getActiveWizard().getTitleBarColor();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.wizard.IWizard#performCancel()
 	 */
 	public boolean performCancel() {
 		// cancels all wizards, but leaves them in the array. It is illegal to
 		// call any other method than dispose() after this call.
 		final ListIterator<IWizard> i = wizards.listIterator(wizards.size());
 		// perform cancel in reversed order
 		for (; i.hasPrevious(); ) {
 			final IWizard wizard = i.previous();
 			// each wizard must be able to be cancelled anytime...
 			if (!wizard.performCancel()) {
 				EuroMath.log(IStatus.WARNING, 0, "Unexpected: Wizard " + wizard //$NON-NLS-1$
 						+ " is not cancellable.", null); //$NON-NLS-1$
 			}
 		}
 		provider.performCancel();
 		return true;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.wizard.IWizard#performFinish()
 	 */
 	public boolean performFinish() {
 		// return false if we cannot finish
 		if (!canFinish())
 			return false;
 		// performs finish on all wizards that have been created
 		for (IWizard wizard : wizards) {
 			// no wizard can fail now...
 			if (!wizard.performFinish())
 				throw new RuntimeException("Unexpected: Wizard " + wizard //$NON-NLS-1$
 						+ " cannot finish"); //$NON-NLS-1$
 		}
 		provider.performFinish();
 		return true;
 	}
 	/***
 	 * Returns the provider instance. The provider's <code>next()</code> and
 	 * <code>previous()</code> methods must not be called.
 	 * @return the provider instance.
 	 */
 	public final IMultiWizardProvider getProvider() {
 		return provider;
 	}
 }