/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.felix.scr.impl.manager;


import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
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 org.apache.felix.scr.impl.inject.ComponentMethods;
import org.apache.felix.scr.impl.logger.ComponentLogger;
import org.apache.felix.scr.impl.metadata.ComponentMetadata;
import org.apache.felix.scr.impl.metadata.ServiceMetadata.Scope;
import org.apache.felix.scr.impl.metadata.TargetedPID;
import org.osgi.framework.Constants;
import org.osgi.service.component.ComponentConstants;
import org.osgi.service.log.LogService;
import org.osgi.util.promise.Deferred;
import org.osgi.util.promise.Promise;
import org.osgi.util.promise.Promises;


/**
 * The <code>ConfigurableComponentHolder</code> class is a
 * {@link ComponentHolder} for automatically configured components instances
 * that may or may not be configured through Config Admin.
 * <p>
 * The holder copes with three situations:
 * <ul>
 * <li>No configuration is available for the held component. That is there is
 * no configuration whose <code>service.pid</code> or
 * <code>service.factoryPid</code> equals the component name.</li>
 * <li>A singleton configuration is available whose <code>service.pid</code>
 * equals the component name.</li>
 * <li>One or more factory configurations exist whose
 * <code>service.factoryPid</code> equals the component name.</li>
 * </ul>
 */
public abstract class ConfigurableComponentHolder<S> implements ComponentHolder<S>, ComponentContainer<S>
{

    /**
     * The activator owning the per-bundle components
     */
    private final ComponentActivator m_activator;

    /**
     * The {@link ComponentMetadata} describing the held component(s)
     */
    private final ComponentMetadata m_componentMetadata;

    /** the targeted pids corresponding to the pids specified in the config metadata, except possibly for the single
     * factory pid
     */
    private final TargetedPID[] m_targetedPids;

    private final Long[] m_changeCount;

    private final Map<String, Long> m_factoryChangeCount = new HashMap<>();

    /**
     * the index in metadata.getConfigurationPid() of the base factory pid, if any.  Each component created from a factory configuration
     * might have a different targeted pid.
     */
    private volatile Integer m_factoryPidIndex;

    /**
     * the non-factory configurations shared between all instances.
     */
    private final Dictionary<String, Object>[] m_configurations;

    /**
     * the factory configurations indexed by pid (which cannot be a TargetedPID since it's generated by CA).  We have to track these since
     * other required configs may not yet be present so we can't create the component manager yet.
     */
    private final Map<String, Dictionary<String, Object>> m_factoryConfigurations = new HashMap<>();

    /**
     * Each factory config may be from a different TargetedPID (sharing the same base service pid, but with different level of detail)
     */
    private final Map<String, TargetedPID> m_factoryTargetedPids = new HashMap<>();
    /**
     * A map of components configured with factory configuration. The indices
     * are the PIDs (<code>service.pid</code>) of the configuration objects.
     * The values are the {@link SingleComponentManager<S> component instances}
     * created on behalf of the configurations.
     */
    private final Map<String, AbstractComponentManager<S>> m_components;

    /**
     * The special component used if there is no configuration or a singleton
     * configuration. This field is only <code>null</code> once all components
     * held by this holder have been disposed of by
     * {@link #disposeComponents(int)} and is first created in the constructor.
     * As factory configurations are provided this instance may be configured
     * or "deconfigured".
     * <p>
     * Expected invariants:
     * <ul>
     * <li>This field is only <code>null</code> after disposal of all held
     * components</li>
     * <li>The {@link #m_components} map is empty or the component pointed to
     * by this field is also contained in the map</li>
     * <ul>
     */
    private volatile AbstractComponentManager<S> m_singleComponent;

    /**
     * Whether components have already been enabled by calling the
     * {@link #enableComponents(boolean)} method. If this field is <code>true</code>
     * component instances created per configuration by the
     * {@link #configurationUpdated(TargetedPID, TargetedPID, Dictionary, long)} method are also
     * enabled. Otherwise they are not enabled immediately.
     */
    private volatile boolean m_enabled;
    private final Object enableLock = new Object();
    private volatile Promise<Void> m_enablePromise;
    private volatile Promise<Void> m_disablePromise = Promises.resolved(null);

    private final ComponentMethods<S> m_componentMethods;

    private final ComponentLogger logger;

    public ConfigurableComponentHolder( final ComponentActivator activator,
            final ComponentMetadata metadata,
            final ComponentLogger logger)
    {
        this.logger = logger;
        this.m_activator = activator;
        this.m_componentMetadata = metadata;
        final int pidCount = metadata.getConfigurationPid().size();
        this.m_targetedPids = new TargetedPID[pidCount];
        this.m_configurations = new Dictionary[pidCount];
        this.m_changeCount = new Long[pidCount];
        this.m_components = new HashMap<>();
        this.m_componentMethods = createComponentMethods();
        this.m_enabled = false;
    }

    protected abstract ComponentMethods<S> createComponentMethods();

    protected ComponentMethods<S> getComponentMethods() {
        return m_componentMethods;
    }

    protected AbstractComponentManager<S> createComponentManager(boolean factoryConfiguration)
    {

        AbstractComponentManager<S> manager;
        if ( m_componentMetadata.isFactory() )
        {
            //TODO is there any check to make sure factory component factories are enabled before creating them?
            if ( !m_componentMetadata.isObsoleteFactoryComponentFactory() || !factoryConfiguration )
            {
                manager = new ComponentFactoryImpl<>(this, m_componentMethods);
            }
            else
            {
                manager = new SingleComponentManager<>(this, m_componentMethods, true );
            }
        }
        else if ( m_componentMetadata.getServiceScope() == Scope.bundle )
        {
            manager = new ServiceFactoryComponentManager<>( this, m_componentMethods );
        }

        else if ( m_componentMetadata.getServiceScope() == Scope.prototype )
        {
            manager = PSFLoader.newPSFComponentManager(this, m_componentMethods);
        }

        else
        {
            //immediate or delayed
            manager = new SingleComponentManager<>( this, m_componentMethods );
        }

        return manager;
    }

    private static class PSFLoader
    {
        static <S> AbstractComponentManager<S> newPSFComponentManager(ConfigurableComponentHolder<S> holder, ComponentMethods methods)
        {
            return new PrototypeServiceFactoryComponentManager<>( holder, methods );
        }
    }


    @Override
    public final ComponentActivator getActivator()
    {
        return m_activator;
    }


    @Override
    public final ComponentMetadata getComponentMetadata()
    {
        return m_componentMetadata;
    }


    /**
     * The configuration with the given <code>pid</code>
     * (<code>service.pid</code> of the configuration object) is deleted.
     * <p>
     * The following situations are supported:
     * <ul>
     * <li>The configuration was a singleton configuration (pid equals the
     * component name). In this case the internal component map is empty and
     * the single component has been configured by the singleton configuration
     * and is no "deconfigured".</li>
     * <li>A factory configuration object has been deleted and the configured
     * object is set as the single component. If the single component held the
     * last factory configuration object, it is deconfigured. Otherwise the
     * single component is disposed off and replaced by another component in
     * the map of existing components.</li>
     * <li>A factory configuration object has been deleted and the configured
     * object is not set as the single component. In this case the component is
     * simply disposed off and removed from the internal map.</li>
     * </ul>
     */
    @Override
    public void configurationDeleted( final TargetedPID pid, TargetedPID factoryPid )
    {
        logger.log( LogService.LOG_DEBUG, "ImmediateComponentHolder configuration deleted for pid {0}", null, pid);

        // component to deconfigure or dispose of
        final Map<AbstractComponentManager<S>, Map<String, Object>> scms = new HashMap<>();
        boolean reconfigure = false;

        synchronized ( m_components )
        {
            if (factoryPid != null) {
                checkFactoryPidIndex(factoryPid);
                String servicePid = pid.getServicePid();
                m_factoryTargetedPids.remove(servicePid);
                m_factoryChangeCount.remove(servicePid);
                m_factoryConfigurations.remove(servicePid);
                AbstractComponentManager<S> scm = m_components.remove(servicePid);
                if ( m_factoryConfigurations.isEmpty() )
                {
                    m_factoryPidIndex = null;
                }
                if ( !m_enabled || scm == null )
                {
                    return;
                }
                reconfigure = m_componentMetadata.isConfigurationOptional() && m_components.isEmpty();
                if ( reconfigure )
                {
                    m_singleComponent = scm;
                    scms.put( scm, mergeProperties(null) );
                }
                else
                {
                    scms.put( scm,  null );
                }
            }
            else
            {
                //singleton pid
                int index = getSingletonPidIndex(pid);
                m_targetedPids[index] = null;
                m_changeCount[index] = null;
                m_configurations[index] = null;
                if ( !m_enabled )
                {
                    return;
                }
                reconfigure = m_componentMetadata.isConfigurationOptional();

                if ( m_factoryPidIndex == null)
                {
                    if ( m_singleComponent != null ) {
                        if (reconfigure) {
                            scms.put(m_singleComponent, mergeProperties(null));
                        } else {
                            scms.put(m_singleComponent, null);
                            m_singleComponent = null;
                        }
                    }
                }
                else
                {
                    if (reconfigure) {
                        for (Map.Entry<String, AbstractComponentManager<S>> entry : m_components.entrySet()) {
                            scms.put(entry.getValue(), mergeProperties(entry.getKey()));
                        }
                    }
                    else
                    {
                        for (Map.Entry<String, AbstractComponentManager<S>> entry : m_components.entrySet()) {
                            scms.put(entry.getValue(), null );
                        }
                        m_components.clear();
                    }
                }

            }
        }

        for ( Map.Entry<AbstractComponentManager<S>,Map<String, Object>> entry: scms.entrySet())
        {
            if ( reconfigure ) {
                entry.getKey().reconfigure( entry.getValue(), true, factoryPid);
            } else {
                entry.getKey().dispose(ComponentConstants.DEACTIVATION_REASON_CONFIGURATION_DELETED);
            }
        }
    }


    /**
     * Configures a component with the given configuration. This configuration
     * update may happen in various situations:
     * <ul>
     * <li>The <code>pid</code> equals the component name. Hence we have a
     * singleton configuration for the single component held by this holder</li>
     * <li>The configuration is a factory configuration and is the first
     * configuration provided. In this case the single component is provided
     * with the configuration and also stored in the map.</li>
     * <li>The configuration is a factory configuration but not the first. In
     * this case a new component is created, configured and stored in the map</li>
     * </ul>
     * @return true if a new configuration was created, false otherwise.
     *
     * TODO there are now 3 states..... still not satisfied, existing, and new
     */
    @Override
    public boolean configurationUpdated( TargetedPID pid, TargetedPID factoryPid, final Dictionary<String, Object> props, long changeCount )
    {
        logger.log( LogService.LOG_DEBUG, "ConfigurableComponentHolder configuration updated for pid {0} with properties {1} and change count {2}", null,
            pid, props, changeCount);

        // component to update or create
        final Map<AbstractComponentManager<S>, Map<String, Object>> scms = new HashMap<>();
        boolean created = false;

        synchronized (m_components) {
            //Find or create the component manager, or return if not satisfied.
            if (factoryPid != null) {
                checkFactoryPidIndex(factoryPid);
                Long oldChangeCount = m_factoryChangeCount.get(pid.getServicePid());
                TargetedPID oldTargetedPID = m_factoryTargetedPids.get(pid.getServicePid());
                if (oldChangeCount != null && changeCount <= oldChangeCount && factoryPid.equals(oldTargetedPID)) {
                	return false;
                }
                m_factoryChangeCount.put(pid.getServicePid(), changeCount);
                m_factoryConfigurations.put(pid.getServicePid(), props);
                m_factoryTargetedPids.put(pid.getServicePid(), factoryPid);
                if (m_enabled && isSatisfied()) {
                    if (m_singleComponent != null && !m_componentMetadata.isObsoleteFactoryComponentFactory()) {
                        AbstractComponentManager<S> scm = m_singleComponent;
                        scms.put( scm, mergeProperties( pid.getServicePid() ) );
                        m_singleComponent = null;
                        m_components.put(pid.getServicePid(), scm);
                    } else if (m_components.containsKey(pid.getServicePid())) {
                        scms.put( m_components.get(pid.getServicePid()), mergeProperties( pid.getServicePid())  );
                    } else {
                        AbstractComponentManager<S> scm = createComponentManager(true);
                        m_components.put(pid.getServicePid(), scm);
                        scms.put( scm, mergeProperties( pid.getServicePid())  );
                        created = true;
                    }
                } else {
                    return false;
                }

            } else {
                //singleton pid
                int index = getSingletonPidIndex(pid);
                if (m_changeCount[index] != null && changeCount <= m_changeCount[index] && pid.equals(m_targetedPids[index])) {
                	return false;
                }
                m_changeCount[index] = changeCount;
                m_targetedPids[index] = pid;
                m_configurations[index] = props;
                if (m_enabled && isSatisfied()) {
                    if (m_singleComponent != null) {
                        scms.put( m_singleComponent, mergeProperties( pid.getServicePid() ) );
                    }
                    else if ( m_factoryPidIndex != null)
                    {
                        for (Map.Entry<String, AbstractComponentManager<S>> entry: m_components.entrySet())
                        {
                            scms.put(entry.getValue(), mergeProperties( entry.getKey()));
                        }
                    }
                    else
                    {
                        m_singleComponent = createComponentManager(false);
                        scms.put( m_singleComponent, mergeProperties( pid.getServicePid() ) );
                        created = true;
                    }
                } else {
                    return false;
                }

            }

        }


        // we have the icm.
        //properties is all the configs merged together (without any possible component factory info.

        final boolean enable = created && m_enabled;// TODO WTF?? && getComponentMetadata().isEnabled();
        for ( Map.Entry<AbstractComponentManager<S>,Map<String, Object>> entry: scms.entrySet())
        {
            // configure the component
            entry.getKey().reconfigure(entry.getValue(), false, factoryPid);
            logger.log(LogService.LOG_DEBUG,
                "ImmediateComponentHolder Finished configuring the dependency managers for component for pid {0} ", null,
                pid );
            if (enable) {
                entry.getKey().enable(false);
                logger.log(LogService.LOG_DEBUG,
                    "ImmediateComponentHolder Finished enabling component for pid {0} ", null,
                    pid );
            } else {
                logger.log(LogService.LOG_DEBUG,
                    "ImmediateComponentHolder Will not enable component for pid {0}: holder enabled state: {1}, metadata enabled: {2} ", null,
                    pid, m_enabled, m_componentMetadata.isEnabled());
            }
        }
        return created;
    }

    private Map<String, Object> mergeProperties(String servicePid) {
        Map<String, Object> properties = new HashMap<>(m_componentMetadata.getProperties());
        List<String> pids = null;
        boolean isDS13 = m_componentMetadata.getDSVersion().isDS13();
        if (isDS13)
        {
            pids = new ArrayList<>();
            if (properties.get(Constants.SERVICE_PID) instanceof String)
            {
                pids.add((String) properties.get(Constants.SERVICE_PID));
            }
        }
        for (int i = 0; i < m_configurations.length; i++)
        {
            if ( m_factoryPidIndex != null && i == m_factoryPidIndex
                && !( m_componentMetadata.isObsoleteFactoryComponentFactory() && servicePid == null)) //obsolete special case
            {
                copyTo(properties, m_factoryConfigurations.get(servicePid));
                if (isDS13)
                {
                    pids.add((String) m_factoryConfigurations.get(servicePid).get(Constants.SERVICE_PID));
                }
            }
            else if ( m_configurations[i] != null )
            {
                copyTo(properties, m_configurations[i]);
                if (isDS13)
                {
                    pids.add((String) m_configurations[i].get(Constants.SERVICE_PID));
                }
            }
        }
        if (isDS13 && !pids.isEmpty())
        {
        	if ( pids.size() == 1 )
        	{
        		properties.put(Constants.SERVICE_PID, pids.get(0));
        	}
        	else
        	{
        		properties.put(Constants.SERVICE_PID, pids);
        	}
        }
        return properties;
    }

    private int getSingletonPidIndex(TargetedPID pid) {
        int index = m_componentMetadata.getPidIndex(pid);
        if (index == -1) {
            logger.log(LogService.LOG_ERROR,
                "Unrecognized pid {0}, expected one of {1}", null,
                 pid,
                m_componentMetadata.getConfigurationPid() );
            throw new IllegalArgumentException("Unrecognized pid "
                + pid);
        }
        if (m_factoryPidIndex != null && index == m_factoryPidIndex) {
            logger.log(LogService.LOG_ERROR,
                "singleton pid {0} supplied, but matches an existing factory pid at index: {1}",
                null, pid, m_factoryPidIndex );
            throw new IllegalStateException(
                "Singleton pid supplied matching a previous factory pid "
                    + pid);
        }
        return index;
    }

    //TODO update error messages so they make sense for deleting config too.
    private void checkFactoryPidIndex(TargetedPID factoryPid) {
        int index = m_componentMetadata.getPidIndex(factoryPid);
        if (index == -1) {
            logger.log(LogService.LOG_ERROR,
                "Unrecognized factory pid {0}, expected one of {1}", null,
                factoryPid,
                m_componentMetadata.getConfigurationPid() );
            throw new IllegalArgumentException(
                "Unrecognized factory pid " + factoryPid);
        }
        if (m_configurations[index] != null) {
            logger.log(LogService.LOG_ERROR,
                "factory pid {0}, but this pid is already supplied as a singleton: {1} at index {2}", null,
                factoryPid, Arrays.asList(m_targetedPids), index);
            throw new IllegalStateException(
                "Factory pid supplied after all non-factory configurations supplied "
                    + factoryPid);
        }
        if (m_factoryPidIndex == null) {
            m_factoryPidIndex = index;
        } else if (index != m_factoryPidIndex) {
            logger.log(LogService.LOG_ERROR,
                "factory pid {0} supplied for index {1}, but a factory pid previously supplied at index {2}", null,
                factoryPid, index, m_factoryPidIndex );
            throw new IllegalStateException(
                "Factory pid supplied at wrong index " + factoryPid);
        }
    }

    protected static void copyTo( Map<String, Object> target, Dictionary<String, ?> source )
    {

        for ( Enumeration<String> keys = source.keys(); keys.hasMoreElements(); )
        {
            String key = keys.nextElement();
            Object value = source.get(key);
            target.put(key, value);
        }
    }

    /**
     * Determine if the holder is satisfied with configurations
     * @return true if configuration optional or all pids supplied with configurations
     */
    private boolean isSatisfied() {
        if ( m_componentMetadata.isConfigurationOptional() || m_componentMetadata.isConfigurationIgnored() )
        {
            return true;
        }
        for ( int i = 0; i < m_componentMetadata.getConfigurationPid().size(); i++)
        {
            if ( m_configurations[i] != null)
            {
                continue;
            }
            if ( m_factoryPidIndex != null && m_factoryPidIndex == i)
            {
                continue;
            }
            return false;
        }
        return true;
    }

    @Override
    public List<? extends ComponentManager<?>> getComponents()
        {
        synchronized ( m_components )
        {
            return getComponentManagers( );
        }
        }


    @Override
    public boolean isEnabled() {
        return m_enabled;
    }


    private void wait(Promise<Void> promise)
    {
        boolean waited = false;
        boolean interrupted = false;
        while ( !waited )
        {
            try
            {
                promise.getValue();
                waited = true;
            }
            catch ( InterruptedException e )
            {
                interrupted = true;
            }
            catch (InvocationTargetException e)
            {
                //this is not going to happen
            }
        }
        if ( interrupted )
        {
            Thread.currentThread().interrupt();
        }
    }

    @Override
    public Promise<Void> enableComponents( final boolean async )
    {
        synchronized (enableLock)
        {
            if ( m_enablePromise != null)
            {
                return m_enablePromise;
            }
            wait( m_disablePromise );

            List<AbstractComponentManager<S>> cms = new ArrayList<>();
            synchronized ( m_components )
            {
                if ( isSatisfied() )
                {
                    if ( m_factoryPidIndex == null ||
                            (m_componentMetadata.isObsoleteFactoryComponentFactory() && !m_componentMetadata.isConfigurationRequired()))
                    {
                        m_singleComponent = createComponentManager(false);
                        cms.add( m_singleComponent );
                        m_singleComponent.reconfigure(mergeProperties( null ), false, null);
                    }
                    if ( m_factoryPidIndex != null)
                    {
                        for (String pid: m_factoryConfigurations.keySet()) {
                            AbstractComponentManager<S> scm = createComponentManager(true);
                            m_components.put(pid, scm);
                            scm.reconfigure( mergeProperties( pid ), false, new TargetedPID(pid));
                            cms.add( scm );
                        }
                    }
                }
                m_enabled = true;
            }
            List<Promise<Void>> promises = new ArrayList<>();
            for ( AbstractComponentManager<S> cm : cms )
            {
                promises.add(cm.enable( async ));
            }
            m_enablePromise = new Deferred<List<Void>>().resolveWith(Promises.<Void, Void>all(promises));
            m_disablePromise = null;
            return m_enablePromise;
        }
    }


    @Override
    public Promise<Void> disableComponents( final boolean async )
    {
        synchronized (enableLock)
        {
            if ( m_disablePromise != null)
            {
                return m_disablePromise;
            }
            wait( m_enablePromise );

            List<AbstractComponentManager<S>> cms;
            synchronized ( m_components )
            {
                m_enabled = false;

                cms = getDirectComponentManagers( );
                clearComponents();
            }
            List<Promise<Void>> promises = new ArrayList<>();
            for ( AbstractComponentManager<S> cm : cms )
            {
                promises.add(cm.disable( async ));
            }
            m_disablePromise = new Deferred<List<Void>>().resolveWith(Promises.<Void, Void>all(promises));
            m_enablePromise = null;
            return m_disablePromise;
        }
    }


    @Override
    public void disposeComponents( final int reason )
    {
        List<AbstractComponentManager<S>> cms;
        synchronized ( m_components )
        {
            cms = getDirectComponentManagers( );
            clearComponents();
        }
        for ( AbstractComponentManager<S> cm : cms )
        {
            cm.dispose( reason );
        }
    }


    @Override
    public void disposed( SingleComponentManager<S> component )
    {
        // ensure the component is removed from the components map
        synchronized ( m_components )
        {
            if ( !m_components.isEmpty() )
            {
                for ( Iterator<AbstractComponentManager<S>> vi = m_components.values().iterator(); vi.hasNext(); )
                {
                    if ( component == vi.next() )
                    {
                        vi.remove();
                        break;
                    }
                }
            }

            if ( component == m_singleComponent )
            {
                m_singleComponent = null;
            }
        }
    }

    /**
     * Compares this {@code ImmediateComponentHolder} object to another object.
     *
     * <p>
     * A ImmediateComponentHolder is considered to be <b>equal to </b> another
     * ImmediateComponentHolder if the component names are equal(using
     * {@code String.equals}) and they have the same bundle activator
     *
     * @param object The {@code ImmediateComponentHolder} object to be compared.
     * @return {@code true} if {@code object} is a
     *         {@code ImmediateComponentHolder} and is equal to this object;
     *         {@code false} otherwise.
     */
    @Override
    public boolean equals(Object object)
    {
        if (!(object instanceof ConfigurableComponentHolder))
        {
            return false;
        }

        @SuppressWarnings("unchecked")
		ConfigurableComponentHolder<S> other = (ConfigurableComponentHolder<S>) object;
        return m_activator == other.m_activator
            && getName().equals(other.getName());
    }

    /**
     * Returns a hash code value for the object.
     *
     * @return An integer which is a hash code value for this object.
     */
    @Override
    public int hashCode()
    {
        return getName().hashCode();
    }

    @Override
    public String toString()
    {
        return "[ImmediateComponentHolder:" + getName() + "]";
    }

    String getName()
    {
        return m_componentMetadata.getName();
    }

    //---------- internal

    /**
     * Returns all component managers from the map and the single component manager, optionally also removing them
     * from the map. If there are no component managers, <code>null</code>
     * is returned.  Must be called synchronized on m_components.
     */
    List<AbstractComponentManager<S>> getComponentManagers( )
    {
        List<AbstractComponentManager<S>> cms = new ArrayList<>();
        if ( m_singleComponent != null)
        {
            m_singleComponent.getComponentManagers(cms);
        }

        for (AbstractComponentManager<S> cm: m_components.values())
        {
            cm.getComponentManagers(cms);
        }
        return cms;
    }

    List<AbstractComponentManager<S>> getDirectComponentManagers( )
    {
        List<AbstractComponentManager<S>> cms = new ArrayList<>();
        if ( m_singleComponent != null)
        {
            cms.add(m_singleComponent);
        }
        cms.addAll(m_components.values());
        return cms;
    }

    void clearComponents()
    {
        m_components.clear();
        m_singleComponent = null;
    }


    @Override
    public ComponentLogger getLogger() {
        return logger;
    }

    @Override
    public TargetedPID getConfigurationTargetedPID(TargetedPID pid, TargetedPID factoryPid)
    {
        if ( factoryPid == null )
        {
            int index = m_componentMetadata.getPidIndex(pid);
            if (index != -1)
            {
                return m_targetedPids[index];
            }
            return null;
        }
        //each factory configured component may have a different factory targeted pid.
        synchronized (m_components)
        {
            return m_factoryTargetedPids.get(pid.getServicePid());
        }
    }

}
