/*
    * 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.util.ArrayList;
  import java.util.EnumSet;
  import java.util.List;
  import org.w3c.dom.Node;
  import org.w3c.dom.events.Event;
  import org.w3c.dom.events.EventListener;
  import org.w3c.dom.events.EventTarget;
  import org.w3c.dom.events.MutationEvent;
  import sk.baka.ikslibs.EventClassEnum;
  import sk.baka.ikslibs.EventTypesEnum;
  import sk.baka.ikslibs.INodeObserver;
  import sk.baka.ikslibs.modify.DOMMutils;
  import sk.baka.ikslibs.ptr.DomPointer;
  import sk.baka.ikslibs.ptr.DomPointerFactory;
  /***
   * Manages undoing of the modification operations. Thread-unsafe.
   * @author Martin Vysny
   * @TODO Move to the ikslibs library.
   */
  public final class UndoManager implements EventListener, INodeObserver {
  	/***
  	 * Constructs an empty undo manager.
  	 */
  	public UndoManager() {
  		super();
  		// create an empty undo group.
  		getLastGroup();
  	}
  	/***
  	 * Contains the undo history. A list of undo groups. Each list is a list of
  	 * actions that has to be taken (in reversed order - from latest to first)
  	 * in order to undo to the mark.
  	 */
  	private final List<UndoGroup> history = new ArrayList<UndoGroup>();
  	/***
  	 * Index of active undo group in history. All items before this item are the
  	 * undo history, all items after this item are operations that were redoed.
  	 */
  	private int historyItem = 0;
  	/***
  	 * If <code>true</code> then we are performing an {@link #undo() undo} or
  	 * {@link #redo() redo} operation and node mutation events must be ignored.
  	 */
  	private boolean ignoringEvents = false;
  	/***
  	 * Marks the end of previous modification operations group and the start of
  	 * a new group. When undo is requested all modifications are rolled back to
  	 * nearest mark point.
  	 */
  	public void mark() {
  		mark(false);
  	}
  	/***
  	 * Marks the end of previous modification operations group and the start of
  	 * a new group. When undo is requested all modifications are rolled back to
  	 * nearest mark point.
  	 * @param savePoint if <code>true</code> then this mark marks a point when
  	 * the document was saved.
  	 */
  	public void mark(final boolean savePoint) {
  		// check if previous mark has some actions. if not then there is no need
  		// to create new mark
  		final UndoGroup last = getLastGroup();
  		if (!last.canUndo()) {
  			if (savePoint)
  				last.isSavePoint = savePoint;
  			return;
  		}
  		// create new undo group.
  		final UndoGroup newGroup = new UndoGroup();
  		newGroup.isSavePoint = savePoint;
  		history.add(newGroup);
  		purgeHistory();
  	}
  	/***
  	 * Checks if the manager is currently 'standing' on the savepoint mark.
  	 * @return <code>true</code> if last undo group is empty (it contains no
  	 * actions) and savepoint.
  	 */
  	public boolean isSavePoint() {
  		final UndoGroup last = getLastGroup();
  		if (last.canUndo())
  			return false;
  		return last.isSavePoint;
  	}
  	/***
  	 * Represents an undo actions group. Contains undoable actions.
 	 * @author Martin Vysny
 	 */
 	private final class UndoGroup {
 		/***
 		 * A list of actions that has to be taken (in reversed order - from
 		 * latest to first) in order to undo the whole group.
 		 */
 		private final List<IUndoAction> actions = new ArrayList<IUndoAction>();
 		/***
 		 * Current action that is about to be undone. After
 		 * {@link #performUndo()} it will be zero, after {@link #performRedo()}
 		 * it will be equal to <code>actions.size() - 1</code>.
 		 */
 		private int currentAction = -1;
 		/***
 		 * Checks if there are some actions to be undone.
 		 * @return <code>true</code> if some actions are left to be undone.
 		 */
 		public boolean canUndo() {
 			return currentAction >= 0;
 		}
 		/***
 		 * Checks if there are some actions that were undone.
 		 * @return <code>true</code> if some actions can be redone.
 		 */
 		public boolean canRedo() {
 			return currentAction < actions.size() - 1;
 		}
 		/***
 		 * If <code>true</code> then this mark marks a point when the document
 		 * was saved.
 		 */
 		private boolean isSavePoint;
 		/***
 		 * Performs the undo operation. Rollbacks all actions. If no actions
 		 * were performed then nothing is done.
 		 */
 		public void performUndo() {
 			if (!canUndo())
 				return;
 			// temporarily remove our listener.
 			ignoringEvents = true;
 			try {
 				for (; currentAction >= 0; currentAction--) {
 					actions.get(currentAction).undo();
 				}
 			} finally {
 				ignoringEvents = false;
 			}
 		}
 		/***
 		 * Performs the redo operation. Re-executes all previously undone
 		 * actions. Does nothing when there are no actions to be redone.
 		 */
 		public void performRedo() {
 			if (!canRedo())
 				return;
 			// temporarily remove our listener.
 			ignoringEvents = true;
 			try {
 				for (; currentAction < actions.size() - 1; currentAction++) {
 					actions.get(currentAction + 1).redo();
 				}
 			} finally {
 				ignoringEvents = false;
 			}
 		}
 		/***
 		 * Adds new undo action.
 		 * @param action the undo action to add.
 		 */
 		public void add(final IUndoAction action) {
 			if (canRedo())
 				throw new IllegalStateException(
 						"There are some actions that were undone."); //$NON-NLS-1$
 			actions.add(action);
 			currentAction++;
 		}
 		/***
 		 * Removes all redoable operations.
 		 */
 		public void clearRedoOps() {
 			while (actions.size() - 1 > currentAction) {
 				actions.remove(actions.size() - 1);
 			}
 			assert !canRedo();
 		}
 	}
 	/***
 	 * Deletes all oldest marks in order for the history list to contain at most
 	 * maximum allowed number of the marks.
 	 */
 	private void purgeHistory() {
 		int purgeCount = history.size() - maxMarkCount;
 		if (purgeCount <= 0)
 			return;
 		historyItem -= purgeCount;
 		assert historyItem >= 0;
 		for (; purgeCount > 0; purgeCount--) {
 			history.remove(0);
 		}
 	}
 	/***
 	 * Removes all operations that were undoed and still can be redoed.
 	 */
 	private void clearRedoOps() {
 		// remove all redoable history items.
 		while (history.size() - 1 > historyItem) {
 			history.remove(history.size() - 1);
 		}
 		getLastGroup().clearRedoOps();
 		assert !canRedo();
 	}
 	/***
 	 * Returns last undo group.
 	 * @return undo list of last mark, never <code>null</code>.
 	 */
 	private UndoGroup getLastGroup() {
 		if (history.isEmpty()) {
 			final UndoGroup result = new UndoGroup();
 			result.isSavePoint = true;
 			history.add(result);
 			historyItem = 0;
 			return result;
 		}
 		return history.get(historyItem);
 	}
 	/***
 	 * <p>
 	 * Rollbacks all previous modification operations up to the nearest mark
 	 * point. If no operations were performed then nothing is done.
 	 * </p>
 	 * <p>
 	 * The document must be in the modifying mode ({@link DocumentModifier#startModify()}
 	 * must have been called).
 	 * </p>
 	 */
 	public void undo() {
 		if (!canUndo())
 			return;
 		// check if previous mark has some actions. if not then delete it.
 		UndoGroup last = getLastGroup();
 		if (!last.canUndo() && (historyItem > 0))
 			historyItem--;
 		// get all actions of the last mark.
 		last = getLastGroup();
 		// rollback the last group.
 		last.performUndo();
 	}
 	/***
 	 * Checks if there are some undoable operations.
 	 * @return <code>true</code> if there are some undoable operations,
 	 * <code>false</code> otherwise.
 	 */
 	public boolean canUndo() {
 		return getLastGroup().canUndo() || (historyItem > 0);
 	}
 	/***
 	 * <p>
 	 * Redoes previously undone modification operations up to the nearest mark
 	 * point. If no operations can be redone then nothing is done.
 	 * </p>
 	 * <p>
 	 * The document must be in the modifying mode ({@link DocumentModifier#startModify()}
 	 * must have been called).
 	 * </p>
 	 */
 	public void redo() {
 		if (!canRedo())
 			return;
 		// redo.
 		final UndoGroup last = getLastGroup();
 		assert last.canRedo();
 		last.performRedo();
 		if (historyItem < history.size() - 1)
 			historyItem++;
 	}
 	/***
 	 * Checks if there are some undo actions that can be applied back to the
 	 * document.
 	 * @return <code>true</code> if there are some redoable operations,
 	 * <code>false</code> otherwise.
 	 */
 	public boolean canRedo() {
 		if (history.size() - 1 > historyItem)
 			return true;
 		return getLastGroup().canRedo();
 	}
 	/***
 	 * Maximum mark count, defaults to <code>10</code>.
 	 */
 	private int maxMarkCount = 10;
 	/***
 	 * Returns the maximum number of marks. Defaults to <code>5</code>.
 	 * @return maximum length of undo history.
 	 */
 	public int getMarkCount() {
 		return maxMarkCount;
 	}
 	/***
 	 * Sets new maximum count of marks - a maximum undo history length. If new
 	 * mark exceeds this limit then first (oldest) mark is forgotten and undo is
 	 * impossible beyond that mark point.
 	 * @param count the maximum marks count.
 	 */
 	public void setMarkCount(int count) {
 		if (count <= 0)
 			throw new IllegalArgumentException("Count must be greater than 0."); //$NON-NLS-1$
 		maxMarkCount = count;
 		purgeHistory();
 	}
 	/***
 	 * Standard interface for all remembered undo actions.
 	 * @author Martin Vysny
 	 */
 	private interface IUndoAction {
 		/***
 		 * Undoes the action. The operation performed depends on the type of the
 		 * action.
 		 */
 		public void undo();
 		/***
 		 * Redoes the action. Can be called only after the {@link #undo()}
 		 * method was called.
 		 */
 		public void redo();
 	}
 	/***
 	 * The node was deleted or inserted.
 	 * @author Martin Vysny
 	 */
 	private class UndoActionMoveNode implements IUndoAction {
 		/***
 		 * Which node to insert.
 		 */
 		private final Node node;
 		/***
 		 * Where to insert the node. If <code>isParent</code> is false then
 		 * the node is inserted before this node, otherwise it is inserted as a
 		 * last child node in this node.
 		 */
 		private final Node where;
 		/***
 		 * Where to insert the node. If false then the node is inserted before
 		 * the <code>where</code> node otherwise it is inserted as a last
 		 * child node in the <code>where</code> node.
 		 */
 		private final boolean isParent;
 		/***
 		 * If <code>true</code> then the node was inserted. {@link #undo()}
 		 * will delete the node, {@link #redo()} will reinsert the node. If
 		 * <code>false</code> then the node is about to be deleted.
 		 * {@link #undo()} will reinsert the node, {@link #redo()} will delete
 		 * the node.
 		 */
 		private final boolean inserted;
 		/***
 		 * Constructs the action.
 		 * @param node Which node to insert. The node must not be present in the
 		 * document.
 		 * @param inserted if <code>true</code> then the node was inserted.
 		 * {@link #undo()} will delete the node, {@link #redo()} will reinsert
 		 * the node. If <code>false</code> then the node is about to be
 		 * deleted. {@link #undo()} will reinsert the node, {@link #redo()} will
 		 * delete the node.
 		 */
 		private UndoActionMoveNode(final Node node, final boolean inserted) {
 			super();
 			this.node = node;
 			this.isParent = (node.getNextSibling() == null);
 			this.where = isParent ? node.getParentNode() : node
 					.getNextSibling();
 			this.inserted = inserted;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.UndoManager.IUndoAction#undo()
 		 */
 		public void undo() {
 			if (inserted)
 				deleteNode();
 			else
 				insertNode();
 		}
 		/***
 		 * Inserts the node at given position.
 		 */
 		private void insertNode() {
 			if (node.getParentNode() != null)
 				throw new IllegalStateException(
 						"Node is present in the document"); //$NON-NLS-1$
 			final DomPointer ptr;
 			if (isParent) {
 				ptr = DomPointerFactory.create(where, (Node) null);
 			} else {
 				ptr = DomPointerFactory.create(where);
 			}
 			DOMMutils.insertNode(node, ptr, false);
 		}
 		/***
 		 * Removes the node from given position.
 		 */
 		private void deleteNode() {
 			if (node.getParentNode() == null)
 				throw new IllegalStateException(
 						"Node is not present in the document"); //$NON-NLS-1$
 			node.getParentNode().removeChild(node);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.UndoManager.IUndoAction#redo()
 		 */
 		public void redo() {
 			if (inserted)
 				insertNode();
 			else
 				deleteNode();
 		}
 	}
 	/***
 	 * Modifies the node using old values from the <code>ChangeTracer</code>.
 	 * @author Martin Vysny
 	 */
 	private class UndoActionModifyNode implements IUndoAction {
 		/***
 		 * New data of node, see {@link MutationEvent#getNewValue()}.
 		 */
 		private final String newData;
 		/***
 		 * New data of node, see {@link MutationEvent#getPrevValue()}.
 		 */
 		private final String prevData;
 		/***
 		 * The mutated node.
 		 */
 		private final Node node;
 		/***
 		 * Constructs action that modifies the node.
 		 * @param event used to perform the modification operation.
 		 */
 		private UndoActionModifyNode(final MutationEvent event) {
 			super();
 			newData = event.getNewValue();
 			prevData = event.getPrevValue();
 			node = EventClassEnum.Mutation.getMutatedNode(event);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.UndoManager.IUndoAction#undo()
 		 */
 		public void undo() {
 			DOMMutils.setText(node, prevData);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.UndoManager.IUndoAction#redo()
 		 */
 		public void redo() {
 			DOMMutils.setText(node, newData);
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.w3c.dom.events.EventListener#handleEvent(org.w3c.dom.events.Event)
 	 */
 	public void handleEvent(Event evt) {
 		if (ignoringEvents)
 			return;
 		final EventTypesEnum e = EventTypesEnum.fromEvent(evt);
 		if ((e.getEventClass() != EventClassEnum.Mutation) || !e.isRaw())
 			return;
 		// create undo action
 		final MutationEvent mevt = (MutationEvent) evt;
 		clearRedoOps();
 		final UndoGroup last = getLastGroup();
 		final Node mutatedNode = EventClassEnum.Mutation.getMutatedNode(mevt);
 		if (EventClassEnum.Mutation.isRemoval(mevt)) {
 			// the node is about to be deleted. When undoing then it shall be
 			// created back.
 			last.add(new UndoActionMoveNode(mutatedNode, false));
 		} else if (EventClassEnum.Mutation.isAddition(mevt)) {
 			// the node was added. Undoing shall delete it.
 			last.add(new UndoActionMoveNode(mutatedNode, true));
 		} else {
 			assert EventClassEnum.Mutation.isModification(mevt);
 			// the node was modified
 			last.add(new UndoActionModifyNode(mevt));
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.baka.ikslibs.INodeObserver#observe(org.w3c.dom.Node)
 	 */
 	public void observe(Node node) {
 		final EventTarget et = (EventTarget) node;
 		EventTypesEnum.addEventListenerTo(et, this, true, EnumSet.of(
 				EventTypesEnum.MAttrModified,
 				EventTypesEnum.MCharacterDataModified,
 				EventTypesEnum.MNodeInserted, EventTypesEnum.MNodeRemoved));
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.baka.ikslibs.INodeObserver#stopObservation(org.w3c.dom.Node)
 	 */
 	public void stopObservation(Node node) {
 		final EventTarget et = (EventTarget) node;
 		EventTypesEnum.removeEventListenerFrom(et, this, true, EnumSet.of(
 				EventTypesEnum.MAttrModified,
 				EventTypesEnum.MCharacterDataModified,
 				EventTypesEnum.MNodeInserted, EventTypesEnum.MNodeRemoved));
 	}
 }