/*
 * 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.ipojo.dependency.impl;

import org.apache.felix.ipojo.Factory;
import org.apache.felix.ipojo.dependency.interceptors.ServiceBindingInterceptor;
import org.apache.felix.ipojo.dependency.interceptors.ServiceRankingInterceptor;
import org.apache.felix.ipojo.dependency.interceptors.ServiceTrackingInterceptor;
import org.apache.felix.ipojo.dependency.interceptors.TransformedServiceReference;
import org.apache.felix.ipojo.util.*;
import org.osgi.framework.Constants;
import org.osgi.framework.Filter;
import org.osgi.framework.ServiceReference;

import java.util.*;

import static org.apache.felix.ipojo.util.DependencyModel.DependencyEventType;
import static org.apache.felix.ipojo.util.DependencyModel.DependencyEventType.ARRIVAL;
import static org.apache.felix.ipojo.util.DependencyModel.DependencyEventType.DEPARTURE;
import static org.apache.felix.ipojo.util.DependencyModel.DependencyEventType.MODIFIED;

/**
 * This class is handling the transformations between the base service set and the selected service set.
 * It handles the matching services and the selected service set.
 * As this class is tied to the dependency model, it reuses the same locks objects.
 */
public class ServiceReferenceManager implements TrackerCustomizer {

    /**
     * The dependency.
     */
    private final DependencyModel m_dependency;
    /**
     * The list of all matching service references. This list is a
     * subset of tracked references. This set is computed according
     * to the filter and the {@link DependencyModel#match(ServiceReference)} method.
     */
    private final Map<ServiceReference, TransformedServiceReference> m_matchingReferences = new
            LinkedHashMap<ServiceReference, TransformedServiceReference>();
    /**
     * The comparator to sort service references.
     */
    private Comparator<ServiceReference> m_comparator;
    /**
     * The LDAP filter object selecting service references
     * from the set of providers providing the required specification.
     */
    private Filter m_filter;
    /**
     * The list of selected service references.
     */
    private List<? extends ServiceReference> m_selectedReferences = new ArrayList<ServiceReference>();
    /**
     * The service ranking interceptor.
     */
    private ServiceRankingInterceptor m_rankingInterceptor;
    /**
     * Service Ranking Interceptor trackers.
     */
    private Tracker m_rankingInterceptorTracker;

    /**
     * Service Tracking Interceptor trackers.
     */
    private Tracker m_trackingInterceptorTracker;

    /**
     * Service Binding Interceptor trackers.
     */
    private Tracker m_bindingInterceptorTracker;

    /**
     * The set of tracking interceptors.
     * TODO this set should be sorted according to the OSGi ranking policy.
     * The filter is always the last interceptor.
     */
    private LinkedList<ServiceTrackingInterceptor> m_trackingInterceptors = new
            LinkedList<ServiceTrackingInterceptor>();

    /**
     * The set of binding interceptors.
     * TODO this set should be sorted according to the OSGi ranking policy.
     */
    private LinkedList<ServiceBindingInterceptor> m_bindingInterceptors = new
            LinkedList<ServiceBindingInterceptor>();

    /**
     * Creates the service reference manager.
     *
     * @param dep        the dependency
     * @param filter     the filter
     * @param comparator the comparator
     */
    public ServiceReferenceManager(DependencyModel dep, Filter filter, Comparator<ServiceReference> comparator) {
        m_dependency = dep;
        m_filter = filter;
        // The Filter based service tracking interceptor needs to be created every time even if the filter is null.
        // This arises from the potential re-implementation of the match method in the dependency implementation.
        // It must be the last interceptor as the chain ends on the filter matching. (FELIX-4199)
        m_trackingInterceptors.addLast(new FilterBasedServiceTrackingInterceptor(m_filter));

        if (comparator != null) {
            m_comparator = comparator;
            m_rankingInterceptor = new ComparatorBasedServiceRankingInterceptor(comparator);
        } else {
            m_rankingInterceptor = new EmptyBasedServiceRankingInterceptor();
        }
    }

    public void open() {
        // The opening order matters, first binding, then ranking and finally tracking.
        m_bindingInterceptorTracker = new Tracker(m_dependency.getBundleContext(),
                ServiceBindingInterceptor.class.getName(),
                new TrackerCustomizer() {

                    public boolean addingService(ServiceReference reference) {
                        return DependencyProperties.match(reference, m_dependency);
                    }

                    public void addedService(ServiceReference reference) {
                        ServiceBindingInterceptor interceptor = (ServiceBindingInterceptor) m_bindingInterceptorTracker
                                .getService(reference);
                        if (interceptor != null) {
                            addBindingInterceptor(interceptor);
                        } else {
                            m_dependency.getComponentInstance().getFactory().getLogger().log(Log.ERROR,
                                    "Cannot retrieve the interceptor object from service reference " + reference
                                            .getProperty(Constants.SERVICE_ID) + " - " + reference.getProperty
                                            (Factory.INSTANCE_NAME_PROPERTY));
                        }
                    }

                    public void modifiedService(ServiceReference reference, Object service) {
                        // Not supported.
                    }

                    public void removedService(ServiceReference reference, Object service) {
                        if (service != null && service instanceof ServiceBindingInterceptor &&
                                m_bindingInterceptors.contains(service)
                                ) {
                            removeBindingInterceptor((ServiceBindingInterceptor) service);
                        }
                    }
                }
        );
        m_bindingInterceptorTracker.open();

        // Initialize the service interceptor tracker.
        m_rankingInterceptorTracker = new Tracker(m_dependency.getBundleContext(), ServiceRankingInterceptor.class.getName(),
                new TrackerCustomizer() {

                    public boolean addingService(ServiceReference reference) {
                        return DependencyProperties.match(reference, m_dependency);
                    }

                    public void addedService(ServiceReference reference) {
                        ServiceRankingInterceptor interceptor = (ServiceRankingInterceptor) m_rankingInterceptorTracker
                                .getService(reference);
                        if (interceptor != null) {
                            setRankingInterceptor(interceptor);
                        } else {
                            m_dependency.getComponentInstance().getFactory().getLogger().log(Log.ERROR,
                                    "Cannot retrieve the interceptor object from service reference " + reference
                                            .getProperty(Constants.SERVICE_ID) + " - " + reference.getProperty
                                            (Factory.INSTANCE_NAME_PROPERTY));
                        }
                    }

                    public void modifiedService(ServiceReference reference, Object service) {
                        // Not supported yet.
                        // TODO it would be nice to support the modification of the interceptor TARGET property.
                    }

                    public void removedService(ServiceReference reference, Object service) {
                        if (service == m_rankingInterceptor) {
                            m_rankingInterceptor.close(m_dependency);
                            // Do we have another one ?
                            ServiceReference anotherReference = m_rankingInterceptorTracker.getServiceReference();
                            if (anotherReference != null) {
                                ServiceRankingInterceptor interceptor = (ServiceRankingInterceptor) m_rankingInterceptorTracker
                                        .getService(anotherReference);
                                if (interceptor != null) setRankingInterceptor(interceptor);
                            } else if (m_comparator != null) {
                                // If we have a comparator, we restore the comparator.
                                setComparator(m_comparator);
                            } else {
                                // If we have neither comparator nor interceptor use an empty interceptor.
                                setRankingInterceptor(new EmptyBasedServiceRankingInterceptor());
                            }
                        }
                    }
                });
        m_rankingInterceptorTracker.open();

        m_trackingInterceptorTracker = new Tracker(m_dependency.getBundleContext(),
                ServiceTrackingInterceptor.class.getName(),
                new TrackerCustomizer() {

                    public boolean addingService(ServiceReference reference) {
                        return DependencyProperties.match(reference, m_dependency);
                    }

                    public void addedService(ServiceReference reference) {
                        ServiceTrackingInterceptor interceptor = (ServiceTrackingInterceptor) m_trackingInterceptorTracker
                                .getService(reference);

                        if (interceptor != null) {
                            addTrackingInterceptor(interceptor);
                        } else {
                            m_dependency.getComponentInstance().getFactory().getLogger().log(Log.ERROR,
                                    "Cannot retrieve the interceptor object from service reference " + reference
                                            .getProperty(Constants.SERVICE_ID) + " - " + reference.getProperty
                                            (Factory.INSTANCE_NAME_PROPERTY));
                        }
                    }

                    public void modifiedService(ServiceReference reference, Object service) {
                        // Not supported yet.
                        // TODO it would be nice to support the modification of the interceptor TARGET property.
                    }

                    public void removedService(ServiceReference reference, Object service) {
                        if (service != null && service instanceof ServiceTrackingInterceptor &&
                                m_trackingInterceptors.contains(service)
                                ) {
                            removeTrackingInterceptor((ServiceTrackingInterceptor) service);
                        }
                    }
                });

        m_trackingInterceptorTracker.open();
    }

    private void addTrackingInterceptor(ServiceTrackingInterceptor interceptor) {
        // A new interceptor arrives. Insert it at the beginning of the list.
        ChangeSet changeset;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_trackingInterceptors.addFirst(interceptor);
            interceptor.open(m_dependency);
            changeset = computeChangesInMatchingServices();
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        m_dependency.onChange(changeset);
    }

    private void removeTrackingInterceptor(ServiceTrackingInterceptor interceptor) {
        ChangeSet changeset;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_trackingInterceptors.remove(interceptor);
            interceptor.close(m_dependency);
            changeset = computeChangesInMatchingServices();
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        m_dependency.onChange(changeset);
    }

    private void addBindingInterceptor(ServiceBindingInterceptor interceptor) {
        // A new interceptor arrives, open it.
        // Binding interceptor cannot modify existing bindings.
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_bindingInterceptors.add(interceptor);
            interceptor.open(m_dependency);
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
    }

    private void removeBindingInterceptor(ServiceBindingInterceptor interceptor) {
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_bindingInterceptors.remove(interceptor);
            interceptor.close(m_dependency);
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
    }

    public Object weavingServiceBinding(DependencyModel.ServiceBindingHolder sbh) {
        Object svc = sbh.service;
        try {
            m_dependency.acquireReadLockIfNotHeld();
            for (ServiceBindingInterceptor interceptor : m_bindingInterceptors) {
                // Interceptor are not allowed to return null.
                svc = interceptor.getService(m_dependency, sbh.reference, svc);
            }
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
        return svc;
    }

    public void unweavingServiceBinding(DependencyModel.ServiceBindingHolder sbh) {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            for (ServiceBindingInterceptor interceptor : m_bindingInterceptors) {
                interceptor.ungetService(m_dependency, sbh.reference);
            }
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    private ChangeSet computeChangesInMatchingServices() {
        if (m_dependency.getTracker() == null || m_dependency.getTracker().getServiceReferences() == null) {
            // Tracker closed, no problem
            m_dependency.getComponentInstance().getFactory().getLogger().log(Logger.DEBUG,
                    "Tracker closed when recomputing dependency " + m_dependency.getId());
            return new ChangeSet(Collections.<ServiceReference>emptyList(),
                    Collections.<ServiceReference>emptyList(),
                    Collections.<ServiceReference>emptyList(),
                    null,
                    null,
                    null,
                    null);
        }
        // The set of interceptor has changed.
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            // The tracker is open, we must recheck all services.
            ServiceReference oldBest = getFirstService();
            // Recompute the matching services.
            m_matchingReferences.clear();
            final List<ServiceReference> serviceReferencesList = m_dependency.getTracker().getServiceReferencesList();
            if (serviceReferencesList != null) {
                for (ServiceReference reference : serviceReferencesList) {
                    TransformedServiceReference ref = new TransformedServiceReferenceImpl(reference);
                    ref = accept(ref);
                    if (ref != null) {
                        m_matchingReferences.put(reference, ref);
                    }
                }
            }
            m_dependency.getComponentInstance().getFactory().getLogger().log(Logger.DEBUG,
                    "Matching services have been recomputed: " + ServiceReferenceUtils.toString(m_matchingReferences.values()));


            // We have the new matching set.
            List<ServiceReference> beforeRanking = getSelectedServices();

            final List<ServiceReference> allServices = getMatchingServices();
            List<ServiceReference> references;
            if (allServices.isEmpty()) {
                references = Collections.emptyList();
            } else {
                m_dependency.getComponentInstance().getFactory().getLogger().log(Logger.DEBUG,
                        "iPOJO >> Calling getServiceReferences on the interceptor " + m_rankingInterceptor);
                references = m_rankingInterceptor.getServiceReferences(m_dependency, allServices);
            }

            RankingResult result = computeDifferences(beforeRanking, references);
            m_selectedReferences = result.selected;

            ServiceReference newFirst = getFirstService();
            ServiceReference modified = null;
            if (ServiceReferenceUtils.haveSameServiceId(oldBest, newFirst) && ServiceReferenceUtils
                    .haveSameProperties(oldBest, newFirst)) {
                modified = newFirst;
            }
            return new ChangeSet(getSelectedServices(), result.departures, result.arrivals, oldBest, getFirstService(),
                    null, modified);
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
    }

    public List<ServiceReference> getMatchingServices() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return new ArrayList<ServiceReference>(m_matchingReferences.values());
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public List<ServiceReference> getSelectedServices() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return new ArrayList<ServiceReference>(m_selectedReferences);
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public ServiceReference getFirstService() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            if (m_selectedReferences.isEmpty()) {
                return null;
            }
            return m_selectedReferences.get(0);
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public boolean contains(ServiceReference ref) {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return m_selectedReferences.contains(ref);
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public void reset() {
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_rankingInterceptor.close(m_dependency);
            for (ServiceTrackingInterceptor interceptor : m_trackingInterceptors) {
                interceptor.close(m_dependency);
            }
            m_trackingInterceptors.clear();
            m_matchingReferences.clear();
            m_selectedReferences = new ArrayList<TransformedServiceReference>();
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }

    }

    public boolean addingService(ServiceReference reference) {
        // We accept all service references except if we are frozen or broken. In these case, just ignore everything.

        // We are doing two tests, we must get the read lock
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return !(m_dependency.getState() == DependencyModel.BROKEN || m_dependency.isFrozen());
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    /**
     * Checks if the given reference is accepted.
     * This method is called when holding the write lock on the dependency.
     *
     * @param reference the reference
     * @param <S> the service interface
     * @return the transformed reference, null if rejected
     */
    private <S> TransformedServiceReference<S> accept(TransformedServiceReference<S> reference) {
        TransformedServiceReference<S> accumulator = reference;
        for (ServiceTrackingInterceptor interceptor : m_trackingInterceptors) {
            TransformedServiceReference<S> accepted = interceptor.accept(m_dependency,
                    m_dependency.getBundleContext(), accumulator);
            if (accepted != null) {
                accumulator = accepted;
            } else {
                // refused by an interceptor
                m_dependency.getComponentInstance().getFactory().getLogger().log(Log.INFO,
                        "The service reference " + reference.getProperty(Constants.SERVICE_ID) + " was rejected by " +
                                "interceptor " + interceptor);
                return null;
            }
        }

        return accumulator;
    }

    public void addedService(ServiceReference reference) {
        // A service was added to the tracker.

        // First, check is the tracking interceptors are accepting it.
        // The transformed reference is creates and check outside of the protected region.
        TransformedServiceReference ref = new TransformedServiceReferenceImpl(reference);

        boolean match;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            ref = accept(ref);
            if (ref != null) {
                m_matchingReferences.put(reference, ref);
            }
            match = ref != null;
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }

        if (match) {
            // Callback invoked outside of locks.
            // The called method is taking the write lock anyway.
            onNewMatchingService(ref);
            m_dependency.notifyListeners(ARRIVAL, ref, null);
        }
    }

    private void onNewMatchingService(TransformedServiceReference reference) {
        ServiceReference oldFirst;
        RankingResult result;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            // We store the currently 'first' service reference.
            oldFirst = getFirstService();

            // We apply our ranking strategy.
            result = applyRankingOnArrival(reference);
            // Set the selected services.
            m_selectedReferences = result.selected;
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        // Fire the event (outside from the synchronized region)
        fireUpdate(getSelectedServices(), result.departures, result.arrivals, oldFirst,
                getFirstService(), null, null);
    }

    private void onModificationOfAMatchingService(TransformedServiceReference reference, Object service) {
        ServiceReference oldFirst;
        RankingResult result;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            // We store the currently 'first' service reference.
            oldFirst = getFirstService();

            // We apply our ranking strategy.
            result = applyRankingOnModification(reference);
            // Set the selected services.
            m_selectedReferences = result.selected;
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        // Fire the event (outside from the synchronized region)
        fireUpdate(getSelectedServices(), result.departures, result.arrivals, oldFirst,
                getFirstService(), service, reference);
    }

    private RankingResult applyRankingOnModification(ServiceReference reference) {
        // TODO we are holding the lock here.
        List<ServiceReference> beforeRanking = getSelectedServices();
        List<ServiceReference> references = m_rankingInterceptor.onServiceModified(m_dependency, getMatchingServices(),
                reference);
        return computeDifferences(beforeRanking, references);
    }

    private void fireUpdate(List<ServiceReference> selectedServices, List<ServiceReference> departures,
                            List<ServiceReference> arrivals, ServiceReference oldFirst,
                            ServiceReference firstService, Object service, ServiceReference modified) {
        ChangeSet set = new ChangeSet(selectedServices, departures, arrivals, oldFirst, firstService, service, modified);
        m_dependency.onChange(set);
    }

    private RankingResult applyRankingOnArrival(ServiceReference ref) {
        // TODO we are holding the lock here.
        List<ServiceReference> beforeRanking = getSelectedServices();
        List<ServiceReference> references = m_rankingInterceptor.onServiceArrival(m_dependency, getMatchingServices(),
                ref);
        // compute the differences
        return computeDifferences(beforeRanking, references);

    }

    private RankingResult applyRankingOnDeparture(ServiceReference ref) {
        // TODO we are holding the lock here.
        List<ServiceReference> beforeRanking = getSelectedServices();
        List<ServiceReference> references = m_rankingInterceptor.onServiceDeparture(m_dependency, getMatchingServices(),
                ref);
        return computeDifferences(beforeRanking, references);
    }

    private RankingResult computeDifferences(List<ServiceReference> beforeRanking, List<ServiceReference> ranked) {
        // compute the differences
        List<ServiceReference> departures = new ArrayList<ServiceReference>();
        List<ServiceReference> arrivals = new ArrayList<ServiceReference>();
        // All references that are no more in the set are considered as leaving services.
        for (ServiceReference old : beforeRanking) {
            if (!ServiceReferenceUtils.containsReferenceById(ranked, old)) {
                departures.add(old);
            }
        }
        // All references that are in `references` but not in `beforeRanking` are new services
        for (ServiceReference newRef : ranked) {
            if (!ServiceReferenceUtils.containsReferenceById(beforeRanking, newRef)) {
                arrivals.add(newRef);
            }
        }

        return new RankingResult(departures, arrivals, ranked);
    }

    public void modifiedService(ServiceReference reference, Object service) {
        // We are handling a modified event, we have three case to handle
        // 1) the service was matching and does not match anymore -> it's a departure.
        // 2) the service was not matching and matches -> it's an arrival
        // 3) the service was matching and still matches -> it's a modification.

        // The dependency event to send
        DependencyEventType eventType = null;
        ServiceReference<?> eventRef = null;

        try {
            m_dependency.acquireWriteLockIfNotHeld();

            if (m_matchingReferences.containsKey(reference)) {
                // do we still accept the reference
                TransformedServiceReference initial = m_matchingReferences.get(reference);
                TransformedServiceReference accepted = new TransformedServiceReferenceImpl(reference);
                accepted = accept(accepted);
                if (accepted == null) {
                    // case 1
                    m_matchingReferences.remove(reference);
                    onDepartureOfAMatchingService(initial, service);
                    eventType = DEPARTURE;
                    eventRef = initial;
                } else {
                    // Do we have a real change
                    if (!ServiceReferenceUtils.haveSameProperties(initial, accepted)) {
                        // case 3
                        m_matchingReferences.put(reference, accepted);
                        onModificationOfAMatchingService(accepted, service);
                        eventType = MODIFIED;
                        eventRef = accepted;
                    }
                }
            } else {
                // Base does not contain the service, let's try to add it.
                TransformedServiceReference transformed = new TransformedServiceReferenceImpl(reference);
                transformed = accept(transformed);
                if (transformed != null) {
                    // case 2
                    m_matchingReferences.put(reference, transformed);
                    onNewMatchingService(transformed);
                    eventType = ARRIVAL;
                    eventRef = transformed;
                }
            }
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }

        if (eventType != null) {
            m_dependency.notifyListeners(eventType, eventRef, service);
        }
    }

    public void onDepartureOfAMatchingService(TransformedServiceReference reference, Object service) {
        ServiceReference oldFirst;
        RankingResult result = null;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            // We store the currently 'first' service reference.
            oldFirst = getFirstService();
            // We apply our ranking strategy.
            result = applyRankingOnDeparture(reference);
            // Set the selected services.
            m_selectedReferences = result.selected;
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        // Fire the event (outside from the synchronized region)
        fireUpdate(getSelectedServices(), result.departures, result.arrivals, oldFirst,
                getFirstService(), service, null);
    }

    public void removedService(ServiceReference reference, Object service) {
        // A service is leaving
        // 1 - the service was in the matching set => real departure
        // 2 - the service was not in the matching set => nothing do do.

        TransformedServiceReference initial = null;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            initial = m_matchingReferences.remove(reference);
            if (initial != null) {
                // Case 1
                onDepartureOfAMatchingService(initial, service);
            }
            // else case 2.
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }

        // Call the listeners outside the locked region.
        if (initial != null) {
            m_dependency.notifyListeners(DEPARTURE, initial, service);
        }

    }

    /**
     * A new filter is set.
     * We have to recompute the set of matching services.
     *
     * @param filter  the new filter
     * @param tracker the tracker
     */
    public ChangeSet setFilter(Filter filter, Tracker tracker) {
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_filter = filter;

            if (!m_trackingInterceptors.isEmpty()) {
                ServiceTrackingInterceptor interceptor = m_trackingInterceptors.getLast();
                if (interceptor != null && interceptor instanceof FilterBasedServiceTrackingInterceptor) {
                    // Remove it first.
                    m_trackingInterceptors.removeLast();
                }
            }

            if (m_filter != null) {
                // Add the new one.
                ServiceTrackingInterceptor newInterceptor = new FilterBasedServiceTrackingInterceptor(m_filter);
                m_trackingInterceptors.addLast(newInterceptor);
            }

            if (tracker == null) {
                // Tracker closed, no problem
                return new ChangeSet(Collections.<ServiceReference>emptyList(),
                        Collections.<ServiceReference>emptyList(),
                        Collections.<ServiceReference>emptyList(),
                        null,
                        null,
                        null,
                        null);
            } else {
                // The tracker is open, we must recheck all services.
                ServiceReference oldBest = getFirstService();

                // Recompute the matching services.
                m_matchingReferences.clear();
                final List<ServiceReference> serviceReferencesList = tracker.getServiceReferencesList();
                if (serviceReferencesList != null) {
                    for (ServiceReference reference : serviceReferencesList) {
                        TransformedServiceReference ref = new TransformedServiceReferenceImpl(reference);
                        ref = accept(ref);
                        if (ref != null) {
                            m_matchingReferences.put(reference, ref);
                        }
                    }
                }

                // We have the new matching set.

                List<ServiceReference> beforeRanking = getSelectedServices();

                final List<ServiceReference> allServices = getMatchingServices();
                List<ServiceReference> references;
                if (allServices.isEmpty()) {
                    references = Collections.emptyList();
                } else {
                    references = m_rankingInterceptor.getServiceReferences(m_dependency, allServices);
                }

                RankingResult result = computeDifferences(beforeRanking, references);
                m_selectedReferences = result.selected;
                return new ChangeSet(getSelectedServices(), result.departures, result.arrivals, oldBest, getFirstService(),
                        null, null);
            }
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
    }

    public boolean isEmpty() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return m_selectedReferences.isEmpty();
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public Comparator<ServiceReference> getComparator() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return m_comparator;
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public void setComparator(Comparator<ServiceReference> cmp) {
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            if (cmp == null) {
                m_comparator = new ServiceReferenceRankingComparator();
            } else {
                m_comparator = cmp;
            }
            // Be aware that this method will release the lock to call the dependency callback.
            setRankingInterceptor(new ComparatorBasedServiceRankingInterceptor(m_comparator));
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
    }

    public Filter getFilter() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            return m_filter;
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    public void setRankingInterceptor(ServiceRankingInterceptor interceptor) {
        m_dependency.getComponentInstance().getFactory().getLogger().log(Log.INFO, "Dependency " + m_dependency.getId
                () + " is getting a new ranking interceptor : " + interceptor);
        ChangeSet changeSet;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            ServiceReference oldBest = getFirstService();
            List<ServiceReference> beforeRanking = getSelectedServices();
            m_rankingInterceptor = interceptor;
            m_rankingInterceptor.open(m_dependency);

            final List<ServiceReference> allServices = getMatchingServices();
            List<ServiceReference> references = Collections.emptyList();
            if (!allServices.isEmpty()) {
                references = m_rankingInterceptor.getServiceReferences(m_dependency, allServices);
            }
            RankingResult result = computeDifferences(beforeRanking, references);
            m_selectedReferences = result.selected;
            changeSet = new ChangeSet(getSelectedServices(), result.departures, result.arrivals, oldBest,
                    getFirstService(), null, null);
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        // Calling onChange outside of the lock.
        m_dependency.onChange(changeSet);
    }

    public void close() {
        reset();
    }

    public void invalidateMatchingServices() {
        ChangeSet changeset;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            m_matchingReferences.clear();
            changeset = computeChangesInMatchingServices();
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }
        m_dependency.onChange(changeset);
    }

    public void invalidateSelectedServices() {
        ChangeSet changeset;
        try {
            m_dependency.acquireWriteLockIfNotHeld();
            ServiceReference oldBest = getFirstService();
            List<ServiceReference> beforeRanking = getSelectedServices();
            m_selectedReferences.clear();
            final List<ServiceReference> allServices = getMatchingServices();
            List<ServiceReference> references = Collections.emptyList();
            if (!allServices.isEmpty()) {
                references = m_rankingInterceptor.getServiceReferences(m_dependency, allServices);
            }
            RankingResult result = computeDifferences(beforeRanking, references);
            m_selectedReferences = result.selected;
            changeset = new ChangeSet(getSelectedServices(), result.departures, result.arrivals, oldBest,
                    getFirstService(), null, null);
        } finally {
            m_dependency.releaseWriteLockIfHeld();
        }

        m_dependency.onChange(changeset);
    }

    /**
     * Gets the list of tracking interceptors attached to the current service dependency.
     * @return the list of service references of the tracking interceptors participating to the resolution of the
     * current service dependency. An empty list is returned is there are no participating interceptors.
     * @since 1.11.0
     */
    public List<ServiceReference> getTrackingInterceptorReferences() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            if (m_trackingInterceptorTracker != null) {
                List<ServiceReference> refs = m_trackingInterceptorTracker.getUsedServiceReferences();
                if (refs != null) {
                    return refs;
                }
            }
            return Collections.emptyList();
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    /**
     * Gets the list of binding interceptors attached to the current service dependency.
     * @return the list of service references of the binding interceptors participating to the resolution of the
     * current service dependency. An empty list is returned is there are no participating interceptors.
     * @since 1.11.0
     */
    public List<ServiceReference> getBindingInterceptorReferences() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            if (m_bindingInterceptorTracker != null) {
                List<ServiceReference> refs = m_bindingInterceptorTracker.getUsedServiceReferences();
                if (refs != null) {
                    return refs;
                }
            }
            return Collections.emptyList();
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    /**
     * Gets the service reference of the currently attached ranking interceptor. As only one ranking interceptor can
     * be attached at a point on time, this is not a list but only one reference.
     * @return the service reference of the ranking interceptor participating to the resolution of the current
     * service dependency. {@code null} if no (external) ranking interceptor is currently attached.
     * @since 1.11.0
     */
    public ServiceReference getRankingInterceptorReference() {
        try {
            m_dependency.acquireReadLockIfNotHeld();
            if (m_rankingInterceptorTracker != null) {
                List<ServiceReference> references = m_rankingInterceptorTracker.getUsedServiceReferences();
                if (references != null  && ! references.isEmpty()) {
                    return references.get(0);
                }
            }
            return null;
        } finally {
            m_dependency.releaseReadLockIfHeld();
        }
    }

    private class RankingResult {
        final List<ServiceReference> departures;
        final List<ServiceReference> arrivals;
        final List<ServiceReference> selected;

        private RankingResult(List<ServiceReference> departures, List<ServiceReference> arrivals,
                              List<ServiceReference> selected) {
            this.departures = departures;
            this.arrivals = arrivals;
            this.selected = selected;
        }
    }

    public class ChangeSet {
        public final List<ServiceReference> selected;
        public final List<ServiceReference> departures;
        public final List<ServiceReference> arrivals;
        public final ServiceReference oldFirstReference;
        public final ServiceReference newFirstReference;
        public final Object service;
        public final ServiceReference modified;

        public ChangeSet(List<ServiceReference> selectedServices,
                         List<ServiceReference> departures, List<ServiceReference> arrivals,
                         ServiceReference oldFirst, ServiceReference newFirst,
                         Object service, ServiceReference modified) {
            this.selected = selectedServices;
            this.departures = departures;
            this.arrivals = arrivals;
            this.oldFirstReference = oldFirst;
            this.newFirstReference = newFirst;
            this.service = service;
            this.modified = modified;
        }
    }
}