/*******************************************************************************
 * Copyright (c) 2008, 2010 VMware Inc.
 * 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:
 *   VMware Inc. - initial contribution
 *******************************************************************************/

package org.eclipse.virgo.kernel.userregion.internal;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.virgo.nano.shim.scope.Scope;
import org.eclipse.virgo.nano.shim.scope.ScopeFactory;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.eclipse.virgo.kernel.install.artifact.ScopeServiceRepository;

/**
 * {@link ServiceScopingStrategy} encapsulates the service scoping algorithms used by {@link ServiceScopingRegistryHook}
 * .
 * <p />
 * 
 * <strong>Concurrent Semantics</strong><br />
 * 
 * Thread safe.
 * 
 */
final class ServiceScopingStrategy {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private final ScopeFactory scopeFactory;

    private ScopeServiceRepository scopeServiceRepository;

    public ServiceScopingStrategy(ScopeFactory scopeFactory, ScopeServiceRepository scopeServiceRepository) {
        this.scopeFactory = scopeFactory;
        this.scopeServiceRepository = scopeServiceRepository;
    }

    /**
     * Returns true if and only the given service reference is potentially visible from the given bundle context. This
     * is the case if and only if the service reference is in the same scope as the bundle context or the service
     * reference is in the global scope.
     * <p/>
     * The given service reference may not be actually visible from the given bundle context if the given service
     * reference is in the global scope, the given bundle context is scoped, and there is another service in the scope
     * which shadows the given service reference.
     */
    boolean isPotentiallyVisible(ServiceReference<?> serviceReference, BundleContext consumingBundleContext) {
        boolean matchesScope = true;
        Scope serviceScope = getServiceScope(serviceReference);
        if (serviceScope != null && !serviceScope.isGlobal()) {
            Scope bundleScope = this.scopeFactory.getBundleScope(consumingBundleContext.getBundle());
            if (!bundleScope.equals(serviceScope)) {
                matchesScope = false;
            }
        }
        return matchesScope;
    }

    /**
     * Takes the given collection of service references and restricts the collection to the scope of the given bundle
     * context. It is not sufficient simply to discard service references in non-matching scopes because the global
     * scope may (see below) be searched after an application scope.
     * <p/>
     * The exact behaviour depends on the {@link ScopeServiceRepository} which models, with varying degrees of accuracy,
     * the services which are published in a particular scope. One variation in accuracy is due to the fact that web
     * bundles typically have their application context files in a directory other than <code>META-INF/spring</code> and
     * this is not currently taken into account when the repository is built. Another variation is due to the fact that
     * Spring DM supports a manifest header which specifies the directory containing application context files. Again
     * this is not currently taken into account when the repository is built.
     */
    void scopeReferences(Collection<ServiceReference<?>> references, BundleContext consumingBundleContext, String className, String filter) {
        Bundle consumingBundle = consumingBundleContext.getBundle();
        Scope lookupScope = getLookupScope(consumingBundle, className, filter);
        Scope consumerScope = getBundleScope(consumingBundle);
        
        /*
         * If the consumer is scoped, look in the consumer's scope before looking in the global scope. This avoids wrongly using
         * the global scope when the service model did not include services which are nevertheless present in the application scope.
         * If some of the service references are in the consumer's scope, restrict the set to just those.
         */
        if (lookupScope.isGlobal() && !consumerScope.isGlobal()) {
            Collection<ServiceReference<?>> scopedReferences = getScopedReferences(references, consumerScope);
            if (!scopedReferences.isEmpty()) {
                removeAllExcept(references, scopedReferences);
                return;
            }
        }
        restrictServicesToScope(references, lookupScope);
    }

    private void removeAllExcept(Collection<ServiceReference<?>> references, Collection<ServiceReference<?>> scopedReferences) {
        /*
         * The simple implementation of clearing references and then using addAll to add
         * in scopedReferences is no good as the find hook is passed a shrinkable collection
         * that does not support add or addAll.
         */
        Iterator<ServiceReference<?>> iterator = references.iterator();
        while (iterator.hasNext()) {
            ServiceReference<?> ref = iterator.next();
            if (!scopedReferences.contains(ref)) {
                iterator.remove();
            }
        }
    }

    private Collection<ServiceReference<?>> getScopedReferences(Collection<ServiceReference<?>> references, Scope scope) {
        Collection<ServiceReference<?>> scopedReferences = new HashSet<ServiceReference<?>>();
        logger.debug("References input to getScopedReferences: {}", references.size());
        Iterator<ServiceReference<?>> iterator = references.iterator();
        while (iterator.hasNext()) {
            ServiceReference<?> ref = iterator.next();
            Scope serviceScope = getServiceScope(ref);
            if (scope.equals(serviceScope)) {
                logger.debug("Adding {} ", ref);
                scopedReferences.add(ref);
            }
        }
        logger.debug("References output from getScopedReferences: {}", scopedReferences.size());
        return scopedReferences;
    }

    private void restrictServicesToScope(Collection<ServiceReference<?>> references, Scope scope) {
        logger.debug("Before filtering: {}", references.size());
        Iterator<ServiceReference<?>> iterator = references.iterator();
        while (iterator.hasNext()) {
            ServiceReference<?> ref = (ServiceReference<?>) iterator.next();
            Scope serviceScope = getServiceScope(ref);
            if (!scope.equals(serviceScope)) {
                logger.debug("Removing {} ", ref);
                iterator.remove();
            }
        }
        logger.debug("After filtering: {}", references.size());
    }

    /**
     * Gets the {@link Scope} in which this lookup is being performed.
     */
    private Scope getLookupScope(Bundle consumer, String name, String filter) {
        Scope consumerScope = getBundleScope(consumer);
        /*
         * The lookup scope is that of the consuming bundle unless the consuming bundle is in an application scope with
         * no service matching the given name and filter in which case the lookup scope is global.
         */
        Scope lookupScope = !consumerScope.isGlobal() && !scopeHasMatchingService(consumerScope, name, filter) ? this.scopeFactory.getGlobalScope()
            : consumerScope;
        logger.debug("{} > {} [{}] ({})", new Object[] { lookupScope, name, filter, consumer });
        return lookupScope;
    }

    private Scope getBundleScope(Bundle consumer) {
        return this.scopeFactory.getBundleScope(consumer);
    }

    private boolean scopeHasMatchingService(Scope scope, String name, String filter) {
        try {
            return this.scopeServiceRepository.scopeHasMatchingService(scope.getScopeName(), name, filter);
        } catch (InvalidSyntaxException e) {
            logger.warn("Filter '{}' is not valid", e, filter);
            return false;
        }
    }

    private Scope getServiceScope(ServiceReference<?> ref) {
        try {
            return this.scopeFactory.getServiceScope(ref);
        } catch (IllegalStateException ise) {
            return null;
        }
    }

}