/*******************************************************************************
 * Copyright (c) 2010 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.distribution;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.ContainerTypeDescription;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerManager;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.osgi.services.discovery.DiscoveredServiceNotification;
import org.eclipse.ecf.osgi.services.discovery.DiscoveredServiceTracker;
import org.eclipse.ecf.osgi.services.discovery.IRemoteServiceEndpointDescription;
import org.eclipse.ecf.osgi.services.discovery.RemoteServiceEndpointDescription;
import org.eclipse.ecf.osgi.services.discovery.RemoteServicePublication;
import org.eclipse.ecf.osgi.services.discovery.ServiceEndpointDescription;
import org.eclipse.ecf.osgi.services.discovery.ServicePublication;
import org.eclipse.ecf.osgi.services.distribution.IDistributionConstants;
import org.eclipse.ecf.osgi.services.distribution.IProxyContainerFinder;
import org.eclipse.ecf.osgi.services.distribution.IProxyDistributionListener;
import org.eclipse.ecf.remoteservice.Constants;
import org.eclipse.ecf.remoteservice.IRemoteService;
import org.eclipse.ecf.remoteservice.IRemoteServiceContainer;
import org.eclipse.ecf.remoteservice.IRemoteServiceListener;
import org.eclipse.ecf.remoteservice.IRemoteServiceReference;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceEvent;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceUnregisteredEvent;
import org.eclipse.osgi.framework.eventmgr.CopyOnWriteIdentityMap;
import org.eclipse.osgi.framework.eventmgr.EventDispatcher;
import org.eclipse.osgi.framework.eventmgr.EventManager;
import org.eclipse.osgi.framework.eventmgr.ListenerQueue;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceRegistration;

public class DiscoveredServiceTrackerImpl implements DiscoveredServiceTracker {

	private DistributionProviderImpl distributionProvider;
	private List serviceLocations = new ArrayList();
	// <Map<containerID><RemoteServiceRegistration>
	private Map discoveredRemoteServiceRegistrations = new HashMap();
	private List ecfRemoteServiceProperties = Arrays.asList(new String[] {
			Constants.SERVICE_ID, Constants.OBJECTCLASS,
			org.eclipse.ecf.remoteservice.Constants.SERVICE_ID,
			org.eclipse.ecf.remoteservice.Constants.SERVICE_CONTAINER_ID,
			org.eclipse.ecf.remoteservice.Constants.SERVICE_RANKING,
			IDistributionConstants.SERVICE_EXPORTED_CONFIGS,
			RemoteServicePublication.ENDPOINT_ID,
			RemoteServicePublication.ENDPOINT_INTERFACE_NAME,
			RemoteServicePublication.ENDPOINT_LOCATION,
			RemoteServicePublication.SERVICE_INTERFACE_NAME,
			RemoteServicePublication.SERVICE_INTERFACE_VERSION,
			RemoteServicePublication.SERVICE_PROPERTIES, "service.uri" }); //$NON-NLS-1$
	// queue for incoming remote service available events
	private ListenerQueue queue;
	private EventManager eventManager;

	// This class is to hold the discovered endpoint available events
	class DiscoveredEndpointEvent {
		private RemoteServiceEndpointDescription rsEndpointDescription;

		public DiscoveredEndpointEvent(
				RemoteServiceEndpointDescription rsEndpointDescription) {
			this.rsEndpointDescription = rsEndpointDescription;
		}

		public RemoteServiceEndpointDescription getEndpointDescription() {
			return rsEndpointDescription;
		}
	}

	public DiscoveredServiceTrackerImpl(DistributionProviderImpl dp) {
		this.distributionProvider = dp;
		ThreadGroup eventGroup = new ThreadGroup("Remote Service Dispatcher"); //$NON-NLS-1$
		eventGroup.setDaemon(true);
		eventManager = new EventManager("Remote Service Dispatcher", eventGroup); //$NON-NLS-1$
		queue = new ListenerQueue(eventManager);
		CopyOnWriteIdentityMap listeners = new CopyOnWriteIdentityMap();
		listeners.put(this, this);
		queue.queueListeners(listeners.entrySet(), new EventDispatcher() {
			public void dispatchEvent(Object eventListener,
					Object listenerObject, int eventAction, Object eventObject) {
				RemoteServiceEndpointDescription rsEndpointDescription = ((DiscoveredEndpointEvent) eventObject)
						.getEndpointDescription();
				try {
					handleDiscoveredServiceAvailable(rsEndpointDescription);
				} catch (Exception e) {
					logError("handleDiscoveredServiceAvailble", //$NON-NLS-1$
							"Unexpected exception with rsEndpointDescription=" //$NON-NLS-1$
									+ rsEndpointDescription, e);
					throw new RuntimeException(
							"Unexpected exception with rsEndpointDescription=" //$NON-NLS-1$
									+ rsEndpointDescription, e);
				}
			}
		});
	}

	public void close() {
		if (eventManager != null) {
			eventManager.close();
			eventManager = null;
			queue = null;
		}
		serviceLocations.clear();
		discoveredRemoteServiceRegistrations.clear();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.osgi.service.discovery.DiscoveredServiceTracker#serviceChanged(org
	 * .osgi.service.discovery.DiscoveredServiceNotification)
	 */
	public void serviceChanged(final DiscoveredServiceNotification notification) {
		if (notification == null)
			return;
		int notificationType = notification.getType();
		switch (notificationType) {
		case DiscoveredServiceNotification.AVAILABLE:
			RemoteServiceEndpointDescription adesc = null;
			try {
				// If the service endpoint description is not ECF's then we
				// don't process it
				adesc = getECFDescription(notification
						.getServiceEndpointDescription());
			} catch (Exception e) {
				logError("serviceChanged.AVAILABLE", //$NON-NLS-1$
						"Error creating ECF endpoint description", e); //$NON-NLS-1$
				return;
			}
			// If it's not for us then return
			if (adesc == null)
				return;

			if (!isValidDescription(adesc)) {
				trace("serviceChanged.AVAILABLE", //$NON-NLS-1$
						"Duplicate or invalid description=" + adesc); //$NON-NLS-1$
				return;
			}
			final RemoteServiceEndpointDescription rsEndpointDescription = adesc;

			// put in queue and execute asynchronously
			queue.dispatchEventAsynchronous(0, new DiscoveredEndpointEvent(
					rsEndpointDescription));
			break;
		case DiscoveredServiceNotification.UNAVAILABLE:
			try {
				RemoteServiceEndpointDescription udesc = getECFDescription(notification
						.getServiceEndpointDescription());
				// If it's not for us then return
				if (udesc == null)
					return;

				// Remove existing proxy service registrations that correspond
				// to the
				// given serviceID
				synchronized (serviceLocations) {
					ServiceRegistration[] proxyServiceRegistrations = removeProxyServiceRegistrations(udesc);
					// Then unregister them
					if (proxyServiceRegistrations != null) {
						for (int i = 0; i < proxyServiceRegistrations.length; i++) {
							trace("handleDiscoveredServiceUnavailable", //$NON-NLS-1$
									"proxyServiceRegistrations=" //$NON-NLS-1$
											+ proxyServiceRegistrations[i]
											+ ",serviceEndpointDesc=" + udesc); //$NON-NLS-1$
							unregisterProxyServiceRegistration(udesc,
									proxyServiceRegistrations[i]);
						}
						removeDiscoveredServiceID(udesc);
					}
				}
			} catch (Exception e) {
				logError("serviceChanged", "UNAVAILABLE", e); //$NON-NLS-1$ //$NON-NLS-2$
			}
			break;
		case DiscoveredServiceNotification.MODIFIED:
			// Do nothing for now
			break;
		case DiscoveredServiceNotification.MODIFIED_ENDMATCH:
			// Do nothing for now
			break;
		default:
			logWarning("serviceChanged", "DiscoveredServiceNotification type=" //$NON-NLS-1$ //$NON-NLS-2$
					+ notificationType + " not found.  Ignoring"); //$NON-NLS-1$
			break;
		}
	}

	private void handleDiscoveredServiceAvailable(
			RemoteServiceEndpointDescription endpointDescription) {
		// Find IRemoteServiceContainers for the given
		// RemoteServiceEndpointDescription via registered services
		IRemoteServiceContainer[] rsContainers = findProxyContainers(endpointDescription);
		// If none found, we have nothing to do
		if (rsContainers == null || rsContainers.length == 0) {
			logWarning("handleDiscoveredServiceAvailable", //$NON-NLS-1$
					"No local RemoteServiceContainers found for endpoint description=" //$NON-NLS-1$
							+ endpointDescription);
			return;
		}
		// Get endpoint ID
		ID endpointID = endpointDescription.getEndpointAsID();
		// Get remote service filter from the service endpoint description
		// if it exists.
		String remoteServiceFilter = getFullRemoteServicesFilter(
				endpointDescription.getRemoteServicesFilter(),
				endpointDescription.getRemoteServiceId());
		// Get provided interfaces as collection
		Collection providedInterfaces = endpointDescription
				.getProvidedInterfaces();
		// Now for all remote service containers
		for (int i = 0; i < rsContainers.length; i++) {
			for (Iterator j = providedInterfaces.iterator(); j.hasNext();) {
				String providedInterface = (String) j.next();
				IRemoteServiceReference[] remoteReferences = null;
				// fire IProxyDistributionListeners pre get references
				firePreGetRemoteServiceReferences(endpointDescription,
						rsContainers[i]);
				try {
					// Get remote remote references for each container
					remoteReferences = rsContainers[i].getContainerAdapter()
							.getRemoteServiceReferences(endpointID,
									new ID[] { endpointID }, providedInterface,
									remoteServiceFilter);
				} catch (ContainerConnectException e) {
					logError("handleDiscoveredServiceAvailable", "rsca=" //$NON-NLS-1$ //$NON-NLS-2$
							+ rsContainers[i] + ",endpointId=" + endpointID //$NON-NLS-1$
							+ ",intf=" + providedInterface //$NON-NLS-1$
							+ ". Connect error in getRemoteServiceReferences", //$NON-NLS-1$
							e);
					continue;
				} catch (InvalidSyntaxException e) {
					logError(
							"handleDiscoveredServiceAvailable", //$NON-NLS-1$
							"rsca=" //$NON-NLS-1$
									+ rsContainers[i]
									+ ",endpointId=" //$NON-NLS-1$
									+ endpointID
									+ ",intf=" //$NON-NLS-1$
									+ providedInterface
									+ " Filter syntax error in getRemoteServiceReferences", //$NON-NLS-1$
							e);
					continue;
				}
				if (remoteReferences == null || remoteReferences.length == 0) {
					logError("handleDiscoveredServiceAvailable", //$NON-NLS-1$
							"getRemoteServiceReferences result is empty. " //$NON-NLS-1$
									+ "containerHelper=" //$NON-NLS-1$
									+ rsContainers[i]
									+ "remoteReferences=" //$NON-NLS-1$
									+ ((remoteReferences == null) ? "null" //$NON-NLS-1$
											: Arrays.asList(remoteReferences)
													.toString()), null);
					continue;
				} else {
					registerRemoteServiceReferences(endpointDescription,
							rsContainers[i], remoteReferences);
				}
			}
		}
	}

	private String getFullRemoteServicesFilter(String remoteServicesFilter,
			long remoteServiceId) {
		if (remoteServiceId < 0)
			return remoteServicesFilter;
		StringBuffer filter = new StringBuffer("(&(") //$NON-NLS-1$
				.append(org.eclipse.ecf.remoteservice.Constants.SERVICE_ID)
				.append("=").append(remoteServiceId).append(")"); //$NON-NLS-1$ //$NON-NLS-2$
		if (remoteServicesFilter != null)
			filter.append(remoteServicesFilter);
		filter.append(")"); //$NON-NLS-1$
		return filter.toString();
	}

	private void firePreGetRemoteServiceReferences(
			final IRemoteServiceEndpointDescription endpointDescription,
			final IRemoteServiceContainer remoteServiceContainer) {
		Activator activator = Activator.getDefault();
		if (activator != null) {
			IProxyDistributionListener[] listeners = activator
					.getProxyDistributionListeners();
			if (listeners != null) {
				for (int i = 0; i < listeners.length; i++) {
					final IProxyDistributionListener l = listeners[i];
					SafeRunner.run(new ISafeRunnable() {
						public void handleException(Throwable exception) {
							logError(
									"firePreGetRemoteServiceReferences", //$NON-NLS-1$
									"Exception calling proxy distribution listener", //$NON-NLS-1$
									exception);
						}

						public void run() throws Exception {
							l.retrievingRemoteServiceReferences(
									endpointDescription, remoteServiceContainer);
						}
					});
				}
			}
		}
	}

	private void firePreRegister(
			final IRemoteServiceEndpointDescription endpointDescription,
			final IRemoteServiceContainer remoteServiceContainer,
			final IRemoteServiceReference remoteServiceReference) {
		Activator activator = Activator.getDefault();
		if (activator != null) {
			IProxyDistributionListener[] listeners = activator
					.getProxyDistributionListeners();
			if (listeners != null) {
				for (int i = 0; i < listeners.length; i++) {
					final IProxyDistributionListener l = listeners[i];
					SafeRunner.run(new ISafeRunnable() {
						public void handleException(Throwable exception) {
							logError(
									"firePreRegister", //$NON-NLS-1$
									"Exception calling proxy distribution listener", //$NON-NLS-1$
									exception);
						}

						public void run() throws Exception {
							l.registering(endpointDescription,
									remoteServiceContainer,
									remoteServiceReference);
						}
					});
				}
			}
		}
	}

	private void firePostRegister(
			final IRemoteServiceEndpointDescription endpointDescription,
			final IRemoteServiceContainer remoteServiceContainer,
			final IRemoteServiceReference remoteServiceReference,
			final ServiceRegistration serviceRegistration) {
		Activator activator = Activator.getDefault();
		if (activator != null) {
			IProxyDistributionListener[] listeners = activator
					.getProxyDistributionListeners();
			if (listeners != null) {
				for (int i = 0; i < listeners.length; i++) {
					final IProxyDistributionListener l = listeners[i];
					SafeRunner.run(new ISafeRunnable() {
						public void handleException(Throwable exception) {
							logError(
									"firePreRegister", //$NON-NLS-1$
									"Exception calling proxy distribution listener", //$NON-NLS-1$
									exception);
						}

						public void run() throws Exception {
							l.registered(endpointDescription,
									remoteServiceContainer,
									remoteServiceReference, serviceRegistration);
						}
					});
				}
			}
		}
	}

	private void fireUnregister(
			final IRemoteServiceEndpointDescription endpointDescription,
			final ServiceRegistration registration) {
		Activator activator = Activator.getDefault();
		if (activator != null) {
			IProxyDistributionListener[] listeners = activator
					.getProxyDistributionListeners();
			if (listeners != null) {
				for (int i = 0; i < listeners.length; i++) {
					final IProxyDistributionListener l = listeners[i];
					SafeRunner.run(new ISafeRunnable() {
						public void handleException(Throwable exception) {
							logError(
									"fireUnregister", //$NON-NLS-1$
									"Exception calling proxy distribution listener", //$NON-NLS-1$
									exception);
						}

						public void run() throws Exception {
							l.unregistered(endpointDescription, registration);
						}
					});
				}
			}
		}
	}

	private RemoteServiceEndpointDescription getECFDescription(
			ServiceEndpointDescription aServiceEndpointDesc) {
		RemoteServiceEndpointDescription ecfSED;
		if (!(aServiceEndpointDesc instanceof RemoteServiceEndpointDescription)) {
			ecfSED = (RemoteServiceEndpointDescription) Activator
					.getDefault()
					.getAdapterManager()
					.loadAdapter(aServiceEndpointDesc,
							RemoteServiceEndpointDescription.class.getName());
		} else
			ecfSED = (RemoteServiceEndpointDescription) aServiceEndpointDesc;
		return ecfSED;
	}

	private boolean findProxyServiceRegistration(
			RemoteServiceEndpointDescription sed) {
		synchronized (discoveredRemoteServiceRegistrations) {
			for (Iterator i = discoveredRemoteServiceRegistrations.keySet()
					.iterator(); i.hasNext();) {
				ID containerID = (ID) i.next();
				RemoteServiceRegistration reg = (RemoteServiceRegistration) discoveredRemoteServiceRegistrations
						.get(containerID);
				if (reg.hasRSED(sed))
					return true;
			}
			return false;
		}
	}

	private ServiceRegistration[] removeProxyServiceRegistrations(
			RemoteServiceEndpointDescription sed) {
		List results = new ArrayList();
		synchronized (discoveredRemoteServiceRegistrations) {
			final List containerIDsToRemove = new ArrayList();
			for (Iterator i = discoveredRemoteServiceRegistrations.keySet()
					.iterator(); i.hasNext();) {
				ID containerID = (ID) i.next();
				RemoteServiceRegistration reg = (RemoteServiceRegistration) discoveredRemoteServiceRegistrations
						.get(containerID);
				if (reg != null) {
					ServiceRegistration sr = reg.removeServiceRegistration(sed);
					if (sr != null)
						results.add(sr);
					if (reg.isEmpty()) {
						reg.dispose();
						containerIDsToRemove.add(containerID);
					}
				}
			}
			// Outside of the iterator, now remove any containerID found to
			// match
			for (Iterator i = containerIDsToRemove.iterator(); i.hasNext();) {
				discoveredRemoteServiceRegistrations.remove(i.next());
			}
			return (ServiceRegistration[]) results
					.toArray(new ServiceRegistration[] {});
		}
	}

	class RemoteServiceReferenceUnregisteredListener implements
			IRemoteServiceListener {
		public void handleServiceEvent(IRemoteServiceEvent event) {
			if (event instanceof IRemoteServiceUnregisteredEvent) {
				ID containerID = event.getContainerID();
				ID localContainerID = event.getLocalContainerID();
				IRemoteServiceReference reference = event.getReference();
				trace("handleRemoteServiceUnregisteredEvent", //$NON-NLS-1$
						"localContainerID=" + localContainerID //$NON-NLS-1$
								+ ",containerID=" + containerID //$NON-NLS-1$
								+ ",remoteReference=" + reference); //$NON-NLS-1$
				// Synchronize on serviceLocations so no other changes happen
				// while
				// this is going on...as it can be invoked by an arbitrary
				RemoteServiceRegistration.RSEDAndSRAssoc[] assocs = null;
				synchronized (serviceLocations) {
					synchronized (discoveredRemoteServiceRegistrations) {
						List containerIDsToRemove = new ArrayList();
						RemoteServiceRegistration rsRegs = (RemoteServiceRegistration) discoveredRemoteServiceRegistrations
								.get(localContainerID);
						// If we've got any remote service registrations for the
						// containerID
						if (rsRegs != null) {
							assocs = rsRegs
									.removeServiceRegistration(reference);
							// If this removes *all* references for this
							// registration
							if (rsRegs.isEmpty()) {
								rsRegs.dispose();
								containerIDsToRemove.add(localContainerID);
							}
							if (assocs != null) {
								for (int i = 0; i < assocs.length; i++) {
									removeDiscoveredServiceID(assocs[i]
											.getRSED());
								}
							}
						}
						for (Iterator i = containerIDsToRemove.iterator(); i
								.hasNext();) {
							discoveredRemoteServiceRegistrations.remove(i
									.next());
						}
					}

				}
				// Call this outside of synchronized block
				if (assocs != null) {
					for (int i = 0; i < assocs.length; i++) {
						ServiceRegistration sr = assocs[i].getSR();
						trace("handleRemoteServiceUnregisteredEvent.unregister", //$NON-NLS-1$
						"localContainerID=" //$NON-NLS-1$
								+ localContainerID + ",containerID=" //$NON-NLS-1$
								+ containerID + ",remoteReference=" //$NON-NLS-1$
								+ reference + ",proxyServiceRegistrations=" //$NON-NLS-1$
								+ sr);
						unregisterProxyServiceRegistration(assocs[i].getRSED(),
								sr);
					}
				}
			}
		}
	}

	private void unregisterProxyServiceRegistration(
			IRemoteServiceEndpointDescription endpointDescription,
			ServiceRegistration reg) {
		try {
			distributionProvider.removeRemoteService(reg.getReference());
			reg.unregister();
		} catch (IllegalStateException e) {
			// Ignore
			logWarning("unregisterProxyServiceRegistration", //$NON-NLS-1$
					"Exception unregistering serviceRegistration=" + reg); //$NON-NLS-1$
		} catch (Exception e) {
			logError("unregisterProxyServiceRegistration", //$NON-NLS-1$
					"Exception unregistering serviceRegistration=" + reg, e); //$NON-NLS-1$
		}
		fireUnregister(endpointDescription, reg);
	}

	private void registerRemoteServiceReferences(
			RemoteServiceEndpointDescription sed,
			IRemoteServiceContainer remoteServiceContainer,
			IRemoteServiceReference[] remoteReferences) {

		synchronized (serviceLocations) {
			// check to make sure that this serviceLocation
			// is still present
			if (!containsDiscoveredServiceID(sed)) {
				logError("registerRemoteServiceReferences", "serviceLocation=" //$NON-NLS-1$ //$NON-NLS-2$
						+ sed + " no longer present", null); //$NON-NLS-1$
				return;
			}
			// check to make sure that the proxy service registry is not
			// already there
			if (findProxyServiceRegistration(sed)) {
				logError("registerRemoteServiceReferences", //$NON-NLS-1$
						"serviceEndpointDesc=" + sed //$NON-NLS-1$
								+ " previously registered locally...ignoring", //$NON-NLS-1$
						null);
				return;
			}
			// Then get/setup remote service
			for (int i = 0; i < remoteReferences.length; i++) {
				// Get IRemoteService, used to create the proxy
				IRemoteService remoteService = remoteServiceContainer
						.getContainerAdapter().getRemoteService(
								remoteReferences[i]);
				// If no remote service then give up
				if (remoteService == null) {
					logError("registerRemoteServiceReferences", //$NON-NLS-1$
							"Remote service is null for remote reference " //$NON-NLS-1$
									+ remoteReferences[i], null);
					continue;
				}

				// Get classes to register for remote service
				String[] clazzes = (String[]) remoteReferences[i]
						.getProperty(Constants.OBJECTCLASS);
				if (clazzes == null || clazzes.length == 0) {
					logError("registerRemoteServiceReferences", //$NON-NLS-1$
							"No classes specified for remote service reference " //$NON-NLS-1$
									+ remoteReferences[i], null);
					continue;
				}

				// Get service properties for the proxy registration
				Dictionary properties = getPropertiesForRemoteService(sed,
						remoteServiceContainer, remoteReferences[i],
						remoteService);

				// Create proxy right here
				Object proxy = null;
				try {
					proxy = remoteService.getProxy();
					if (proxy == null) {
						logError("registerRemoteServiceReferences", //$NON-NLS-1$
								"Remote service proxy is null", null); //$NON-NLS-1$
						continue;
					}
					// Fire pre register notification fir
					// IProxyDistributionListener
					firePreRegister(sed, remoteServiceContainer,
							remoteReferences[i]);
					trace("registerRemoteServiceReferences", "rsca=" //$NON-NLS-1$ //$NON-NLS-2$
							+ remoteServiceContainer + ",remoteReference=" //$NON-NLS-1$
							+ remoteReferences[i]);
					// Actually register proxy here
					ServiceRegistration registration = Activator.getDefault()
							.getContext()
							.registerService(clazzes, proxy, properties);

					RemoteServiceRegistration reg = getProxyServiceRegistration(remoteServiceContainer);
					reg.addServiceRegistration(remoteReferences[i], sed,
							registration);
					// And add to distribution provider
					distributionProvider.addRemoteService(registration
							.getReference());
					trace("addLocalServiceRegistration.COMPLETE", //$NON-NLS-1$
							"containerHelper=" + remoteServiceContainer //$NON-NLS-1$
									+ ",remoteServiceReference=" //$NON-NLS-1$
									+ remoteReferences[i]
									+ ",localServiceRegistration=" //$NON-NLS-1$
									+ registration);
					// Fire IProxyDistributionListener to notify we're done
					firePostRegister(sed, remoteServiceContainer,
							remoteReferences[i], registration);
				} catch (Exception e) {
					logError("registerRemoteServiceReferences", //$NON-NLS-1$
							"Exception creating or registering remote reference " //$NON-NLS-1$
									+ remoteReferences[i], e);
					continue;
				}
			}
		}
	}

	private RemoteServiceRegistration getProxyServiceRegistration(
			IRemoteServiceContainer rsContainer) {
		ID localContainerID = rsContainer.getContainer().getID();
		synchronized (discoveredRemoteServiceRegistrations) {
			RemoteServiceRegistration reg = (RemoteServiceRegistration) discoveredRemoteServiceRegistrations
					.get(localContainerID);
			// If there is none, then create one
			if (reg == null) {
				reg = new RemoteServiceRegistration(rsContainer,
						new RemoteServiceReferenceUnregisteredListener());
				discoveredRemoteServiceRegistrations.put(localContainerID, reg);
			}
			return reg;
		}
	}

	private boolean isRemoteServiceProperty(String propertyKey) {
		return ecfRemoteServiceProperties.contains(propertyKey);
	}

	private Dictionary getPropertiesForRemoteService(
			RemoteServiceEndpointDescription rsEndpointDescription,
			IRemoteServiceContainer rsContainer,
			IRemoteServiceReference rsReference, IRemoteService remoteService) {

		Properties props = new Properties();
		// Add the required 'service.imported' property, which for ECF rs
		// providers
		// exposes the IRemoteService
		props.put(IDistributionConstants.SERVICE_IMPORTED, remoteService);

		// Add service intents...if not null (optional property)
		String[] serviceIntents = rsEndpointDescription.getServiceIntents();
		if (serviceIntents != null)
			props.put(IDistributionConstants.SERVICE_INTENTS, serviceIntents);

		// Then add all other service properties
		String[] propKeys = rsReference.getPropertyKeys();
		for (int i = 0; i < propKeys.length; i++) {
			if (!isRemoteServiceProperty(propKeys[i])) {
				props.put(propKeys[i], rsReference.getProperty(propKeys[i]));
			}
		}

		// make the service identifiable by consumers
		// especially org.eclipse.ecf.remoteservice.ui.dosgi
		final ID endpointId = (ID) rsReference
				.getProperty(org.eclipse.ecf.remoteservice.Constants.SERVICE_CONTAINER_ID);
		final Long serviceId = (Long) rsReference
				.getProperty(org.eclipse.ecf.remoteservice.Constants.SERVICE_ID);
		props.put(ServicePublication.ENDPOINT_ID, endpointId + "#" + serviceId); //$NON-NLS-1$

		// finally add service.imported.configs
		addImportedConfigsProperties(
				getContainerTypeDescription(rsContainer.getContainer()),
				rsEndpointDescription.getSupportedConfigs(), props);

		return props;
	}

	private void addImportedConfigsProperties(
			ContainerTypeDescription containerTypeDescription,
			String[] remoteExportedConfigs, Dictionary exportedProperties) {
		if (containerTypeDescription == null)
			return;
		if (remoteExportedConfigs != null) {
			String[] importedConfigs = containerTypeDescription
					.getImportedConfigs(remoteExportedConfigs);
			if (importedConfigs != null) {
				// Add the service.imported.configs property
				exportedProperties.put(
						IDistributionConstants.SERVICE_IMPORTED_CONFIGS,
						importedConfigs);
				// First get any/all properties to add
				Dictionary localConfigProperties = containerTypeDescription
						.getPropertiesForImportedConfigs(importedConfigs,
								exportedProperties);
				if (localConfigProperties != null) {
					for (Enumeration e = localConfigProperties.keys(); e
							.hasMoreElements();) {
						String key = (String) e.nextElement();
						exportedProperties.put(key,
								localConfigProperties.get(key));
					}
				}
			}
		}
	}

	protected ContainerTypeDescription getContainerTypeDescription(
			IContainer container) {
		IContainerManager containerManager = getContainerManager();
		if (containerManager == null)
			return null;
		return containerManager.getContainerTypeDescription(container.getID());
	}

	protected IContainerManager getContainerManager() {
		Activator activator = Activator.getDefault();
		if (activator == null)
			return null;
		return activator.getContainerManager();
	}

	private boolean addDiscoveredServiceID(RemoteServiceEndpointDescription desc) {
		synchronized (serviceLocations) {
			return serviceLocations.add(desc);
		}
	}

	private boolean removeDiscoveredServiceID(
			RemoteServiceEndpointDescription desc) {
		synchronized (serviceLocations) {
			return serviceLocations.remove(desc);
		}
	}

	private boolean containsDiscoveredServiceID(
			RemoteServiceEndpointDescription desc) {
		synchronized (serviceLocations) {
			return serviceLocations.contains(desc);
		}
	}

	protected void trace(String methodName, String message) {
		LogUtility.trace(methodName, DebugOptions.DISCOVEREDSERVICETRACKER,
				this.getClass(), message);
	}

	protected void traceException(String methodName, String message, Throwable t) {
		LogUtility.traceException(methodName, DebugOptions.EXCEPTIONS_CATCHING,
				this.getClass(), message, t);
	}

	protected void logError(String methodName, String message, Throwable t) {
		LogUtility.logError(methodName, DebugOptions.DISCOVEREDSERVICETRACKER,
				this.getClass(), message, t);
	}

	protected void logError(String methodName, String message) {
		LogUtility.logError(methodName, DebugOptions.DISCOVEREDSERVICETRACKER,
				this.getClass(), message);
	}

	protected void logWarning(String methodName, String message) {
		LogUtility
				.logWarning(methodName, DebugOptions.DISCOVEREDSERVICETRACKER,
						this.getClass(), message);
	}

	private boolean isValidDescription(
			RemoteServiceEndpointDescription rsEndpointDescription) {
		if (rsEndpointDescription == null)
			return false;
		synchronized (serviceLocations) {
			if (containsDiscoveredServiceID(rsEndpointDescription)) {
				return false;
			} else {
				addDiscoveredServiceID(rsEndpointDescription);
				return true;
			}
		}
	}

	private IRemoteServiceContainer[] findProxyContainers(
			final RemoteServiceEndpointDescription rsEndpointDescription) {
		// Get activator
		Activator activator = Activator.getDefault();
		if (activator == null)
			return null;
		// Get finder (as service)
		IProxyContainerFinder finder = activator
				.getProxyRemoteServiceContainerFinder();
		if (finder == null) {
			logError("findRemoteServiceContainersViaService", //$NON-NLS-1$
					"No container finders available"); //$NON-NLS-1$
			return null;
		}
		return finder.findProxyContainers(rsEndpointDescription.getServiceID(),
				rsEndpointDescription);
	}

}