/*******************************************************************************
 * Copyright (c) 2000, 2018 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.unittest.internal.ui;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

import org.eclipse.unittest.internal.UnitTestPlugin;
import org.eclipse.unittest.internal.model.Status;
import org.eclipse.unittest.internal.model.TestCaseElement;
import org.eclipse.unittest.internal.model.TestElement;
import org.eclipse.unittest.internal.model.TestRunSession;
import org.eclipse.unittest.internal.model.TestSuiteElement;
import org.eclipse.unittest.internal.ui.TestRunnerViewPart.TestResultsLayout;
import org.eclipse.unittest.model.ITestCaseElement;
import org.eclipse.unittest.model.ITestElement;
import org.eclipse.unittest.model.ITestElement.Result;
import org.eclipse.unittest.model.ITestRunSession;
import org.eclipse.unittest.model.ITestSuiteElement;

import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.TableItem;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.part.PageBook;

import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;

/**
 * A Test Viewer implementation
 */
class TestViewer {

	private final class TestSelectionListener implements ISelectionChangedListener {
		@Override
		public void selectionChanged(SelectionChangedEvent event) {
			IStructuredSelection selection = (IStructuredSelection) fSelectionProvider.getSelection();
			TestElement testElement = null;
			if (selection.size() == 1) {
				testElement = (TestElement) selection.getFirstElement();
			}
			fTestRunnerPart.handleTestSelected(testElement);
		}
	}

	private final class TestOpenListener extends SelectionAdapter {
		@Override
		public void widgetDefaultSelected(SelectionEvent e) {
			handleDefaultSelected();
		}
	}

	private final class FailuresOnlyFilter extends ViewerFilter {
		@Override
		public boolean select(Viewer viewer, Object parentElement, Object element) {
			return select(((TestElement) element));
		}

		public boolean select(TestElement testElement) {
			Status status = testElement.getStatus();
			if (status.isErrorOrFailure())
				return true;
			else
				return !fTestRunSession.isRunning() && status == Status.RUNNING; // rerunning
		}
	}

	private final class IgnoredOnlyFilter extends ViewerFilter {
		@Override
		public boolean select(Viewer viewer, Object parentElement, Object element) {
			return select(((TestElement) element));
		}

		public boolean select(TestElement testElement) {
			if (hasIgnoredInTestResult(testElement))
				return true;
			else
				return !fTestRunSession.isRunning() && testElement.getStatus() == Status.RUNNING; // rerunning
		}

		/**
		 * Checks whether a test was skipped i.e. it was ignored (<code>@Ignored</code>)
		 * or had any assumption failure.
		 *
		 * @param testElement the test element (a test suite or a single test case)
		 *
		 * @return <code>true</code> if the test element or any of its children has
		 *         {@link Result#IGNORED} test result
		 */
		private boolean hasIgnoredInTestResult(TestElement testElement) {
			if (testElement instanceof TestSuiteElement) {
				List<TestElement> children = ((TestSuiteElement) testElement).getChildren();
				for (TestElement child : children) {
					boolean hasIgnoredTestResult = hasIgnoredInTestResult(child);
					if (hasIgnoredTestResult) {
						return true;
					}
				}
				return false;
			}

			return testElement.getTestResult(false) == Result.IGNORED;
		}
	}

	private static class ReverseList<E> extends AbstractList<E> {
		private final List<E> fList;

		public ReverseList(List<E> list) {
			fList = list;
		}

		@Override
		public E get(int index) {
			return fList.get(fList.size() - index - 1);
		}

		@Override
		public int size() {
			return fList.size();
		}
	}

	private class ExpandAllAction extends Action {
		public ExpandAllAction() {
			setText(Messages.ExpandAllAction_text);
			setToolTipText(Messages.ExpandAllAction_tooltip);
		}

		@Override
		public void run() {
			fTreeViewer.expandAll();
		}
	}

	private class CollapseAllAction extends Action {
		public CollapseAllAction() {
			setText(Messages.CollapseAllAction_text);
			setToolTipText(Messages.CollapseAllAction_tooltip);
		}

		@Override
		public void run() {
			fTreeViewer.collapseAll();
		}
	}

	/**
	 * Compares two {@link TestElement}s: - {@link TestSuiteElement}s are placed on
	 * top of {@link TestCaseElement}s - TestElements are alphabetically ordered(by
	 * their names)
	 */
	private static final ViewerComparator TEST_ELEMENT_ALPHABETIC_ORDER = new ViewerComparator() {
		@Override
		public int compare(Viewer viewer, Object e1, Object e2) {
			// Show test suites on top of test messages
			int weight1 = (e1 instanceof ITestSuiteElement) ? 0 : 1;
			int weight2 = (e2 instanceof ITestSuiteElement) ? 0 : 1;
			if (weight1 != weight2) {
				return weight1 - weight2;
			}
			// Compare by element names
			return ((TestElement) e1).getTestName().compareTo(((TestElement) e2).getTestName());
		}
	};

	private final FailuresOnlyFilter fFailuresOnlyFilter = new FailuresOnlyFilter();
	private final IgnoredOnlyFilter fIgnoredOnlyFilter = new IgnoredOnlyFilter();

	private final TestRunnerViewPart fTestRunnerPart;
	private final Clipboard fClipboard;

	private PageBook fViewerbook;
	private TreeViewer fTreeViewer;
	private TestSessionTreeContentProvider fTreeContentProvider;
	private TestSessionLabelProvider fTreeLabelProvider;
	private TableViewer fTableViewer;
	private TestSessionLabelProvider fTableLabelProvider;
	private SelectionProviderMediator fSelectionProvider;

	private TestResultsLayout fLayoutMode;
	private boolean fTreeHasFilter;
	private boolean fTableHasFilter;

	private TestRunSession fTestRunSession;

	private boolean fTreeNeedsRefresh;
	private boolean fTableNeedsRefresh;
	private HashSet<ITestElement> fNeedUpdate;
	private ITestCaseElement fAutoScrollTarget;

	private LinkedList<ITestSuiteElement> fAutoClose;
	private HashSet<ITestSuiteElement> fAutoExpand;

	/**
	 * Constructs a Test Viewer object
	 *
	 * @param parent    a parent composite
	 * @param clipboard a {@link Clipboard} instance
	 * @param runner    a Test Runner view part
	 */
	public TestViewer(Composite parent, Clipboard clipboard, TestRunnerViewPart runner) {
		fTestRunnerPart = runner;
		fClipboard = clipboard;

		fLayoutMode = TestRunnerViewPart.TestResultsLayout.HIERARCHICAL;

		createTestViewers(parent);

		registerViewersRefresh();

		initContextMenu();
	}

	private void createTestViewers(Composite parent) {
		fViewerbook = new PageBook(parent, SWT.NULL);

		fTreeViewer = new TreeViewer(fViewerbook, SWT.V_SCROLL | SWT.SINGLE);
		fTreeViewer.setUseHashlookup(true);
		fTreeContentProvider = new TestSessionTreeContentProvider();
		fTreeViewer.setContentProvider(fTreeContentProvider);
		fTreeLabelProvider = new TestSessionLabelProvider(fTestRunnerPart,
				TestRunnerViewPart.TestResultsLayout.HIERARCHICAL);
//		fTreeViewer.setLabelProvider(new ColoringLabelProvider(fTreeLabelProvider));
		fTreeViewer.setLabelProvider(fTreeLabelProvider);

		fTableViewer = new TableViewer(fViewerbook, SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE);
		fTableViewer.setUseHashlookup(true);
		TestSessionTableContentProvider fTableContentProvider = new TestSessionTableContentProvider();
		fTableViewer.setContentProvider(fTableContentProvider);
		fTableLabelProvider = new TestSessionLabelProvider(fTestRunnerPart, TestRunnerViewPart.TestResultsLayout.FLAT);
//		fTableViewer.setLabelProvider(new ColoringLabelProvider(fTableLabelProvider));
		fTableViewer.setLabelProvider(fTableLabelProvider);

		fSelectionProvider = new SelectionProviderMediator(new StructuredViewer[] { fTreeViewer, fTableViewer },
				fTreeViewer);
		fSelectionProvider.addSelectionChangedListener(new TestSelectionListener());
		TestOpenListener testOpenListener = new TestOpenListener();
		fTreeViewer.getTree().addSelectionListener(testOpenListener);
		fTableViewer.getTable().addSelectionListener(testOpenListener);

		fTestRunnerPart.getSite().setSelectionProvider(fSelectionProvider);

		fViewerbook.showPage(fTreeViewer.getTree());
	}

	private void initContextMenu() {
		MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(this::handleMenuAboutToShow);
		fTestRunnerPart.getSite().registerContextMenu(menuMgr, fSelectionProvider);
		Menu menu = menuMgr.createContextMenu(fViewerbook);
		fTreeViewer.getTree().setMenu(menu);
		fTableViewer.getTable().setMenu(menu);
	}

	void handleMenuAboutToShow(IMenuManager manager) {
		IStructuredSelection selection = (IStructuredSelection) fSelectionProvider.getSelection();
		if (!selection.isEmpty()) {
			TestElement testElement = (TestElement) selection.getFirstElement();

			if (testElement instanceof TestSuiteElement) {
				TestSuiteElement testSuiteElement = (TestSuiteElement) testElement;
				IAction openTestAction = testSuiteElement.getTestRunSession().getTestViewSupport()
						.getOpenTestAction(fTestRunnerPart.getSite().getShell(), testSuiteElement);
				if (openTestAction != null) {
					manager.add(openTestAction);
				}
				manager.add(new Separator());
				if (!fTestRunnerPart.lastLaunchStillRunning()) {
					addRerunActions(manager, testSuiteElement);
				}
			} else {
				TestCaseElement testCaseElement = (TestCaseElement) testElement;
				IAction openTestAction = testElement.getTestRunSession().getTestViewSupport()
						.getOpenTestAction(fTestRunnerPart.getSite().getShell(), testCaseElement);
				if (openTestAction != null) {
					manager.add(openTestAction);
				}
				manager.add(new Separator());
				addRerunActions(manager, testCaseElement);
			}
			if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL) {
				manager.add(new Separator());
				manager.add(new ExpandAllAction());
				manager.add(new CollapseAllAction());
			}

		}
		if (fTestRunSession != null
				&& fTestRunSession.getCurrentFailureCount() + fTestRunSession.getCurrentErrorCount() > 0) {
			if (fLayoutMode != TestRunnerViewPart.TestResultsLayout.HIERARCHICAL) {
				manager.add(new Separator());
			}
			manager.add(new CopyFailureListAction(fTestRunnerPart, fClipboard));
		}
		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS + "-end")); //$NON-NLS-1$
	}

	private void addRerunActions(IMenuManager manager, TestElement testCaseElement) {
		ILaunchConfiguration rerunLaunchConfiguration = testCaseElement.getTestRunSession().getTestViewSupport()
				.getRerunLaunchConfiguration(Collections.singletonList(testCaseElement));
		if (rerunLaunchConfiguration == null) {
			return;
		}
		if (fTestRunnerPart.lastLaunchStillRunning()) {
			manager.add(new RerunAction(rerunLaunchConfiguration, ILaunchManager.RUN_MODE));
		} else {
			try {
				rerunLaunchConfiguration.getType().getSupportedModeCombinations().stream() //
						.filter(modes -> modes.size() == 1) //
						.flatMap(Collection::stream) //
						.forEach(mode -> manager.add(new RerunAction(rerunLaunchConfiguration, mode)));
			} catch (CoreException e) {
				UnitTestPlugin.log(e);
			}
		}
	}

	/**
	 * Returns the tree viewer control
	 *
	 * @return tree viewer control object
	 */
	public Control getTestViewerControl() {
		return fViewerbook;
	}

	/**
	 * Registers a given active test session
	 *
	 * @param testRunSession a test session object
	 */
	public synchronized void registerActiveSession(TestRunSession testRunSession) {
		fTestRunSession = testRunSession;
		registerAutoScrollTarget(null);
		registerViewersRefresh();
	}

	void handleDefaultSelected() {
		IStructuredSelection selection = (IStructuredSelection) fSelectionProvider.getSelection();
		if (selection.size() != 1)
			return;

		TestElement testElement = (TestElement) selection.getFirstElement();
		IAction action;
		if (testElement instanceof ITestSuiteElement) {
			action = testElement.getTestRunSession().getTestViewSupport()
					.getOpenTestAction(fTestRunnerPart.getSite().getShell(), (ITestSuiteElement) testElement);
		} else if (testElement instanceof ITestCaseElement) {
			action = testElement.getTestRunSession().getTestViewSupport()
					.getOpenTestAction(fTestRunnerPart.getSite().getShell(), (ITestCaseElement) testElement);
		} else {
			throw new IllegalStateException(String.valueOf(testElement));
		}

		if (action != null && action.isEnabled())
			action.run();
	}

	/**
	 * Tunes the label providers to show time on the generated labels
	 *
	 * @param showTime <code>true</code> in case a time value is to be shown,
	 *                 otherwise - <code>false</code>
	 */
	public synchronized void setShowTime(boolean showTime) {
		try {
			fViewerbook.setRedraw(false);
			fTreeLabelProvider.setShowTime(showTime);
			fTableLabelProvider.setShowTime(showTime);
		} finally {
			fViewerbook.setRedraw(true);
		}
	}

	/**
	 * It makes sense to display either failed or ignored tests, not both together.
	 *
	 * @param failuresOnly whether to show only failed tests
	 * @param ignoredOnly  whether to show only skipped tests
	 * @param layoutMode   the layout mode
	 */
	public synchronized void setShowFailuresOrIgnoredOnly(boolean failuresOnly, boolean ignoredOnly,
			TestResultsLayout layoutMode) {
		/*
		 * Management of fTreeViewer and fTableViewer
		 * ****************************************** - invisible viewer is updated on
		 * registerViewerUpdate unless its f*NeedsRefresh is true - invisible viewer is
		 * not refreshed upfront - on layout change, new viewer is refreshed if
		 * necessary - filter only applies to "current" layout mode / viewer
		 */
		try {
			fViewerbook.setRedraw(false);

			IStructuredSelection selection = null;
			boolean switchLayout = layoutMode != fLayoutMode;
			if (switchLayout) {
				selection = (IStructuredSelection) fSelectionProvider.getSelection();
				if (layoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL) {
					if (fTreeNeedsRefresh) {
						clearUpdateAndExpansion();
					}
				} else {
					if (fTableNeedsRefresh) {
						clearUpdateAndExpansion();
					}
				}
				fLayoutMode = layoutMode;
				fViewerbook.showPage(getActiveViewer().getControl());
			}
			// avoid realizing all TableItems, especially in flat mode!
			StructuredViewer viewer = getActiveViewer();
			if (failuresOnly || ignoredOnly) {
				if (getActiveViewerHasFilter()) {
					// For simplicity clear both filters (only one of them is used)
					viewer.removeFilter(fFailuresOnlyFilter);
					viewer.removeFilter(fIgnoredOnlyFilter);
				}
				setActiveViewerHasFilter(true);
				viewer.setInput(null);
				// Set either the failures or the skipped tests filter
				ViewerFilter filter = fFailuresOnlyFilter;
				if (ignoredOnly == true) {
					filter = fIgnoredOnlyFilter;
				}
				viewer.addFilter(filter);
				setActiveViewerNeedsRefresh(true);

			} else {
				if (getActiveViewerHasFilter()) {
					setActiveViewerNeedsRefresh(true);
					setActiveViewerHasFilter(false);
					viewer.setInput(null);
					viewer.removeFilter(fIgnoredOnlyFilter);
					viewer.removeFilter(fFailuresOnlyFilter);
				}
			}
			processChangesInUI();

			if (selection != null) {
				// workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=125708
				// (ITreeSelection not adapted if TreePaths changed):
				StructuredSelection flatSelection = new StructuredSelection(selection.toList());
				fSelectionProvider.setSelection(flatSelection, true);
			}

		} finally {
			fViewerbook.setRedraw(true);
		}
	}

	private boolean getActiveViewerHasFilter() {
		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL)
			return fTreeHasFilter;
		else
			return fTableHasFilter;
	}

	private void setActiveViewerHasFilter(boolean filter) {
		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL)
			fTreeHasFilter = filter;
		else
			fTableHasFilter = filter;
	}

	private StructuredViewer getActiveViewer() {
		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL)
			return fTreeViewer;
		else
			return fTableViewer;
	}

	private boolean getActiveViewerNeedsRefresh() {
		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL)
			return fTreeNeedsRefresh;
		else
			return fTableNeedsRefresh;
	}

	private void setActiveViewerNeedsRefresh(boolean needsRefresh) {
		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.HIERARCHICAL)
			fTreeNeedsRefresh = needsRefresh;
		else
			fTableNeedsRefresh = needsRefresh;
	}

	/**
	 * To be called periodically by the TestRunnerViewPart (in the UI thread).
	 */
	public void processChangesInUI() {
		if (fTestRunSession == null) {
			registerViewersRefresh();
			fTreeNeedsRefresh = false;
			fTableNeedsRefresh = false;
			fTreeViewer.setInput(null);
			fTableViewer.setInput(null);
			return;
		}

		StructuredViewer viewer = getActiveViewer();
		if (getActiveViewerNeedsRefresh()) {
			clearUpdateAndExpansion();
			setActiveViewerNeedsRefresh(false);
			viewer.setInput(fTestRunnerPart);
		} else {
			Object[] toUpdate;
			synchronized (this) {
				toUpdate = fNeedUpdate.toArray();
				fNeedUpdate.clear();
			}
			if (!fTreeNeedsRefresh && toUpdate.length > 0) {
				if (fTreeHasFilter)
					for (Object element : toUpdate)
						updateElementInTree((TestElement) element);
				else {
					HashSet<Object> toUpdateWithParents = new HashSet<>();
					toUpdateWithParents.addAll(Arrays.asList(toUpdate));
					for (Object element : toUpdate) {
						ITestElement parent = ((ITestElement) element).getParent();
						while (parent != null) {
							toUpdateWithParents.add(parent);
							parent = parent.getParent();
						}
					}
					fTreeViewer.update(toUpdateWithParents.toArray(), null);
				}
			}
			if (!fTableNeedsRefresh && toUpdate.length > 0) {
				if (fTableHasFilter)
					for (Object element : toUpdate)
						updateElementInTable((TestElement) element);
				else
					fTableViewer.update(toUpdate, null);
			}
		}
		autoScrollInUI();
	}

	private void updateElementInTree(final TestElement testElement) {
		if (isShown(testElement)) {
			updateShownElementInTree(testElement);
		} else {
			TestElement current = testElement;
			do {
				if (fTreeViewer.testFindItem(current) != null)
					fTreeViewer.remove(current);
				current = current.getParent();
			} while (!(current instanceof ITestRunSession) && !isShown(current));

			while (current != null && !(current instanceof ITestRunSession)) {
				fTreeViewer.update(current, null);
				current = current.getParent();
			}
		}
	}

	private void updateShownElementInTree(ITestElement testElement) {
		if (testElement == null || testElement instanceof ITestRunSession) // paranoia null check
			return;

		ITestSuiteElement parent = testElement.getParent();
		updateShownElementInTree(parent); // make sure parent is shown and up-to-date

		if (fTreeViewer.testFindItem(testElement) == null) {
			fTreeViewer.add(parent, testElement); // if not yet in tree: add
		} else {
			fTreeViewer.update(testElement, null); // if in tree: update
		}
	}

	private void updateElementInTable(TestElement element) {
		if (isShown(element)) {
			if (fTableViewer.testFindItem(element) == null) {
				TestElement previous = getNextFailure(element, false);
				int insertionIndex = -1;
				if (previous != null) {
					TableItem item = (TableItem) fTableViewer.testFindItem(previous);
					if (item != null)
						insertionIndex = fTableViewer.getTable().indexOf(item);
				}
				fTableViewer.insert(element, insertionIndex);
			} else {
				fTableViewer.update(element, null);
			}
		} else {
			fTableViewer.remove(element);
		}
	}

	private boolean isShown(TestElement current) {
		return fFailuresOnlyFilter.select(current);
	}

	private void autoScrollInUI() {
		if (!fTestRunnerPart.isAutoScroll()) {
			clearAutoExpand();
			fAutoClose.clear();
			return;
		}

		if (fLayoutMode == TestRunnerViewPart.TestResultsLayout.FLAT) {
			if (fAutoScrollTarget != null)
				fTableViewer.reveal(fAutoScrollTarget);
			return;
		}

		synchronized (this) {
			for (ITestSuiteElement suite : fAutoExpand) {
				fTreeViewer.setExpandedState(suite, true);
			}
			clearAutoExpand();
		}

		ITestCaseElement current = fAutoScrollTarget;
		fAutoScrollTarget = null;

		ITestSuiteElement parent = current == null ? null : (ITestSuiteElement) fTreeContentProvider.getParent(current);
		if (fAutoClose.isEmpty() || !fAutoClose.getLast().equals(parent)) {
			// we're in a new branch, so let's close old OK branches:
			for (ListIterator<ITestSuiteElement> iter = fAutoClose.listIterator(fAutoClose.size()); iter
					.hasPrevious();) {
				ITestSuiteElement previousAutoOpened = iter.previous();
				if (previousAutoOpened.equals(parent))
					break;

				if (((TestElement) previousAutoOpened).getStatus() == Status.OK) {
					// auto-opened the element, and all children are OK -> auto close
					iter.remove();
					fTreeViewer.collapseToLevel(previousAutoOpened, AbstractTreeViewer.ALL_LEVELS);
				}
			}

			while (parent != null && !fTestRunSession.equals(parent) && fTreeViewer.getExpandedState(parent) == false) {
				fAutoClose.add(parent); // add to auto-opened elements -> close later if STATUS_OK
				parent = (ITestSuiteElement) fTreeContentProvider.getParent(parent);
			}
		}
		if (current != null)
			fTreeViewer.reveal(current);
	}

	/**
	 * Selects the next failure test element
	 */
	public void selectFirstFailure() {
		ITestElement firstFailure = getNextChildFailure(fTestRunSession, true);
		if (firstFailure != null)
			getActiveViewer().setSelection(new StructuredSelection(firstFailure), true);
	}

	/**
	 * Selects a next failure test element
	 *
	 * @param showNext <code>true</code> if a next failed element is to be shown,
	 *                 otherwise - <code>false</code>
	 */
	public void selectFailure(boolean showNext) {
		IStructuredSelection selection = (IStructuredSelection) getActiveViewer().getSelection();
		TestElement selected = (TestElement) selection.getFirstElement();
		ITestElement next;

		if (selected == null) {
			next = getNextChildFailure(fTestRunSession, showNext);
		} else {
			next = getNextFailure(selected, showNext);
		}

		if (next != null)
			getActiveViewer().setSelection(new StructuredSelection(next), true);
	}

	private TestElement getNextFailure(TestElement selected, boolean showNext) {
		if (selected instanceof TestSuiteElement) {
			TestElement nextChild = getNextChildFailure((TestSuiteElement) selected, showNext);
			if (nextChild != null)
				return nextChild;
		}
		return getNextFailureSibling(selected, showNext);
	}

	private TestElement getNextFailureSibling(TestElement current, boolean showNext) {
		TestSuiteElement parent = current.getParent();
		if (parent == null)
			return null;

		List<TestElement> siblings = getSortedChildren(parent);
		if (!showNext)
			siblings = new ReverseList<>(siblings);

		int nextIndex = siblings.indexOf(current) + 1;
		for (int i = nextIndex; i < siblings.size(); i++) {
			TestElement sibling = siblings.get(i);
			if (sibling.getStatus().isErrorOrFailure()) {
				if (sibling instanceof ITestCaseElement) {
					return sibling;
				} else {
					TestSuiteElement testSuiteElement = (TestSuiteElement) sibling;
					if (testSuiteElement.getChildren().isEmpty()) {
						return testSuiteElement;
					}
					return getNextChildFailure(testSuiteElement, showNext);
				}
			}
		}
		return getNextFailureSibling(parent, showNext);
	}

	private TestElement getNextChildFailure(TestSuiteElement root, boolean showNext) {
		List<TestElement> children = getSortedChildren(root);
		if (!showNext)
			children = new ReverseList<>(children);
		for (TestElement child : children) {
			if (child.getStatus().isErrorOrFailure()) {
				if (child instanceof ITestCaseElement) {
					return child;
				} else {
					TestSuiteElement testSuiteElement = (TestSuiteElement) child;
					if (testSuiteElement.getChildren().isEmpty()) {
						return testSuiteElement;
					}
					return getNextChildFailure(testSuiteElement, showNext);
				}
			}
		}
		return null;
	}

	private List<TestElement> getSortedChildren(TestSuiteElement parent) {
		List<TestElement> siblings = new ArrayList<>(parent.getChildren());
		ViewerComparator comparator = fTreeViewer.getComparator();
		if (comparator != null) {
			siblings.sort((e1, e2) -> comparator.compare(fTreeViewer, e1, e2));
		}
		return siblings;
	}

	/**
	 * Initializes a viewers refresh
	 */
	public synchronized void registerViewersRefresh() {
		fTreeNeedsRefresh = true;
		fTableNeedsRefresh = true;
		clearUpdateAndExpansion();
	}

	private void clearUpdateAndExpansion() {
		fNeedUpdate = new LinkedHashSet<>();
		fAutoClose = new LinkedList<>();
		fAutoExpand = new HashSet<>();
	}

	/**
	 * Registers a test element
	 *
	 * @param testElement the added test
	 */
	public synchronized void registerTestAdded(ITestElement testElement) {
		// TODO: performance: would only need to refresh parent of added element
		fTreeNeedsRefresh = true;
		fTableNeedsRefresh = true;
	}

	/**
	 * Initializes an update for a test element
	 *
	 * @param testElement a test element that needs to be updated
	 */
	public synchronized void registerViewerUpdate(final ITestElement testElement) {
		fNeedUpdate.add(testElement);
	}

	private synchronized void clearAutoExpand() {
		fAutoExpand.clear();
	}

	/**
	 * Registers an auto-scroll target test case element
	 *
	 * @param testCaseElement a test case element
	 */
	public void registerAutoScrollTarget(ITestCaseElement testCaseElement) {
		fAutoScrollTarget = testCaseElement;
	}

	/**
	 * Registers a failed test element for an auto-scroll
	 *
	 * @param testElement a failed test element
	 */
	public synchronized void registerFailedForAutoScroll(ITestElement testElement) {
		ITestSuiteElement parent = (TestSuiteElement) fTreeContentProvider.getParent(testElement);
		if (parent != null)
			fAutoExpand.add(parent);
	}

	/**
	 * Expands the test element tree first level
	 */
	public void expandFirstLevel() {
		fTreeViewer.expandToLevel(2);
	}

	/**
	 * Sets up an alphabetical sort flag
	 *
	 * @param enableAlphabeticalSort <code>true</code> if an alphabetical sort is
	 *                               enabled, otherwise <code>false</code>
	 */
	public void setAlphabeticalSort(boolean enableAlphabeticalSort) {
		fTreeViewer.setComparator(enableAlphabeticalSort ? TEST_ELEMENT_ALPHABETIC_ORDER : null);
		fTreeViewer.refresh();
	}

	/**
	 * Indicates if an alphabetical sort is enabled
	 *
	 * @return <code>true</code> if an alphabetical sort is enabled, otherwise
	 *         <code>false</code>
	 */
	public boolean isAlphabeticalSort() {
		return fTreeViewer.getComparator() == TEST_ELEMENT_ALPHABETIC_ORDER;
	}
}