/*******************************************************************************
 * Copyright (c) 2001, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.contentoutline;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.xml.ui.internal.XMLUIMessages;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 * This job holds a queue of updates (affected nodes) for multiple structured
 * viewers. When a new request comes in, the current run is cancelled, the new
 * request is added to the queue, then the job is re-scheduled. Support for
 * multiple structured viewers is required because refresh updates are usually
 * triggered by model changes, and the model may be visible in more than one
 * viewer.
 * 
 * @author pavery
 */
class RefreshStructureJob extends Job {

	/** debug flag */
	static final boolean DEBUG;
	private static final long UPDATE_DELAY = 300;
	static {
		String value = Platform.getDebugOption("org.eclipse.wst.sse.ui/debug/refreshStructure"); //$NON-NLS-1$
		DEBUG = (value != null) && value.equalsIgnoreCase("true"); //$NON-NLS-1$
	}
	/** List of refresh requests (Nodes) */
	private final List fRefreshes;
	/** List of update requests (Nodes) */
	private final List fUpdates;
	/** List of update requests (Nodes) */
	private final List fUpdateProperties;
	/** the structured viewers */
	Set fRefreshViewers = new HashSet(3);
	Set fUpdateViewers = new HashSet(3);

	public RefreshStructureJob() {
		super(XMLUIMessages.refreshoutline_0);
		setPriority(Job.LONG);
		setSystem(true);
		fRefreshes = new ArrayList(5);
		fUpdates = new ArrayList(5);
		fUpdateProperties = new ArrayList(5);
	}

	private synchronized void addUpdateRequest(Node newNodeRequest, String[] updateProperties) {
		/*
		 * If we get to here, either from existing request list being zero
		 * length, or no exisitng requests "matched" new request, then add the
		 * new request.
		 */
		fUpdates.add(newNodeRequest);
		fUpdateProperties.add(updateProperties);
	}

	private synchronized void addUpdateViewer(StructuredViewer viewer) {
		fUpdateViewers.add(viewer);
	}

	private synchronized void addRefreshRequest(Node newNodeRequest) {
		/*
		 * note: the caller must NOT pass in null node request (which, since
		 * private method, we do not need to gaurd against here, as long as we
		 * gaurd against it in calling method.
		 */
		int size = fRefreshes.size();
		for (int i = 0; i < size; i++) {
			Node existingNodeRequest = (Node) fRefreshes.get(i);
			/*
			 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=157427 If we
			 * already have a request which equals the new request, discard
			 * the new request
			 */
			if (existingNodeRequest.equals(newNodeRequest)) {
				return;
			}
			/*
			 * If we already have a request which contains the new request,
			 * discard the new request
			 */
			if (contains(existingNodeRequest, newNodeRequest)) {
				return;
			}
			/*
			 * If new request contains any existing requests, replace it with
			 * new request. ISSUE: technically, we should replace ALL
			 * contained, existing requests (such as if many siblings already
			 * que'd up when their common parent is then requested, but, I'm
			 * not sure if that occurs much, in practice, or if there's an
			 * algorithm to quickly find them all. Actually, I guess we could
			 * just go through the _rest_ of the list (i+1 to size) and remove
			 * any that are contained by new request ... in future :) .
			 */
			if (contains(newNodeRequest, existingNodeRequest)) {
				fRefreshes.set(i, newNodeRequest);
				return;
			}
		}
		/*
		 * If we get to here, either from existing request list being zero
		 * length, or no exisitng requests "matched" new request, then add the
		 * new request.
		 */
		fRefreshes.add(newNodeRequest);
	}

	private synchronized void addRefreshViewer(StructuredViewer viewer) {
		fRefreshViewers.add(viewer);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.runtime.jobs.Job#canceling()
	 */
	protected void canceling() {
		fUpdates.clear();
		fUpdateViewers.clear();
		super.canceling();
	}

	/**
	 * Simple hierarchical containment relationship. Note, this method returns
	 * "false" if the two nodes are equal!
	 * 
	 * @param root
	 * @param possible
	 * @return if the root is parent of possible, return true, otherwise
	 *         return false
	 */
	private boolean contains(Node root, Node possible) {
		if (DEBUG) {
			System.out.println("=============================================================================================================="); //$NON-NLS-1$
			System.out.println("recursive call w/ root: " + root.getNodeName() + " and possible: " + possible); //$NON-NLS-1$ //$NON-NLS-2$
			System.out.println("--------------------------------------------------------------------------------------------------------------"); //$NON-NLS-1$
		}

		// the following checks are important
		// #document node will break the algorithm otherwise

		// can't contain the child if it's null
		if (root == null) {
			if (DEBUG) {
				System.out.println("returning false: root is null"); //$NON-NLS-1$
			}
			return false;
		}
		// nothing can be parent of Document node
		if (possible instanceof Document) {
			if (DEBUG) {
				System.out.println("returning false: possible is Document node"); //$NON-NLS-1$
			}
			return false;
		}
		// document contains everything
		if (root instanceof Document) {
			if (DEBUG) {
				System.out.println("returning true: root is Document node"); //$NON-NLS-1$
			}
			return true;
		}

		// check parentage
		Node current = possible;
		// loop parents
		while ((current != null) && (current.getNodeType() != Node.DOCUMENT_NODE)) {
			// found it
			if (root.equals(current)) {
				if (DEBUG) {
					System.out.println("   !!! found: " + possible.getNodeName() + " in subelement of: " + root.getNodeName()); //$NON-NLS-1$ //$NON-NLS-2$
				}
				return true;
			}
			current = current.getParentNode();
		}
		// never found it
		return false;
	}

	/**
	 * Refresh must be on UI thread because it's on a SWT widget.
	 * 
	 * @param node
	 */
	private void doRefresh(final Node node, final StructuredViewer[] viewers) {
		final Display display = PlatformUI.getWorkbench().getDisplay();
		display.asyncExec(new Runnable() {
			public void run() {
				if (DEBUG) {
					System.out.println("refresh on: [" + node.getNodeName() + "]"); //$NON-NLS-1$ //$NON-NLS-2$
				}

				for (int i = 0; i < viewers.length; i++) {
					if (!viewers[i].getControl().isDisposed()) {
						if (node.getNodeType() == Node.DOCUMENT_NODE) {
							viewers[i].refresh(true);
						}
						else {
							viewers[i].refresh(node, true);
						}
					}
					else {
						if (DEBUG) {
							System.out.println("   !!! skipped refreshing disposed viewer: " + viewers[i]); //$NON-NLS-1$
						}
					}
				}
			}
		});
	}

	/**
	 * Update must be on UI thread because it's on a SWT widget.
	 * 
	 * @param node
	 */
	private void doUpdate(final StructuredViewer[] viewers, final Node node, final String[] properties) {
		final Display display = PlatformUI.getWorkbench().getDisplay();
		display.asyncExec(new Runnable() {
			public void run() {
				if (DEBUG) {
					System.out.println("refresh on: [" + node.getNodeName() + "]"); //$NON-NLS-1$ //$NON-NLS-2$
				}

				for (int i = 0; i < viewers.length; i++) {
					if (!viewers[i].getControl().isDisposed()) {
						viewers[i].update(node, properties);
					}
					else {
						if (DEBUG) {
							System.out.println("   !!! skipped refreshing disposed viewer: " + viewers[i]); //$NON-NLS-1$
						}
					}
				}
			}
		});
	}

	/**
	 * This method also synchronized because it accesses the fRefreshes queue
	 * and fRefreshViewers list
	 * 
	 * @return an array containing and array of the currently requested Nodes
	 *         to refresh and the viewers in which to refresh them
	 */
	private synchronized Object[] getRefreshRequests() {
		Node[] toRefresh = (Node[]) fRefreshes.toArray(new Node[fRefreshes.size()]);
		fRefreshes.clear();

		StructuredViewer[] viewers = (StructuredViewer[]) fRefreshViewers.toArray(new StructuredViewer[fRefreshViewers.size()]);
		fRefreshViewers.clear();

		return new Object[]{toRefresh, viewers};
	}

	/**
	 * This method also synchronized because it accesses the fUpdates queue
	 * and fUpdateViewers list
	 * 
	 * @return an array containing and array of the currently requested Nodes
	 *         to refresh and the viewers in which to refresh them
	 */
	private synchronized Object[] getUpdateRequests() {
		Node[] toUpdate = (Node[]) fUpdates.toArray(new Node[fUpdates.size()]);
		fUpdates.clear();

		StructuredViewer[] viewers = (StructuredViewer[]) fUpdateViewers.toArray(new StructuredViewer[fUpdateViewers.size()]);
		fUpdateViewers.clear();

		String[][] properties = (String[][]) fUpdateProperties.toArray(new String[fUpdateProperties.size()][]);
		fUpdateProperties.clear();

		return new Object[]{toUpdate, viewers, properties};
	}

	/**
	 * Invoke a refresh on the viewer on the given node.
	 * 
	 * @param node
	 */
	public void refresh(StructuredViewer viewer, Node node) {
		if (node == null) {
			return;
		}

		addRefreshViewer(viewer);
		addRefreshRequest(node);
		schedule(UPDATE_DELAY);
	}

	/**
	 * Invoke a refresh on the viewer on the given node.
	 * 
	 * @param node
	 */
	public void update(StructuredViewer viewer, Node node, String[] properties) {
		if (node == null) {
			return;
		}

		addUpdateViewer(viewer);
		addUpdateRequest(node, properties);
		schedule(UPDATE_DELAY);
	}

	protected IStatus run(IProgressMonitor monitor) {
		IStatus status = Status.OK_STATUS;
		try {
			performUpdates();
			
			performRefreshes(monitor);
		}
		finally {
			monitor.done();
		}
		return status;
	}

	private void performRefreshes(IProgressMonitor monitor) {
		// Retrieve BOTH viewers and Nodes on one block
		Object[] requests = getRefreshRequests();
		Node[] nodes = (Node[]) requests[0];
		StructuredViewer[] viewers = (StructuredViewer[]) requests[1];

		for (int i = 0; i < nodes.length; i++) {
			if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}
			doRefresh(nodes[i], viewers);
		}
	}

	private void performUpdates() {
		// Retrieve BOTH viewers and Nodes on one block
		Object[] requests = getUpdateRequests();
		Node[] nodes = (Node[]) requests[0];
		StructuredViewer[] viewers = (StructuredViewer[]) requests[1];
		String[][] properties = (String[][]) requests[2];

		for (int i = 0; i < nodes.length; i++) {
			doUpdate(viewers, nodes[i], properties[i]);
		}
	}

}