/******************************************************************************
 * Copyright (c) 2006, 2010 VMware Inc., Oracle Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution. 
 * The Eclipse Public License is available at 
 * http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
 * is available at http://www.opensource.org/licenses/apache2.0.php.
 * You may elect to redistribute this code under either of these licenses. 
 * 
 * Contributors:
 *   VMware Inc.
 *   Oracle Inc.
 *****************************************************************************/

package org.eclipse.gemini.blueprint.extender.internal.dependencies.shutdown;

import java.io.Serializable;
import java.util.Comparator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceReference;
import org.eclipse.gemini.blueprint.context.ConfigurableOsgiBundleApplicationContext;
import org.eclipse.gemini.blueprint.service.exporter.OsgiServicePropertiesResolver;
import org.eclipse.gemini.blueprint.util.OsgiServiceReferenceUtils;
import org.springframework.util.ObjectUtils;

/**
 * Null safe service-based dependency sorter for bundles. Sorts bundles based on their services using the following
 * algorithm: <p/> <ol> <li> if two bundles are connected (transitively) then the bundle that exports the service with
 * lowest ranking id, will be considered lower. </li> <li> if the ranks are equal, then the service id (which is
 * guaranteed to be unique) will be considered. </li> <li> if the bundles are not related then they will be sorted based
 * on their symbolic name. </li> </ol>
 * 
 * @author Hal Hildebrand
 * @author Andy Piper
 * @author Costin Leau
 */
public class BundleDependencyComparator implements Comparator, Serializable {

	private static final long serialVersionUID = -108354908478230663L;

	private static final Log log = LogFactory.getLog(BundleDependencyComparator.class);

	/**
	 * Simple method checking whether the given service reference points to a spring managed service or not. Checks for
	 * 
	 * @param reference reference to the OSGi service
	 * @return true if the service is spring managed, false otherwise
	 */
	public static boolean isSpringManagedService(ServiceReference reference) {
		if (reference == null)
			return false;
		return (reference.getProperty(OsgiServicePropertiesResolver.BEAN_NAME_PROPERTY_KEY) != null ||
				reference.getProperty(OsgiServicePropertiesResolver.SPRING_DM_BEAN_NAME_PROPERTY_KEY) != null
				|| reference.getProperty(ConfigurableOsgiBundleApplicationContext.APPLICATION_CONTEXT_SERVICE_PROPERTY_NAME) != null 
				|| reference.getProperty(ConfigurableOsgiBundleApplicationContext.SPRING_DM_APPLICATION_CONTEXT_SERVICE_PROPERTY_NAME) != null);
	}

	private static ServiceReference[] excludeNonSpringManagedServices(ServiceReference[] references) {
		if (ObjectUtils.isEmpty(references))
			return references;

		int count = 0;
		for (int i = 0; i < references.length; i++) {
			if (!isSpringManagedService(references[i]))
				references[i] = null;
			else
				count++;
		}

		if (count == references.length)
			return references;

		ServiceReference[] refs = new ServiceReference[count];
		int j = 0;
		for (int i = 0; i < references.length; i++) {
			if (references[i] != null) {
				refs[j] = references[i];
				j++;
			}
		}

		return refs;
	}

	/**
	 * Answer whether Bundle a is higher or lower depending on the ranking and id of its exported services. This is used
	 * as a tie-breaker for circular references.
	 */
	protected static int compareUsingServiceRankingAndId(Bundle a, Bundle b) {
		ServiceReference[] aservices = excludeNonSpringManagedServices(a.getRegisteredServices());
		ServiceReference[] bservices = excludeNonSpringManagedServices(b.getRegisteredServices());

		boolean trace = log.isTraceEnabled();

		// this case should not occur
		if (ObjectUtils.isEmpty(aservices) && ObjectUtils.isEmpty(bservices)) {
			if (trace)
				log.trace("both services have 0 services; sorting based on id");
			return signum((int) (a.getBundleId() - b.getBundleId()));
		} else if (aservices == null) {
			return -1;
		} else if (bservices == null) {
			return 1;
		}

		// Look for the *lowest* highest ranked service in each bundle
		// i.e. take a look at each bundle, find the highest ranking service
		// and compare it to the other bundle
		// this means that the service with the highest ranking service will
		// be shutdown last

		int aRank = findHighestServiceRanking(aservices);
		int bRank = findHighestServiceRanking(bservices);

		// since we are looking for the minimum, invert the substraction
		// (the higher bundle is the one with the lowest rank)
		if (aRank != bRank) {
			int compare = -(bRank - aRank);
			if (trace) {
				int min = (compare > 0 ? (int) bRank : (int) aRank);
				log.trace("sorting based on lowest-service-ranking won by bundle" + (compare > 0 ? "1" : "2")
						+ " w/ service id " + min);
			}

			return signum(-(bRank - aRank));
		}

		// Look for the highest id in each bundle (i.e. started last).
		long aMaxId = findHighestServiceId(aservices);
		long bMaxId = findHighestServiceId(bservices);

		if (aMaxId != bMaxId) {
			int compare = (int) (bMaxId - aMaxId);
			if (trace) {
				int max = (compare > 0 ? (int) bMaxId : (int) aMaxId);
				log.trace("sorting based on highest-service-id won by bundle " + (compare > 0 ? "1" : "2")
						+ " w/ service id " + max);
			}

			return signum(compare);
		}

		return signum((int) (a.getBundleId() - b.getBundleId()));
	}

	/**
	 * Find the highest service ranking. This might come as unexpected however, since a bundle can export multiple
	 * services, we have to find the minimum between the maximum services in each bundle - i.e. the bundle with the
	 * highest service ranking will win.
	 * 
	 * @param refs
	 */
	private static int findHighestServiceRanking(ServiceReference[] refs) {
		int maxRank = Integer.MIN_VALUE;
		for (int i = 0; i < refs.length; i++) {
			int currentRank = OsgiServiceReferenceUtils.getServiceRanking(refs[i]);
			if (currentRank > maxRank)
				maxRank = currentRank;
		}

		return maxRank;
	}

	private static long findHighestServiceId(ServiceReference[] refs) {
		long maxId = Long.MIN_VALUE;
		for (int i = 0; i < refs.length; i++) {
			long currentId = OsgiServiceReferenceUtils.getServiceId(refs[i]);
			if (currentId > maxId)
				maxId = currentId;
		}

		return maxId;
	}

	private static int signum(int a) {
		return a < 0 ? -1 : a == 0 ? 0 : 1;
	}

	public int compare(Object a, Object b) {
		return compareUsingServiceRankingAndId((Bundle) a, (Bundle) b);
	}
}