/*
 * Copyright (C) 2007-2012 Argeo GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 org.argeo.eclipse.spring;

import static java.text.MessageFormat.format;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.core.runtime.Platform;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.util.tracker.ServiceTracker;
import org.springframework.context.ApplicationContext;

/**
 * Tracks Spring application context published as services.
 * 
 * @author Heiko Seeberger
 * @author Mathieu Baudier
 */
class ApplicationContextTracker {
	private final static Log log = LogFactory
			.getLog(ApplicationContextTracker.class);

	private static final String FILTER = "(&(objectClass=org.springframework.context.ApplicationContext)" //$NON-NLS-1$
			+ "(org.springframework.context.service.name={0}))"; //$NON-NLS-1$

	public final static String APPLICATION_CONTEXT_TRACKER_TIMEOUT = "org.argeo.eclipse.spring.applicationContextTrackerTimeout";

	private static Long defaultTimeout = Long.parseLong(System.getProperty(
			APPLICATION_CONTEXT_TRACKER_TIMEOUT, "30000"));

	@SuppressWarnings("rawtypes")
	private ServiceTracker applicationContextServiceTracker;

	/**
	 * @param contributorBundle
	 *            OSGi bundle for which the Spring application context is to be
	 *            tracked. Must not be null!
	 * @param factoryBundleContext
	 *            BundleContext object which can be used to track services
	 * @throws IllegalArgumentException
	 *             if the given bundle is null.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public ApplicationContextTracker(final Bundle contributorBundle,
			final BundleContext factoryBundleContext) {
		final String filter = format(FILTER,
				contributorBundle.getSymbolicName());
		try {
			applicationContextServiceTracker = new ServiceTracker(
					factoryBundleContext, FrameworkUtil.createFilter(filter),
					null);
			// applicationContextServiceTracker.open();
		} catch (final InvalidSyntaxException e) {
			e.printStackTrace();
		}
	}

	public void open() {
		if (applicationContextServiceTracker != null) {
			applicationContextServiceTracker.open();
		}
	}

	public void close() {
		if (applicationContextServiceTracker != null) {
			applicationContextServiceTracker.close();
		}
	}

	public ApplicationContext getApplicationContext() {
		ApplicationContext applicationContext = null;
		if (applicationContextServiceTracker != null) {
			try {
				applicationContext = (ApplicationContext) applicationContextServiceTracker
						.waitForService(defaultTimeout);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return applicationContext;
	}

	@Override
	protected void finalize() throws Throwable {
		close();
		super.finalize();
	}

	static ApplicationContext getApplicationContext(String bundleSymbolicName) {
		Bundle contributorBundle = Platform.getBundle(bundleSymbolicName);
		return getApplicationContext(contributorBundle);
	}

	static ApplicationContext getApplicationContext(
			final Bundle contributorBundle) {
		if (log.isTraceEnabled())
			log.trace("Get application context for bundle " + contributorBundle);

		// Start if not yet started (also if in STARTING state, may be lazy)
		if (contributorBundle.getState() != Bundle.ACTIVE) {
			if (log.isTraceEnabled())
				log.trace("Starting bundle: "
						+ contributorBundle.getSymbolicName());
			// Thread startBundle = new Thread("Start bundle "
			// + contributorBundle.getSymbolicName()) {
			// public void run() {
			try {
				contributorBundle.start();
			} catch (BundleException e) {
				log.error("Cannot start bundle " + contributorBundle, e);
			}
			// }
			// };
			// startBundle.start();
			// try {
			// startBundle.join(10 * 1000l);
			// } catch (InterruptedException e) {
			// // silent
			// }
		}

		final ApplicationContextTracker applicationContextTracker = new ApplicationContextTracker(
				contributorBundle, contributorBundle.getBundleContext());
		ApplicationContext applicationContext = null;
		try {
			applicationContextTracker.open();
			applicationContext = applicationContextTracker
					.getApplicationContext();
		} finally {
			applicationContextTracker.close();
		}
		return applicationContext;
	}
}