/*
    * Created on Mar 19, 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.List;
  import java.util.NoSuchElementException;
  import javax.xml.namespace.QName;
  import org.w3c.dom.Element;
  import org.w3c.dom.Text;
  import sk.baka.ikslibs.DOMUtils;
  import sk.baka.ikslibs.modify.DOMMutils;
  import sk.baka.ikslibs.ptr.DOMPoint;
  import sk.uniba.euromath.document.NamespaceManager;
  import sk.uniba.euromath.document.XMLAccess;
  import sk.uniba.euromath.document.schema.AttributeListRule;
  import sk.uniba.euromath.document.schema.ElementSequenceRule;
  import sk.uniba.euromath.document.schema.InsertList;
  import sk.uniba.euromath.document.schema.NewElementRule;
  import sk.uniba.euromath.document.schema.plug.IValueRule;
  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;
  /***
   * <p>
   * Fills given element with new content. The element is expected to be freshly
   * created and thus must not contain any children nodes nor attributes.
   * </p>
   * @author Martin Vysny
   */
  public class FillNewElementWizardProvider implements IMultiWizardProvider {
  	/***
  	 * Creates instance of the wizard.
  	 * @param element the element to be filled. The element is expected to be
  	 * freshly created and thus must not contain any children nodes nor
  	 * attributes.
  	 * @param rule the rule for contents of the element.
  	 * @param xmlAccess the document instance.
  	 * @param nsMan actual namespace manager. It won't get modified. If
  	 * <code>null</code> then <code>xmlAccess</code> current namespace
  	 * manager is taken.
  	 * @param name the name of the activity provided by this provider. If
  	 * <code>null</code> then default name is used.
  	 */
  	public FillNewElementWizardProvider(Element element, NewElementRule rule,
  			XMLAccess xmlAccess, NamespaceManager nsMan, String name) {
  		super();
  		this.xmlAccess = xmlAccess;
  		this.name = name == null ? Messages.getString("ENTER_ELEMENT_CONTENT") : name; //$NON-NLS-1$
  		startupManager = nsMan == null ? xmlAccess.getNsManager() : nsMan;
  		// create first factory.
  		firstFactory = getNextStep(rule, element);
  		if (firstFactory != null) {
  			// register it.
  			stepFactories.add(firstFactory);
  			visitedSteps.add(firstFactory.newStep(startupManager));
  		}
  	}
  	/***
  	 * The provider name.
  	 */
  	protected final String name;
  	/***
  	 * The document instance.
  	 */
  	protected final XMLAccess xmlAccess;
  	/***
  	 * Represents one step in wizard.
  	 * @author Martin Vysny
  	 */
  	protected interface WizardStep {
  		/***
  		 * Returns wizard that allows user to enter data required for this step
  		 * to be finished succesfully.
  		 * @return wizard instance. Each call to this method should return same
  		 * instance of wizard.
  		 */
  		public IWizard getWizard();
  		/***
  		 * Returns element where this step creates contents.
  		 * @return the element whose attributes or children are being created by
  		 * this step.
  		 */
  		public Element getContextElement();
  		/***
  		 * Checks whether <code>moveToNextStep()</code> will return non-empty
  		 * list. It does not finish this step. May be called multiple times.
  		 * <code>getWizard().canFinish()</code> is granted to be
  		 * <code>true</code>, and <code>getWizard()</code> has already been
  		 * invoked.
 		 * @return <code>true</code> if there are still more steps.
 		 */
 		public boolean hasNextSteps();
 		/***
 		 * Finishes this step and moves to the next step.
 		 * <code>getWizard().canFinish()</code> is granted to be
 		 * <code>true</code>, and <code>getWizard()</code> has already been
 		 * invoked.
 		 * @return next step, or empty array if no more steps are required.
 		 * Never <code>null</code>.
 		 */
 		public List<AbstractStepFactory> moveToNextStep();
 		/***
 		 * May be called after call to <code>moveToNextStep()</code> if user
 		 * wishes to rollback next step and return to this one.
 		 */
 		public void rollbackFromNextStep();
 	}
 	/***
 	 * Produces new steps. Allows wizards to be created lazily.
 	 * @author Martin Vysny
 	 */
 	protected abstract class AbstractStepFactory {
 		/***
 		 * Rule to use for produced step.
 		 */
 		public final NewElementRule rule;
 		/***
 		 * Step shall fill contents of this element.
 		 */
 		public final Element e;
 		/***
 		 * Constructor.
 		 * @param rule Rule to use for produced step.
 		 * @param e Step shall fill contents of this element.
 		 */
 		protected AbstractStepFactory(NewElementRule rule, Element e) {
 			super();
 			this.rule = rule;
 			this.e = e;
 		}
 		/***
 		 * Produces instance of the step.
 		 * @param manager the namespace manager to use. It must not be modified
 		 * by this step, nor by the following steps.
 		 * @return instance of the step. Must not return <code>null</code>.
 		 */
 		protected abstract WizardStep newStep(NamespaceManager manager);
 	}
 	/***
 	 * Step that allows user to create attributes in newly created element.
 	 * @author Martin Vysny
 	 */
 	protected class CreateAttributesWS implements WizardStep {
 		/***
 		 * rule for this new element.
 		 */
 		protected final NewElementRule rule;
 		/***
 		 * Rules for possible new attributes, as required by the schema.
 		 */
 		protected final List<AttributeListRule> attrRules;
 		/***
 		 * the new element. Must not contain any elements nor attributes.
 		 */
 		protected final Element e;
 		/***
 		 * current namespace manager. won't get modified.
 		 */
 		protected final NamespaceManager nsManager;
 		/***
 		 * Constructor.
 		 * @param rule rule for this new element.
 		 * @param e the new element. Must not contain any elements nor
 		 * attributes.
 		 * @param nsManager current namespace manager. won't get modified.
 		 */
 		protected CreateAttributesWS(NewElementRule rule, Element e,
 				NamespaceManager nsManager) {
 			super();
 			attrRules = rule.getLists();
 			this.e = e;
 			this.nsManager = nsManager;
 			this.rule = rule;
 			if (attrRules.isEmpty())
 				throw new IllegalArgumentException();
 		}
 		/***
 		 * The wizard instance.
 		 */
 		protected CreateAttributeListWizard wizard = null;
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#getWizard()
 		 */
 		public CreateAttributeListWizard getWizard() {
 			if (wizard != null)
 				return wizard;
 			wizard = new CreateAttributeListWizard(attrRules, DOMUtils
 					.printQName(e),
 					FillNewElementWizardProvider.this.xmlAccess, nsManager);
 			return wizard;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#getContextElement()
 		 */
 		public Element getContextElement() {
 			return e;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#hasNextSteps()
 		 */
 		public boolean hasNextSteps() {
 			List< ? > result = moveToNextStep();
 			rollbackFromNextStep();
 			return result.size() != 0;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#moveToNextStep()
 		 */
 		public List<AbstractStepFactory> moveToNextStep() {
 			// get all attributes names and values
 			if (wizard == null)
 				throw new IllegalStateException("Page has not yet been created"); //$NON-NLS-1$
 			// create the attributes
 			wizard.createAttributes(e, null);
 			// create and return next wizard step
 			List<AbstractStepFactory> nextStep = new ArrayList<AbstractStepFactory>(
 					1);
 			AbstractStepFactory nextFactory = getNextStep(rule, e);
 			if (nextFactory != null)
 				nextStep.add(nextFactory);
 			return nextStep;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#rollbackFromNextStep()
 		 */
 		public void rollbackFromNextStep() {
 			DOMMutils.clearAttributes(e);
 		}
 	}
 	/***
 	 * Creates new elements or text nodes in new element. This element should
 	 * already contain attributes, to select correct rule amongst similar rules.
 	 * @author Martin Vysny
 	 */
 	protected class CreateElementContentsWS implements WizardStep {
 		/***
 		 * rule for this new element.
 		 */
 		protected final NewElementRule rule;
 		/***
 		 * the new element. Must not contain any elements nor attributes.
 		 */
 		protected final Element e;
 		/***
 		 * current namespace manager. won't get modified.
 		 */
 		protected final NamespaceManager nsManager;
 		/***
 		 * Constructor.
 		 * @param rule rule for this new element.
 		 * @param e the new element. Must not contain any elements nor
 		 * attributes.
 		 * @param nsManager current namespace manager. won't get modified.
 		 */
 		protected CreateElementContentsWS(NewElementRule rule, Element e,
 				NamespaceManager nsManager) {
 			super();
 			this.e = e;
 			this.nsManager = nsManager;
 			this.rule = rule;
 		}
 		/***
 		 * The wizard instance.
 		 */
 		protected InsertListChooserWizard wizard = null;
 		/***
 		 * User may select between these insertlists.
 		 */
 		protected List<InsertList> insertLists = null;
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#getWizard()
 		 */
 		public IWizard getWizard() {
 			if (wizard != null)
 				return wizard;
 			// get rules for new content.
 			ElementSequenceRule seqRule = rule.getNewContent(e);
 			insertLists = (seqRule == null) ? new ArrayList<InsertList>()
 					: seqRule.getSequences(DOMPoint.FIRST);
 			IValueRule textRule = rule.getNewTextRule(e);
 			// if there is no required content then just return
 			assert (insertLists.size() != 0) || (textRule != null);
 			wizard = new InsertListChooserWizard(
 					FillNewElementWizardProvider.this.xmlAccess, insertLists,
 					nsManager, DOMUtils.printQName(e), textRule, Messages
 							.getString("NEW_ELEMENT_CONTENT")); //$NON-NLS-1$
 			return wizard;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#getContextElement()
 		 */
 		public Element getContextElement() {
 			return e;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#hasNextSteps()
 		 */
 		public boolean hasNextSteps() {
 			List< ? > result = moveToNextStep();
 			rollbackFromNextStep();
 			return result.size() != 0;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#moveToNextStep()
 		 */
 		public List<AbstractStepFactory> moveToNextStep() {
 			int sel = wizard.ilcPage.getWidget().getSelected();
 			if (sel == -2) {
 				// create a text, no elements actually needs to be created.
 				Text text = xmlAccess.getDocument().createTextNode(
 						wizard.ilcPage.getWidget().getText());
 				e.appendChild(text);
 				return new ArrayList<AbstractStepFactory>();
 			}
 			// some insertlist must be selected.
 			assert sel >= 0;
 			List<QName> elementNames = wizard.getNames();
 			InsertList insertList = insertLists.get(sel);
 			// create new elements and for each element compute new correct
 			// 'step' object.
 			List<AbstractStepFactory> result = new ArrayList<AbstractStepFactory>(
 					insertList.size());
 			for (int i = 0; i < insertList.size(); i++) {
 				// create new element and get a rule for it.
 				QName qname = elementNames.get(i);
 				Element newElement = xmlAccess.getDocument().createElementNS(
 						qname.getNamespaceURI(), DOMUtils.printQName(qname));
 				e.appendChild(newElement);
 				NewElementRule newRule = insertList.get(i).nameList.getRule(
 						qname, true);
 				// generate factory for next step.
 				final AbstractStepFactory factory = getNextStep(newRule,
 						newElement);
 				if (factory != null)
 					result.add(factory);
 			}
 			return result;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.WizardStep#rollbackFromNextStep()
 		 */
 		public void rollbackFromNextStep() {
 			// delete all created child nodes.
 			DOMMutils.clearChildren(e, true);
 		}
 	}
 	/***
 	 * Determines which step is to be taken next.
 	 * @param rule rule for element e.
 	 * @param e the element. It may already have attributes created.
 	 * @return new wizard step factory, or <code>null</code> if there are no
 	 * required elements and/or attributes in given rule.
 	 */
 	protected AbstractStepFactory getNextStep(NewElementRule rule, Element e) {
 		// check if attributes are needed to be created
 		if (!e.hasAttributes()) {
 			List<AttributeListRule> attrRules = rule.getLists();
 			if ((attrRules != null) && (attrRules.size() > 0)) {
 				// we need to create some attributes.
 				return new AbstractStepFactory(rule, e) {
 					/*
 					 * (non-Javadoc)
 					 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.AbstractStepFactory#newStep(sk.uniba.euromath.document.NamespaceManager)
 					 */
 					@Override
 					protected WizardStep newStep(NamespaceManager manager) {
 						return new CreateAttributesWS(rule, e, manager);
 					}
 				};
 			}
 		}
 		// check if we need to create some element content.
 		ElementSequenceRule seqRule = rule.getNewContent(e);
 		List<InsertList> insertLists = (seqRule == null) ? new ArrayList<InsertList>()
 				: seqRule.getSequences(DOMPoint.FIRST);
 		IValueRule textRule = rule.getNewTextRule(e);
 		// if there is no required content then just return
 		if ((insertLists.size() == 0) && (textRule == null))
 			return null;
 		return new AbstractStepFactory(rule, e) {
 			/*
 			 * (non-Javadoc)
 			 * @see sk.uniba.euromath.editor.wizards.document.FillNewElementWizardProvider.AbstractStepFactory#newStep(sk.uniba.euromath.document.NamespaceManager)
 			 */
 			@Override
 			protected WizardStep newStep(NamespaceManager manager) {
 				return new CreateElementContentsWS(rule, e, manager);
 			}
 		};
 	}
 	/***
 	 * All wizard step factories. This list may contain more items than already
 	 * returned wizards - predictions, which wizard will follow are stored here
 	 * aswell.
 	 */
 	protected final List<AbstractStepFactory> stepFactories = new ArrayList<AbstractStepFactory>();
 	/***
 	 * List of steps that have been already visited. Last item of this array is
 	 * a step that was returned by recent call to <code>next()</code> and is
 	 * currently interacting with user. This list is consistent with the
 	 * <code>stepFactories</code>: i-th factory has produced i-th step.
 	 */
 	protected final List<WizardStep> visitedSteps = new ArrayList<WizardStep>();
 	/***
 	 * Index of item which was returned by last <code>next()</code> call.
 	 */
 	private int activeItem = 0;
 	/***
 	 * The first factory. May be <code>null</code> - in this case no element
 	 * content needs to be created and this provider provides no wizards. If not
 	 * <code>null</code> and <code>stepFactories</code> has at least one
 	 * item, then <code>stepFactories.get(0)==firstFactory</code>.
 	 */
 	protected final AbstractStepFactory firstFactory;
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#performCancel()
 	 */
 	public void performCancel() {
 		// no special processing needed
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#performFinish()
 	 */
 	public void performFinish() {
 		// finalize last step
 		List< ? > result = visitedSteps.get(visitedSteps.size() - 1)
 				.moveToNextStep();
 		assert result.size() == 0;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#current()
 	 */
 	public IWizard current() {
 		if (firstFactory == null)
 			return null;
 		return visitedSteps.get(activeItem).getWizard();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#hasNext()
 	 */
 	public boolean hasNext() {
 		// check if we are able to produce wizard in next step.
 		if (activeItem < stepFactories.size() - 1)
 			return true;
 		// check if last wizard step is able to produce more steps
 		WizardStep last = visitedSteps.get(activeItem);
 		return last.hasNextSteps();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#hasPrevious()
 	 */
 	public boolean hasPrevious() {
 		return activeItem > 0;
 	}
 	/***
 	 * Namespace manager provided at construction time.
 	 */
 	protected final NamespaceManager startupManager;
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#next()
 	 */
 	public IWizard next() {
 		assert activeItem == visitedSteps.size() - 1;
 		assert visitedSteps.size() <= stepFactories.size();
 		// get factory that'll produce wizard step able to produce active wizard
 		AbstractStepFactory factory;
 		WizardStep activeStep = visitedSteps.get(activeItem);
 		// register factories spawned from currently active wizard, if
 		// needed.
 		List<AbstractStepFactory> factories = activeStep.moveToNextStep();
 		int i = activeItem + 1;
 		for (AbstractStepFactory newFactory : factories) {
 			stepFactories.add(i, newFactory);
 			i++;
 		}
 		// get new active factory.
 		if (activeItem + 1 >= stepFactories.size())
 			throw new NoSuchElementException();
 		factory = stepFactories.get(activeItem + 1);
 		// create the step and register it
 		WizardStep step = factory.newStep(newNsManager());
 		visitedSteps.add(step);
 		// check if there is some required content. If yes then create and
 		// register appropriate factories.
 		activeItem++;
 		return step.getWizard();
 	}
 	/***
 	 * Determines and returns active namespace manager.
 	 * @return namespace manager of current step's wizard.
 	 */
 	public NamespaceManager newNsManager() {
 		// if (activeItem == 0)
 		// return startupManager;
 		// retrieve namespace manager from previous step.
 		final WizardStep activeStep = visitedSteps.get(activeItem);
 		final IWizard activeWizard = activeStep.getWizard();
 		final NamespaceManager result;
 		if (activeWizard instanceof CreateAttributeListWizard) {
 			result = ((CreateAttributeListWizard) activeWizard).newNsManager();
 		} else {
 			result = ((InsertListChooserWizard) activeWizard).newNsManager();
 		}
 		return result;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#previous()
 	 */
 	public IWizard previous() {
 		if (!hasPrevious())
 			throw new NoSuchElementException();
 		AbstractStepFactory active = stepFactories.get(activeItem);
 		// check if previous factory has created contents of parent element. If
 		// yes then we shall delete all consecutive factories generating
 		// contents of same element.
 		AbstractStepFactory previous = stepFactories.get(activeItem - 1);
 		// test if we have to delete factories producing contents of same
 		// element. We must delete all factories that may become invalid when
 		// 'previous' factory becomes active. This may happen when:
 		// a) previous factory generates attributes for e. depending on these
 		// attributes, different rules for contents of e may be selected. We
 		// must delete all factories for e.
 		WizardStep prevStep = visitedSteps.get(activeItem - 1);
 		boolean delete = (prevStep.getWizard() instanceof CreateAttributeListWizard);
 		// b) previous factory generates content for parent of e. We must delete
 		// all factories for e.
 		if (!delete) {
 			delete = (active.e.getParentNode() != null)
 					&& active.e.getParentNode().isSameNode(previous.e);
 		}
 		if (delete) {
 			// remove 'active' factory and all that are creating contents of
 			// same element.
 			while (activeItem < stepFactories.size()) {
 				AbstractStepFactory fac = stepFactories.get(activeItem);
 				if (active.e.isSameNode(fac.e))
 					stepFactories.remove(activeItem);
 				else
 					break;
 			}
 		}
 		// go back.
 		IWizard result = visitedSteps.get(activeItem).getWizard();
 		visitedSteps.remove(activeItem);
 		assert visitedSteps.size() == activeItem;
 		activeItem--;
 		result = visitedSteps.get(activeItem).getWizard();
 		return result;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#dispose()
 	 */
 	public void dispose() {
 		visitedSteps.clear();
 		stepFactories.clear();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#setWizard(sk.uniba.euromath.editor.wizards.MultiWizard)
 	 */
 	public void setWizard(MultiWizard wizard) {
 		// do nothing, we don't use the wizard instance.
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.wizards.IMultiWizardProvider#getName()
 	 */
 	public String getName() {
 		return name;
 	}
 }