/*
 * Copyright 2007 the original author or authors.
 * 
 * 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.wamblee.system;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Composite system consisting of multiple subsystems. 
 *
 * @author Erik Brakkee
 */
public class Container extends AbstractComponent {

	private static final Log LOG = LogFactory.getLog(Container.class);

	private Component[] _systems;

	public static RequiredInterface[] filterRequiredServices(
			ProvidedInterface aProvided,
			Collection<RequiredInterface> aDescriptors) {
		List<RequiredInterface> required = new ArrayList<RequiredInterface>();
		for (RequiredInterface descriptor : aDescriptors) {
			if (descriptor.implementedBy(aProvided)) {
				required.add(descriptor);
			}
		}
		return required.toArray(new RequiredInterface[0]);
	}

	public static ProvidedInterface[] filterProvidedServices(
			RequiredInterface aRequired,
			Collection<ProvidedInterface> aProvided) {
		List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
		for (ProvidedInterface descriptor : aProvided) {
			if (aRequired.implementedBy(descriptor)) {
				provided.add(descriptor);
			}
		}
		return provided.toArray(new ProvidedInterface[0]);
	}
	
	/**
	 * Construcst the composite system. 
	 * @param aName Name of the system. 
	 * @param aRegistry Service registry.
	 * @param aSystems Subsystems. 
	 * @param aProvided Provided services of the system. 
	 * @param aRequired Required services by the system. 
	 */
	public Container(String aName, Component[] aSystems,
			ProvidedInterface[] aProvided, RequiredInterface[] aRequired) {
		super(aName, aProvided, aRequired);
		_systems = aSystems;
		validate(aRequired);
	}

	/**
	 * Validates the subsystems together to check that there are
	 * no required services not in the required list and 
	 * no services in the provided list that cannot be provided. 
	 * Also logs a warning in case of superfluous requirements.  
	 */
	private void validate(RequiredInterface[] aRequired) {
		List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
		for (Component system : _systems) {
			provided.addAll(Arrays.asList(system.getProvidedServices()));
		}

		List<RequiredInterface> required = new ArrayList<RequiredInterface>();
		for (Component system : _systems) {
			required.addAll(Arrays.asList(system.getRequiredServices()));
		}

		for (ProvidedInterface service : getProvidedServices()) {
			if (!(provided.contains(service))) {
				throw new SystemAssemblyException(getName() + ": Service '" + service
						+ "' is not provided by any of the subsystems");
			}
		}

		for (RequiredInterface service : getRequiredServices()) {
			if (!(required.contains(service))) {
				info("Service '"
						+ service
						+ "' indicated as required is not actually required by any of the subsystems");
			}
		}

		List<RequiredInterface> reallyRequired = new ArrayList<RequiredInterface>(
				required);
		// Compute all required interfaces that are not provided
		for (ProvidedInterface service : provided) {
			List<RequiredInterface> fulfilled = 
				Arrays.asList(filterRequiredServices(service, 
					reallyRequired));
			reallyRequired.removeAll(fulfilled); 
		}
		// Now the remaining interfaces should be covered by the required
		// list. 
		reallyRequired.removeAll(Arrays.asList(aRequired));
		
		String missingRequired = "";
		for (RequiredInterface service: reallyRequired) {
			missingRequired += service + "\n";
		}
		if ( missingRequired.length() > 0 ) { 
			throw new SystemAssemblyException(getName() + ": missing required services\n" + missingRequired);
		}
	}

	@Override
	protected void doStart(String aContext) {
		List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
		
		// all interfaces from the required list of this container are
		// provided to the components inside it.
		RequiredInterface[] required = getRequiredServices();
		for (RequiredInterface intf: required) { 
		    ProvidedInterface provider = intf.getProvider(); 
		    if ( provider == null ) { 
		    	throw new SystemAssemblyException(aContext + ": required interface '" + intf +"' is not provided");
		    }
			provided.add(intf.getProvider());
		}
		
		startImpl();
	}
	
	/**
	 * Starts the subsystems.
	 * 
	 * @param aRequiredServices
	 *            Services that are available from other systems that have been
	 *            started before.
	 */
	private void startImpl() {
		LOG.info("Starting '" + "'");
		List<ProvidedInterface> allProvided = new ArrayList<ProvidedInterface>();
		
		// Add the provides of all externally required interfaces to the list of available
		// interfaces
		for (RequiredInterface required: getRequiredServices()) { 
			allProvided.add(required.getProvider());
		}
		
		for (Component system : _systems) {
			// Check if all required services are already provided by earlier
			// systems.
			RequiredInterface[] required = system.getRequiredServices();

			for (RequiredInterface descriptor : required) {
				ProvidedInterface[] filtered = filterProvidedServices(
						descriptor, allProvided);

				if (filtered.length == 0) {
					throw new SystemAssemblyException(
							"Service '"
									+ descriptor
									+ "' required by system '"
									+ system
									+ "' is not provided by systems that are started earlier");
				}
				if (filtered.length > 1) {
					throw new SystemAssemblyException(
							"Service '"
									+ descriptor
									+ "' required by system '"
									+ system
									+ "' matches multiple services provided by other systems: " + 
									Arrays.asList(filtered));
				}
				descriptor.setProvider(filtered[0]);
			}
			
			// Start the service. 
			system.start(getQualifiedName());

			// add all provided services
			ProvidedInterface[] provided = system.getProvidedServices();
			allProvided.addAll(Arrays.asList(provided));
		}
	}

	
	@Override
	protected void doStop() {
		for (int i = _systems.length-1; i >= 0; i--) { 
			_systems[i].stop();
		}
	}

	private void info(String aMsg) {
		LOG.info(getName() + ": " + aMsg);
	}

}