/*****************************************************************************
 * Copyright (c) 2015 Christian W. Damus 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:
 *   Christian W. Damus - Initial API and implementation
 *   
 *****************************************************************************/

package org.eclipse.papyrus.junit.utils;

import java.lang.annotation.Annotation;
import java.util.Map;

import org.junit.rules.TestRule;
import org.junit.runner.Description;

import com.google.common.collect.Maps;

/**
 * Utilities for working with the JUnit data model and execution environment.
 */
public class JUnitUtils {

	/**
	 * Not instantiable by clients.
	 */
	private JUnitUtils() {
		super();
	}

	/**
	 * Obtains the test class implied by a {@code description} that is supplied to a {@link TestRule}.
	 * 
	 * @param description
	 *            a rule's owning description, which generally would be a test method or a test class
	 *            (as these are the contexts in which rules are invoked)
	 * 
	 * @return the test class, or {@code null} in the unlikely event that none can be found
	 */
	public static Class<?> getTestClass(Description description) {
		Class<?> result = description.getTestClass();

		if (result == null) {
			for (Description child : description.getChildren()) {
				result = getTestClass(child);
				if (result != null) {
					break;
				}
			}
		}

		return result;
	}

	/**
	 * Obtains the annotations applied to a {@code description} that is supplied to a {@link TestRule}.
	 * If the description is for a test method, the annotations of its owning class are included,
	 * excepting annotations of the same type applied to the method.
	 * 
	 * @param description
	 *            a rule's owning description, which generally would be a test method or a test class
	 *            (as these are the contexts in which rules are invoked)
	 * 
	 * @return all of the annotations applied to the test description
	 */
	public static Iterable<Annotation> getAnnotations(Description description) {
		Map<Class<? extends Annotation>, Annotation> result = Maps.newLinkedHashMap();

		for (Annotation next : description.getAnnotations()) {
			result.put(next.annotationType(), next);
		}

		if (description.getTestClass() != null) {
			for (Annotation next : description.getTestClass().getAnnotations()) {
				if (!result.containsKey(next.annotationType())) {
					result.put(next.annotationType(), next);
				}
			}
		}

		return result.values();
	}

	/**
	 * Obtains the annotation of the specified {@code type} applicable to a {@code description} that is supplied to a {@link TestRule}.
	 * If the description is for a test method, then if that method doesn't have the requested annotation, its owning class is searched
	 * for the annotation.
	 * 
	 * @param description
	 *            a rule's owning description, which generally would be a test method or a test class
	 *            (as these are the contexts in which rules are invoked)
	 * @param type
	 *            the annotation type to look for
	 * 
	 * @return the requested annotation, or {@code null} if none was found
	 */
	public static <A extends Annotation> A getAnnotation(Description description, Class<A> type) {
		A result = description.getAnnotation(type);

		if ((result == null) && (description.getTestClass() != null)) {
			result = description.getTestClass().getAnnotation(type);
		}

		return result;
	}

	/**
	 * Obtains the annotation of any one of the specified {@code types} applicable to a {@code description} that is supplied to a {@link TestRule}.
	 * If the description is for a test method, then if that method doesn't have any of the requested annotations, its owning class is searched
	 * for the annotations.
	 * 
	 * @param description
	 *            a rule's owning description, which generally would be a test method or a test class
	 *            (as these are the contexts in which rules are invoked)
	 * @param types
	 *            the annotation types to look for
	 * 
	 * @return the first available of the requested annotations, or {@code null} if none was found
	 */
	@SafeVarargs
	public static Annotation getAnyAnnotation(Description description, final Class<? extends Annotation>... types) {
		Annotation result = null;

		for (Class<? extends Annotation> next : types) {
			result = description.getAnnotation(next);
			if (result != null) {
				break;
			}
		}

		if (result == null) {
			out: for (Class<?> testClass = description.getTestClass(); testClass != null; testClass = testClass.getSuperclass()) {
				for (Class<? extends Annotation> next : types) {
					result = testClass.getAnnotation(next);
					if (result != null) {
						break out;
					}
				}
			}
		}

		return result;
	}

	/**
	 * Queries whether the current JUnit test execution is running in the automated build environment
	 * (whether actually on the build server or not; users can run local builds on their development systems, too).
	 * 
	 * @return whether the tests are running in the automated build environment
	 */
	public static boolean isAutomatedBuildExecution() {
		return Activator.getDefault().getRunningApplicationID().startsWith("org.eclipse.tycho."); //$NON-NLS-1$
	}
}