/*******************************************************************************
 * Copyright (c) 2010-2011 Composent, Inc. 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:
 *   Composent, Inc. - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.internal.osgi.services.remoteserviceadmin;

import java.util.ArrayList;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.UUID;

import javax.xml.parsers.SAXParserFactory;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.ecf.core.ContainerFactory;
import org.eclipse.ecf.core.ContainerTypeDescription;
import org.eclipse.ecf.core.IContainerManager;
import org.eclipse.ecf.core.util.LogHelper;
import org.eclipse.ecf.core.util.SystemLogService;
import org.eclipse.ecf.osgi.services.remoteserviceadmin.EndpointDescriptionLocator;
import org.eclipse.ecf.osgi.services.remoteserviceadmin.IServiceInfoFactory;
import org.eclipse.ecf.osgi.services.remoteserviceadmin.RemoteServiceAdmin;
import org.eclipse.ecf.osgi.services.remoteserviceadmin.ServiceInfoFactory;
import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceFactory;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.framework.Version;
import org.osgi.service.log.LogService;
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;

public class Activator implements BundleActivator {

	public static final String PLUGIN_ID = "org.eclipse.ecf.osgi.services.remoteserviceadmin"; //$NON-NLS-1$

	private static BundleContext context;
	private static Activator instance;

	public static BundleContext getContext() {
		return context;
	}

	public static Activator getDefault() {
		return instance;
	}

	public IContainerManager getContainerManager() {
		return (IContainerManager) ContainerFactory.getDefault();
	}

	private ServiceRegistration remoteServiceAdminRegistration;
	private Dictionary rsaProps;
	private ServiceTracker<ContainerTypeDescription,ContainerTypeDescription> ctdTracker;
	
	private EndpointDescriptionLocator endpointDescriptionLocator;
	private ServiceRegistration<?> iServiceInfoFactoryRegistration;

	// Logging
	private ServiceTracker logServiceTracker = null;
	private LogService logService = null;
	private Object logServiceTrackerLock = new Object();
	// Sax parser
	private Object saxParserFactoryTrackerLock = new Object();
	private ServiceTracker saxParserFactoryTracker;

	private static final String RSA_PROXY_BUNDLE_SYMBOLIC_ID = "org.eclipse.ecf.osgi.services.remoteserviceadmin.proxy"; //$NON-NLS-1$

	private BundleContext proxyServiceFactoryBundleContext;

	private void initializeProxyServiceFactoryBundle() throws Exception {
		// First, find proxy bundle
		for (Bundle b : context.getBundles()) {
			if (RSA_PROXY_BUNDLE_SYMBOLIC_ID.equals(b.getSymbolicName())) {
				// first start it
				b.start();
				// then get its bundle context
				proxyServiceFactoryBundleContext = b.getBundleContext();
			}
		}
		if (proxyServiceFactoryBundleContext == null)
			throw new IllegalStateException("RSA Proxy bundle (symbolic id=='" //$NON-NLS-1$
					+ RSA_PROXY_BUNDLE_SYMBOLIC_ID
					+ "') cannot be found, so RSA cannot be started"); //$NON-NLS-1$
	}

	private void stopProxyServiceFactoryBundle() {
		if (proxyServiceFactoryBundleContext != null) {
			// stop it
			try {
				proxyServiceFactoryBundleContext.getBundle().stop();
			} catch (Exception e) {
				// we don't care
			}
			proxyServiceFactoryBundleContext = null;
		}
	}

	public BundleContext getProxyServiceFactoryBundleContext() {
		return proxyServiceFactoryBundleContext;
	}

	private Map<Bundle, RemoteServiceAdmin> remoteServiceAdmins = new HashMap<Bundle, RemoteServiceAdmin>(
			1);

	private void removeSupportedConfigsAndIntents(ContainerTypeDescription ctd) {
		String[] remoteConfigsSupported = (String[]) rsaProps.get(
				org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_CONFIGS_SUPPORTED);
		List<String> rcs = new ArrayList<String>();
		if (remoteConfigsSupported != null) 
			for(int i=0; i < remoteConfigsSupported.length; i++) rcs.add(remoteConfigsSupported[i]);
		String[] remoteIntentsSupported = (String[]) rsaProps.get(
				org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_INTENTS_SUPPORTED);
		List<String> ris = new ArrayList<String>();
		if (remoteIntentsSupported != null) 
			for(int i=0; i < remoteIntentsSupported.length; i++) ris.add(remoteIntentsSupported[i]);

		String[] descSupportedConfigs = ctd.getSupportedConfigs();
		if (descSupportedConfigs != null) {
			for (int j = 0; j < descSupportedConfigs.length; j++)
				rcs.remove(descSupportedConfigs[j]);
			String[] descSupportedIntents = ctd.getSupportedIntents();
			for (int j = 0; j < descSupportedIntents.length; j++)
				ris.remove(descSupportedIntents);
		}
		// set rsaProps to new values
		rsaProps.put(org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_CONFIGS_SUPPORTED, rcs.toArray(new String[rcs.size()]));
		rsaProps.put(org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_INTENTS_SUPPORTED, ris.toArray(new String[ris.size()]));
	}
	
	void addSupportedConfigsAndIntents(ContainerTypeDescription desc) {
		// Get the existing remoteConfigsSupported from rsaProps
		String[] remoteConfigsSupported = (String[]) rsaProps.get(
				org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_CONFIGS_SUPPORTED);
		// Add all the existing to rcs list
		List<String> rcs = new ArrayList<String>();
		if (remoteConfigsSupported != null) 
			for(int i=0; i < remoteConfigsSupported.length; i++) rcs.add(remoteConfigsSupported[i]);
		// Get the existing remoteIntentsSupported from rsaProps
		String[] remoteIntentsSupported = (String[]) rsaProps.get(
				org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_INTENTS_SUPPORTED);
		// Add all the existing to ris list
		List<String> ris = new ArrayList<String>();
		if (remoteIntentsSupported != null) 
			for(int i=0; i < remoteIntentsSupported.length; i++) ris.add(remoteIntentsSupported[i]);

		// Get the supported configs from the given description
		String[] descSupportedConfigs = desc.getSupportedConfigs();
		
		if (descSupportedConfigs != null) {
			// Add all supported configs...as long as they are not already present
			for (int j = 0; j < descSupportedConfigs.length; j++)
				if (!rcs.contains(descSupportedConfigs[j])) rcs.add(descSupportedConfigs[j]);
			// Get supported intents
			String[] descSupportedIntents = desc.getSupportedIntents();
			// Add them all
			for (int j = 0; j < descSupportedIntents.length; j++)
				ris.add(descSupportedIntents[j]);
		}
		// set rsaProps to new values
		rsaProps.put(org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_CONFIGS_SUPPORTED, rcs.toArray(new String[rcs.size()]));
		rsaProps.put(org.osgi.service.remoteserviceadmin.RemoteConstants.REMOTE_INTENTS_SUPPORTED, ris.toArray(new String[ris.size()]));
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext
	 * )
	 */
	public void start(BundleContext bundleContext) throws Exception {
		Activator.context = bundleContext;
		Activator.instance = this;
		// initialize the RSA proxy service factory bundle...so that we
		// can get/use *that bundle's BundleContext for registering the
		// proxy ServiceFactory.
		// See osgi-dev thread here for info about this
		// approach/using the ServiceFactory extender approach for this purpose:
		// https://mail.osgi.org/pipermail/osgi-dev/2011-February/003000.html
		initializeProxyServiceFactoryBundle();

		// make remote service admin available
		rsaProps = new Properties();
		rsaProps.put(RemoteServiceAdmin.SERVICE_PROP, new Boolean(true));
		
		IContainerManager containerManager = getContainerManager();
		Assert.isNotNull(containerManager,
				"Container manager service must be present to start ECF Remote Service Admin"); //$NON-NLS-1$
		
		ContainerTypeDescription[] remoteServiceDescriptions = containerManager
				.getContainerFactory().getDescriptionsForContainerAdapter(
						IRemoteServiceContainerAdapter.class);
		// The following adds the standard supported configs and supported intents
		// values for all remote service descriptions to rsaProps
		for (int i = 0; i < remoteServiceDescriptions.length; i++) 
			addSupportedConfigsAndIntents(remoteServiceDescriptions[i]);

		// Register Remote Service Admin factory, with rsaProps
		remoteServiceAdminRegistration = context.registerService(
				org.osgi.service.remoteserviceadmin.RemoteServiceAdmin.class
						.getName(), new ServiceFactory() {
					public Object getService(Bundle bundle,
							ServiceRegistration registration) {
						RemoteServiceAdmin result = null;
						synchronized (remoteServiceAdmins) {
							RemoteServiceAdmin rsa = remoteServiceAdmins
									.get(bundle);
							if (rsa == null) {
								rsa = new RemoteServiceAdmin(bundle);
								remoteServiceAdmins.put(bundle, rsa);
							}
							result = rsa;
						}
						return result;
					}

					public void ungetService(Bundle bundle,
							ServiceRegistration registration, Object service) {
						synchronized (remoteServiceAdmins) {
							RemoteServiceAdmin rsa = remoteServiceAdmins
									.remove(bundle);
							if (rsa != null)
								rsa.close();
						}
					}
				}, (Dictionary) rsaProps);

		ctdTracker = new ServiceTracker<ContainerTypeDescription,ContainerTypeDescription>(context,ContainerTypeDescription.class,new ServiceTrackerCustomizer<ContainerTypeDescription,ContainerTypeDescription>() {
			public ContainerTypeDescription addingService(
					ServiceReference<ContainerTypeDescription> reference) {
				ContainerTypeDescription ctd = null;
				if (reference != null && context != null) {
					ctd = context.getService(reference);
					if (ctd != null) {
						// Add any new supported configs to rsaProps
						addSupportedConfigsAndIntents(ctd);
						if (remoteServiceAdminRegistration != null) 
							// Set the new properties for remoteServiceRegistration
							remoteServiceAdminRegistration.setProperties(rsaProps);
					}
				} 
				return ctd;
			}

			public void modifiedService(
					ServiceReference<ContainerTypeDescription> reference,
					ContainerTypeDescription service) {
			}

			public void removedService(
					ServiceReference<ContainerTypeDescription> reference,
					ContainerTypeDescription service) {
				if (remoteServiceAdminRegistration != null && service != null) {
					// Remove supported configs and intents from rsaProps
					removeSupportedConfigsAndIntents(service);
					// Reset properties for remoteServiceAdmin
					remoteServiceAdminRegistration.setProperties(rsaProps);
				}
			}
});
		ctdTracker.open();
		
		// create endpoint description locator
		endpointDescriptionLocator = new EndpointDescriptionLocator(context);
		// create and register endpoint description advertiser
		final Properties properties = new Properties();
		properties.put(Constants.SERVICE_RANKING,
				new Integer(Integer.MIN_VALUE));
		iServiceInfoFactoryRegistration = context.registerService(
				IServiceInfoFactory.class.getName(),
				new ServiceInfoFactory(), (Dictionary) properties);

		// start endpointDescriptionLocator
		endpointDescriptionLocator.start();
	}

	private void clearRSAs() {
		synchronized (remoteServiceAdmins) {
			for (Iterator<Entry<Bundle, RemoteServiceAdmin>> i = remoteServiceAdmins
					.entrySet().iterator(); i.hasNext();) {
				Entry<Bundle, RemoteServiceAdmin> entry = i.next();
				RemoteServiceAdmin rsa = entry.getValue();
				rsa.close();
				i.remove();
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
	 */
	public void stop(BundleContext bundleContext) throws Exception {
		if (endpointDescriptionLocator != null) {
			endpointDescriptionLocator.close();
			endpointDescriptionLocator = null;
		}
		if (ctdTracker != null) {
			ctdTracker.close();
			ctdTracker = null;
		}
		if (remoteServiceAdminRegistration != null) {
			remoteServiceAdminRegistration.unregister();
			remoteServiceAdminRegistration = null;
		}
		clearRSAs();
		if (iServiceInfoFactoryRegistration != null) {
			iServiceInfoFactoryRegistration.unregister();
			iServiceInfoFactoryRegistration = null;
		}
		synchronized (saxParserFactoryTrackerLock) {
			if (saxParserFactoryTracker != null) {
				saxParserFactoryTracker.close();
				saxParserFactoryTracker = null;
			}
		}
		synchronized (logServiceTrackerLock) {
			if (logServiceTracker != null) {
				logServiceTracker.close();
				logServiceTracker = null;
				logService = null;
			}
		}
		stopProxyServiceFactoryBundle();
		Activator.context = null;
		Activator.instance = null;
	}

	public boolean isOldEquinox() {
		if (context == null)
			return false;
		Bundle systemBundle = context.getBundle(0);
		String systemBSN = systemBundle.getSymbolicName();
		if ("org.eclipse.osgi".equals(systemBSN)) { //$NON-NLS-1$
			Version fixedVersion = new Version("3.7.0"); //$NON-NLS-1$
			// running on equinox; check the version
			Version systemVersion = systemBundle.getVersion();
			if (systemVersion.compareTo(fixedVersion) < 0)
				return true;
		}
		return false;
	}

	public String getFrameworkUUID() {
		if (context == null)
			return null;
		// code get and set the framework uuid property as specified in
		// r2.enterprise.pdf pg 297
		synchronized ("org.osgi.framework.uuid") { //$NON-NLS-1$
			String result = context.getProperty("org.osgi.framework.uuid"); //$NON-NLS-1$
			if (result == null) {
				UUID newUUID = UUID.randomUUID();
				result = newUUID.toString();
				System.setProperty("org.osgi.framework.uuid", //$NON-NLS-1$
						newUUID.toString());
			}
			return result;
		}
	}

	public SAXParserFactory getSAXParserFactory() {
		if (instance == null)
			return null;
		synchronized (saxParserFactoryTrackerLock) {
			if (saxParserFactoryTracker == null) {
				saxParserFactoryTracker = new ServiceTracker(context,
						SAXParserFactory.class.getName(), null);
				saxParserFactoryTracker.open();
			}
			return (SAXParserFactory) saxParserFactoryTracker.getService();
		}
	}

	public LogService getLogService() {
		if (context == null)
			return null;
		synchronized (logServiceTrackerLock) {
			if (logServiceTracker == null) {
				logServiceTracker = new ServiceTracker(context,
						LogService.class.getName(), null);
				logServiceTracker.open();
			}
			logService = (LogService) logServiceTracker.getService();
			if (logService == null)
				logService = new SystemLogService(PLUGIN_ID);
			return logService;
		}
	}

	public void log(IStatus status) {
		if (logService == null)
			logService = getLogService();
		if (logService != null)
			logService.log(null, LogHelper.getLogCode(status),
					LogHelper.getLogMessage(status), status.getException());
	}

	public void log(ServiceReference sr, IStatus status) {
		log(sr, LogHelper.getLogCode(status), LogHelper.getLogMessage(status),
				status.getException());
	}

	public void log(ServiceReference sr, int level, String message, Throwable t) {
		if (logService == null)
			logService = getLogService();
		if (logService != null)
			logService.log(sr, level, message, t);
	}

}