/* 
 * 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.wireadmin;

import java.io.PrintStream;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;

import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
import org.osgi.service.wireadmin.Consumer;
import org.osgi.service.wireadmin.Producer;
import org.osgi.service.wireadmin.Wire;
import org.osgi.service.wireadmin.WireAdmin;
import org.osgi.service.wireadmin.WireConstants;
import org.osgi.service.wireadmin.WireAdminEvent;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

/**
 * Wire Administration service.
 *
 * <p>This service can be used to create <tt>Wire</tt> objects connecting
 * a Producer service and a Consumer service.
 * <tt>Wire</tt> objects also have wire properties that may be specified
 * when a <tt>Wire</tt> object is created. The Producer and Consumer
 * services may use the <tt>Wire</tt> object's properties to manage or control their
 * interaction.
 * The use of <tt>Wire</tt> object's properties by a Producer or Consumer
 * services is optional.
 *
 * <p>Security Considerations.
 * A bundle must have <tt>ServicePermission[GET,WireAdmin]</tt> to get the Wire Admin service to
 * create, modify, find, and delete <tt>Wire</tt> objects.
 *
 * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
 */
public class WireAdminImpl implements WireAdmin, ServiceListener {

	private BundleContext m_bundleContext;

    // A Map containing a service reference associated to a producer and a List
    // of wire objects	
    private Map m_consumers = new HashMap(); /* ServiceReferences, List */
	
    private Map m_producers = new HashMap(); /* ServiceReferences, List */

	private List m_wires; // List containing the wires

	//private BindingController wireAdminListenersBindingController;

    // Filter corresponding to a consumer service
	private Filter m_consumerFilter;
    
    //  Filter corresponding to a producer service
	private Filter m_producerFilter;

    // EventManager
    private EventManager m_eventManager;

	private static int m_wireCount = 0;
    
    private AsyncMethodCaller m_asyncMethodCaller = new AsyncMethodCaller();        //m_eventDispatcher.stop();
    
    private static PrintStream m_traceout = null;
    
    private static PrintStream m_errorout = System.err;

	/**
     * Constructor with package visibility
     * 
	 * @param bundleContext the bundle context
	 */
	WireAdminImpl(BundleContext bundleContext) 
    {
		m_bundleContext = bundleContext;
        
        if(bundleContext.getProperty("fr.imag.adele.wireadmin.trace") != null)
        {
            String value = bundleContext.getProperty("fr.imag.adele.wireadmin.trace");
            if(value.equals("true"))
            {
                m_traceout = System.out;
            }
        }
        // Create the event manager (the event manager will start its own thread)       
        m_eventManager = new EventManager(m_bundleContext);
        
		try 
        {
			m_producerFilter = m_bundleContext.createFilter(
					"(objectClass=org.osgi.service.wireadmin.Producer)");
			m_consumerFilter = m_bundleContext.createFilter(
					"(objectClass=org.osgi.service.wireadmin.Consumer)");
		} 
        catch (InvalidSyntaxException e) 
        {
			// never thrown since LDAP expressions are correct
		}

        // Recover persistent wires
        getPersistentWires();

        // Activate thread that does asynchronous calls to
        // the producersConnected and consummersConnected methods
        new Thread(m_asyncMethodCaller).start();

        // Gets all producers and consumers that are present at the
        // moment the wire admin is created
        try 
        {
            // Registration for events must be done first, as some service
            // can be registered during initialization
            
            m_bundleContext.addServiceListener(this,"(|"+m_producerFilter.toString()+m_consumerFilter.toString()+")");

            // Replacement for the two following lines which work under OSCAR, 
            // but not work under IBM's SMF
            //m_bundleContext.addServiceListener(this,m_consumerFilter.toString());
            //m_bundleContext.addServiceListener(this,m_producerFilter.toString());
            
            // Get all producers
            ServiceReference[] producerRefs = m_bundleContext.getServiceReferences(Producer.class.getName(),null);
            
            if(producerRefs!=null)
            {
                // lock the producers Map to avoid concurrent modifications due
                // to service events
                synchronized(m_producers)
                {
                    for(int i=0;i<producerRefs.length;i++)
                    {
                        ServiceReference currentRef=(ServiceReference)producerRefs[i];
                        
                        Iterator wireIt = m_wires.iterator();
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();
                            if(currentWire.getProducerPID().equals(currentRef.getProperty(Constants.SERVICE_PID)))
                            {
                                currentWire.bindProducer(currentRef);
                            }
                        }
                        m_producers.put(currentRef,new ArrayList());
                    }
                }
            }

            // Get all the consumers
            ServiceReference[] consumerRefs = m_bundleContext.getServiceReferences(Consumer.class.getName(),null);
            
            if(consumerRefs!=null)
            {
                for(int i=0;i<consumerRefs.length;i++)
                {
                    // lock the consumers to avoid concurrent modifications due
                    // to service events
                    synchronized(m_consumers)
                    {
                        ServiceReference currentRef=(ServiceReference)consumerRefs[i];

                        Iterator wireIt = m_wires.iterator();
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();
                            if(currentWire.getConsumerPID().equals(currentRef.getProperty(Constants.SERVICE_PID)))
                            {
                                currentWire.bindConsumer(currentRef);
                            }
                        }
                        m_consumers.put(currentRef,new ArrayList());
                    }
                }
            }
        } 
        catch (InvalidSyntaxException e) 
        {
            trace(e);
        }

        // Iterate over all the wires, when a wire is connected
        // add it to the list of wires associated to a particular
        // producer or consumer
        synchronized(m_wires)
        {
            Iterator wireIterator = m_wires.iterator();
            while(wireIterator.hasNext())
            {
                WireImpl currentWire = (WireImpl) wireIterator.next();
                if(currentWire.isConnected())
                {                
                    // p. 327 "If both Producer and consumer services are registered
                    // with the framework, they are connected by the WireAdmin service"
                    List wires = (List) m_producers.get(currentWire.getProducerServiceRef());
                    wires.add(currentWire);
                    m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
                    
                    wires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
                    wires.add(currentWire);
                    m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
                }            
            }
        }       
	}
    
    /**
     * Pass the service reference to the event dispatcher
     * 
     * @param ref the service reference
     */
    void setServiceReference(ServiceReference ref)
    {
        m_eventManager.setServiceReference(ref);
    }

	/**
	 * Create a new <tt>Wire</tt> object that connects a Producer
	 * service to a Consumer service.
	 *
	 * The Producer service and Consumer service do not
	 * have to be registered when the <tt>Wire</tt> object is created.
	 *
	 * <p>The <tt>Wire</tt> configuration data must be persistently stored.
	 * All <tt>Wire</tt> connections are reestablished when the
	 * <tt>WireAdmin</tt> service is registered.
	 * A <tt>Wire</tt> can be permanently removed by using the
	 * {@link #deleteWire} method.
	 *
	 * <p>The <tt>Wire</tt> object's properties must have case
	 * insensitive <tt>String</tt> objects as keys (like the Framework).
	 * However, the case of the key must be preserved.
	 * The type of the value of the property must be one of the following:
	 *
	 * <pre>
	 * type        = basetype
	 *  | vector | arrays
	 *
	 * basetype = String | Integer | Long
	 *  | Float | Double | Byte
	 *  | Short | Character
	 *  | Boolean
	 *
	 * primitive   = long | int | short
	 *  | char | byte | double | float
	 *
	 * arrays   = primitive '[]' | basetype '[]'
	 *
	 * vector   = Vector of basetype
	 * </pre>
	 *
	 * <p>The <tt>WireAdmin</tt> service must automatically add the
	 * following <tt>Wire</tt> properties:
	 * <ul>
	 * <li>
	 * {@link WireConstants#WIREADMIN_PID} set to the value of the <tt>Wire</tt> object's
	 * persistent identity (PID). This value is generated by the
	 * Wire Admin service when a <tt>Wire</tt> object is created.
	 * </li>
	 * <li>
	 * {@link WireConstants#WIREADMIN_PRODUCER_PID} set to the value of
	 * Producer service's PID.
	 * </li>
	 * <li>
	 * {@link WireConstants#WIREADMIN_CONSUMER_PID} set to the value of
	 * Consumer service's PID.
	 * </li>
	 * </ul>
	 * If the <tt>properties</tt> argument
	 * already contains any of these keys, then the supplied values
	 * are replaced with the values assigned by the Wire Admin service.
	 *
	 * <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
	 * {@link WireAdminEvent#WIRE_CREATED}
	 * after the new <tt>Wire</tt> object becomes available from {@link #getWires}.
	 *
	 * @param producerPID The <tt>service.pid</tt> of the Producer service
	 * to be connected to the <tt>Wire</tt> object.
	 * @param consumerPID The <tt>service.pid</tt> of the Consumer service
	 * to be connected to the <tt>Wire</tt> object.
	 * @param properties The <tt>Wire</tt> object's properties. This argument may be <tt>null</tt>
	 * if the caller does not wish to define any <tt>Wire</tt> object's properties.
	 * @return The <tt>Wire</tt> object for this connection.
	 * @throws java.lang.IllegalArgumentException If
	 * <tt>properties</tt> contains case variants of the same key name.
	 */
	public Wire createWire(String producerPID, String consumerPID, Dictionary props) 
    {
        ServiceReference producerServiceRef = null;
        ServiceReference consumerServiceRef = null;

        Dictionary properties;
        
        if(props == null)
        {
        	properties = new Hashtable();
        }
        else
        {
        	//Clone the dictionary
        	properties = cloneProperties(props);
        }

        // Addition of mandatory properties
        properties.put(WireConstants.WIREADMIN_CONSUMER_PID, consumerPID);
        properties.put(WireConstants.WIREADMIN_PRODUCER_PID, producerPID);
        properties.put(WireConstants.WIREADMIN_PID, generateWirePID());

        // p.327 "Wire objects can be created when the producer or consumer
        // service is not registered
        WireImpl wire = new WireImpl(producerPID, consumerPID, properties);

        // Initialize the wire
        wire.initialize(m_bundleContext,m_eventManager);

        // Add the wire to the list 
        synchronized(m_wires)
        {
            m_wires.add(wire);            
        }

        // p. 357 "The Wire Admin service must broadcast a WireAdminEvent of 
        // type WireAdminEvent.WIRE_CREATED  after the new Wire object becomes 
        // available from getWires(java.lang.String)."
        m_eventManager.fireEvent(WireAdminEvent.WIRE_CREATED,wire);

        synchronized (m_producers)
        {
            Iterator producerIterator = m_producers.keySet().iterator();
            while(producerIterator.hasNext())
            {
                producerServiceRef = (ServiceReference) producerIterator.next();
                if (producerServiceRef.getProperty(Constants.SERVICE_PID).equals(producerPID)) 
                {
                    wire.bindProducer(producerServiceRef);                    
                    break;
                }
            }
        }        
        
        synchronized (m_consumers)
        {
            Iterator consumerIterator = m_consumers.keySet().iterator();
            while(consumerIterator.hasNext())
            {
                consumerServiceRef = (ServiceReference) consumerIterator.next();
                if (consumerServiceRef.getProperty(Constants.SERVICE_PID).equals(consumerPID)) 
                {
                    wire.bindConsumer(consumerServiceRef);
                    break;
                }
                
            }
        }
        
        
        // p.327 If both Producer and Consumer services are registered, they are 
        // connected by the wire admin service. 
        if(wire.isConnected())
        {
            List wires = (List) m_producers.get(producerServiceRef);
            wires.add(wire);
            m_asyncMethodCaller.consumersConnected(wire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));

            wires = (List) m_consumers.get(consumerServiceRef);
            wires.add(wire);
            m_asyncMethodCaller.producersConnected(wire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
        }

        // Newly created wires are immediately persisted to avoid information
        // loss in case of crashes.  (spec not clear about this)        
        persistWires();

        return wire;
    }

	/**
	 * Delete a <tt>Wire</tt> object.
	 *
	 * <p>The <tt>Wire</tt> object representing a connection between
	 * a Producer service and a Consumer service must be
	 * removed.
	 * The persistently stored configuration data for the <tt>Wire</tt> object
	 * must destroyed. The <tt>Wire</tt> object's method {@link Wire#isValid} will return <tt>false</tt>
	 * after it is deleted.
	 *
	 * <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
	 * {@link WireAdminEvent#WIRE_DELETED}
	 * after the <tt>Wire</tt> object becomes invalid.
	 *
	 * @param wire The <tt>Wire</tt> object which is to be deleted.
	 */
	public void deleteWire(Wire wire) 
    {
        if(m_wires.contains(wire))
        {
            WireImpl wireImpl = (WireImpl) wire;
            m_wires.remove(wire);
            if(wireImpl.isConnected())
            {
                List wires = (List) m_producers.get(wireImpl.getProducerServiceRef());
                wires.remove(wireImpl);
                m_asyncMethodCaller.consumersConnected(wireImpl.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));

                wires = (List) m_consumers.get(wireImpl.getConsumerServiceRef());
                wires.remove(wireImpl);
                m_asyncMethodCaller.producersConnected(wireImpl.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
            }
            
            wireImpl.invalidate();

            // fire an event
            m_eventManager.fireEvent(WireAdminEvent.WIRE_DELETED,wireImpl);
            
            // Persist state to avoid losses in case of crashes (spec not clear about this).        
            persistWires();
        }
        else
        {
            traceln("WireAdminImpl: Cannot delete a wire that is not managed by this service");
        }

	}

	/**
	 * Update the properties of a <tt>Wire</tt> object.
	 *
	 * The persistently stored configuration data for the <tt>Wire</tt> object
	 * is updated with the new properties and then the Consumer and Producer
	 * services will be called at the respective {@link Consumer#producersConnected}
	 * and {@link Producer#consumersConnected} methods.
	 *
	 * <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
	 * {@link WireAdminEvent#WIRE_UPDATED}
	 * after the updated properties are available from the <tt>Wire</tt> object.
	 *
	 * @param wire The <tt>Wire</tt> object which is to be updated.
	 * @param properties The new <tt>Wire</tt> object's properties or <tt>null</tt> if no properties are required.
	 */
	public void updateWire(Wire wire, Dictionary props) 
    {
        if(m_wires.contains(wire) == false)
        {
            traceln("WireAdminImpl: Cannot update a wire that is not managed by this service");
            return;
        }
        
        // Clone the dictionary
        Dictionary properties = cloneProperties(props);

        // Put again the mandatory properties, in case they are not set
        properties.put(WireConstants.WIREADMIN_CONSUMER_PID,wire.getProperties().get(WireConstants.WIREADMIN_CONSUMER_PID));
        properties.put(WireConstants.WIREADMIN_PRODUCER_PID,wire.getProperties().get(WireConstants.WIREADMIN_PRODUCER_PID));
        properties.put(WireConstants.WIREADMIN_PID,wire.getProperties().get(WireConstants.WIREADMIN_PID));
        
        WireImpl wireImpl = (WireImpl) wire;
        
        wireImpl.updateProperties(properties);
        
        // Call methods on Consumer and Producer
        if(wireImpl.isConnected())
        {
            List wires = (List) m_producers.get(wireImpl.getProducerServiceRef());
            m_asyncMethodCaller.consumersConnected(wireImpl.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));

            wires = (List) m_consumers.get(wireImpl.getConsumerServiceRef());
            m_asyncMethodCaller.producersConnected(wireImpl.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
        }

        // fire an event
        m_eventManager.fireEvent(WireAdminEvent.WIRE_UPDATED,wireImpl);
	}

	/**
	 * Return the <tt>Wire</tt> objects that match the given <tt>filter</tt>.
	 *
	 * <p>The list of available <tt>Wire</tt> objects is matched against the
	 * specified <tt>filter</tt>. <tt>Wire</tt> objects which match the
	 * <tt>filter</tt> must be returned. These <tt>Wire</tt> objects are not necessarily
	 * connected. The Wire Admin service should not return
	 * invalid <tt>Wire</tt> objects, but it is possible that a <tt>Wire</tt>
	 * object is deleted after it was placed in the list.
	 *
	 * <p>The filter matches against the <tt>Wire</tt> object's properties including
	 * {@link WireConstants#WIREADMIN_PRODUCER_PID}, {@link WireConstants#WIREADMIN_CONSUMER_PID}
	 * and {@link WireConstants#WIREADMIN_PID}.
	 *
	 * @param filter Filter string to select <tt>Wire</tt> objects
	 * or <tt>null</tt> to select all <tt>Wire</tt> objects.
	 * @return An array of <tt>Wire</tt> objects which match the <tt>filter</tt>
	 * or <tt>null</tt> if no <tt>Wire</tt> objects match the <tt>filter</tt>.
	 * @throws org.osgi.framework.InvalidSyntaxException If the specified <tt>filter</tt>
	 * has an invalid syntax.
	 * @see org.osgi.framework.Filter
	 */
	public Wire[] getWires(String filter) throws InvalidSyntaxException 
    {
		List res = null;
		if (filter == null) 
        {
            return (Wire [])m_wires.toArray(new Wire[m_wires.size()]);
		} 
        else 
        {
			Filter tempFilter = m_bundleContext.createFilter(filter);
			Iterator iter = m_wires.iterator();
			while (iter.hasNext()) 
            {
				WireImpl currentWire = (WireImpl) iter.next();
				if (tempFilter.match(currentWire.getProperties())) 
                {
					if (res == null)
                    {
						res = new ArrayList();
                    }
					res.add(currentWire);
				}
			}
		}
		if (res == null) 
        {
			return null;
		} 
        else 
        {
            return (Wire [])res.toArray(new Wire[res.size()]);
		}
	}

    /**
     * listens Producer and Consumer services changes
     * @see org.osgi.framework.ServiceListener#serviceChanged(org.osgi.framework.ServiceEvent)
     */
    public void serviceChanged(ServiceEvent e) 
    {
		ServiceReference serviceRef = e.getServiceReference();
		// A consumer service changed
		if (m_consumerFilter.match(serviceRef)) 
        {
			switch (e.getType()) 
            {
                case ServiceEvent.REGISTERED :
                    traceln("consumer registered");
                    
                    List wires = new ArrayList();

                    synchronized(m_consumers)
                    {
                        m_consumers.put(serviceRef,wires);
                    }
                    synchronized(m_wires)
                    {
                        Iterator wireIt = m_wires.iterator();
                        boolean called = false;
                        // Iterate over all existing wires
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();

                            if(currentWire.getConsumerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
                            {
                                // This wire is associated to the newly arrived consumer
                                currentWire.bindConsumer(serviceRef);
                                if(currentWire.isConnected())
                                {
                                    // The wire has been connected, both producer and consumer
                                    // must be updated
                                    wires.add(currentWire);
                                    called = true;
                                    m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
                                    List producerWires = (List) m_producers.get(currentWire.getProducerServiceRef());
                                    producerWires.add(currentWire);
                                    m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])producerWires.toArray(new Wire[producerWires.size()]));                                    
                                }
                            }
                        }
                        if(!called)
                        {
                            // P. 329 "If the Consumer service has no Wire objects attached when it
                            // is registered, the WireAdmin service must always call producersConnected(null)
                            m_asyncMethodCaller.producersConnected((Consumer) m_bundleContext.getService(serviceRef),null);
                        }
                    }
                    break;
                case ServiceEvent.UNREGISTERING :
                    traceln("consumer unregistering");
                    
                    synchronized(m_consumers)
                    {
                        m_consumers.remove(serviceRef);
                    }
                    synchronized(m_wires)
                    {
                        Iterator wireIt = m_wires.iterator();
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();
                            if(currentWire.getConsumerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
                            {
                                // p. 328 "When a Consumer or Producer service is unregistered
                                // from the OSGi framework, the other object in the association
                                // is informed that the Wire object is no longer valid"

                                if(currentWire.isConnected())
                                {
                                    currentWire.unbindConsumer();                               
                                    List producerWires = (List) m_producers.get(currentWire.getProducerServiceRef());
                                    producerWires.remove(currentWire);
                                    m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])producerWires.toArray(new Wire[producerWires.size()]));
                                }
                                else
                                {
                                    currentWire.unbindConsumer();    
                                }
                            }
                        }
                    }
                    break;
                case ServiceEvent.MODIFIED :
                    // TODO Respond to consumer service modification
                    traceln("consumer service modified");
                    break;

            }
        }
        // Removed else to manage services which are both producers AND consumers
		if (m_producerFilter.match(serviceRef)) 
        {
            switch (e.getType()) 
            {
                case ServiceEvent.REGISTERED :
                    traceln("producer registered");
                    
                    List wires = new ArrayList();

                    synchronized(m_producers)
                    {
                        m_producers.put(serviceRef,wires);
                    }
                    synchronized(m_wires)
                    {
                        Iterator wireIt = m_wires.iterator();
                        boolean called = false;
                        // Iterate over all existing wires
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();
                            if(currentWire.getProducerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
                            {
                                // This wire is associated to the newly arrived producer
                                currentWire.bindProducer(serviceRef);
                                if(currentWire.isConnected())
                                {
                                    // The wire has been connected, both producer and consumer
                                    // must be updated
                                    wires.add(currentWire);
                                    called = true;
                                    m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
                                    List consumerWires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
                                    consumerWires.add(currentWire);
                                    m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])consumerWires.toArray(new Wire[consumerWires.size()]));                                    
                                }
                            }
                        }
                        if(!called)
                        {
                            // P. 329 "If the Producer service has no Wire objects attached when it
                            // is registered, the WireAdmin service must always call consumersConnected(null)
                            m_asyncMethodCaller.consumersConnected((Producer) m_bundleContext.getService(serviceRef),null);
                        }
                    }
                    break;
                case ServiceEvent.UNREGISTERING :
                    traceln("Producer unregistering");
                    
                    synchronized(m_producers)
                    {
                        m_producers.remove(serviceRef);
                    }
                    synchronized(m_wires)
                    {
                        Iterator wireIt = m_wires.iterator();
                        while(wireIt.hasNext())
                        {
                            WireImpl currentWire = (WireImpl) wireIt.next();
                            if(currentWire.getProducerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
                            {
                                // p. 328 "When a Consumer or Producer service is unregistered
                                // from the OSGi framework, the other object in the association
                                // is informed that the Wire object is no longer valid"

                                if(currentWire.isConnected())
                                {
                                    currentWire.unbindProducer();                               
                                    List consumerWires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
                                    consumerWires.remove(currentWire);
                                    m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])consumerWires.toArray(new Wire[consumerWires.size()]));
                                }
                                else
                                {
                                    currentWire.unbindProducer();    
                                }
                            }
                        }
                    }
                    break;
                case ServiceEvent.MODIFIED :
                    // TODO Respond to producer service modification
                    traceln("producer service modified");
                    break;
            }
        }        
    }


	/**
	 * release all references before stop
	 */
	synchronized void releaseAll() 
    {
        Iterator wireIt = m_wires.iterator();
        while(wireIt.hasNext())
        {
            WireImpl currentWire = (WireImpl) wireIt.next();
            currentWire.invalidate();
        }
        
        Iterator producerIt = m_producers.keySet().iterator();        
        while (producerIt.hasNext())
        {
            ServiceReference producerRef = (ServiceReference) producerIt.next();
            ((Producer)m_bundleContext.getService(producerRef)).consumersConnected(null);            
        }
        
        Iterator consumerIt = m_consumers.keySet().iterator();        
        while (consumerIt.hasNext())
        {
            ServiceReference consumerRef = (ServiceReference) consumerIt.next();
            ((Consumer)m_bundleContext.getService(consumerRef)).producersConnected(null);            
        }

        // Stop the thread
        m_asyncMethodCaller.stop();
        
        // Notify the event manager so that it stops its thread
        m_eventManager.stop();
        
        persistWires();

	}

    /**
     * This method generates a PID. The pid is generated from the bundle id,
     * a hash code from the current time and a counter.
     * 
     * @return a wire PID
     */
    private String generateWirePID()
    {
        Date d = new Date();
        String PID="wire."+m_bundleContext.getBundle().getBundleId()+d.hashCode()+m_wireCount;
        m_wireCount ++;
        
        // Maybe the counter should go above 9?
        if(m_wireCount>9)
        {
            m_wireCount = 0;
        }
        return PID;
    }
    
    /**
     * Recover persistent wires 
     *
     */
    private void getPersistentWires()
    {
        
        try
        {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(m_bundleContext.getDataFile("wires.ser")));
            m_wires = (ArrayList) ois.readObject();
            ois.close();
            if(m_wires!=null)
            {
                traceln("Deserialized "+m_wires.size()+" wires");
                Iterator wireIt = m_wires.iterator();
                while(wireIt.hasNext())
                {
                    WireImpl currentWire = (WireImpl) wireIt.next();
                    currentWire.initialize(m_bundleContext,m_eventManager);     
                }
            }
            else
            {
                traceln("Couldn't Deserialize wires");
                m_wires = new ArrayList();
            }
        }
        catch(FileNotFoundException ex)
        {
            // do not show anything as this exception is thrown every
            // time the wire admin service is launched for the first
            // time
            m_wires = new ArrayList();
        }
        catch(Exception ex)
        {
            trace(ex);
            m_wires = new ArrayList();
        }
    }
    
    /**
     * Persist existing wires
     *
     */
    private void persistWires()
    {
        try
        {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(m_bundleContext.getDataFile("wires.ser")));
            oos.writeObject(m_wires);
            oos.close();
            traceln("Serialized "+m_wires.size()+" wires");
        }
        catch(Exception ex)
        {
            trace(ex);
        }
    }

    /**
     * print an error 
     * @param message message to error 
     */
    static void error(String message)
    {
        if (m_errorout != null) 
        {
            m_errorout.println(message);
        }
    }

	/**
	 * print a trace 
	 * @param message message to trace
	 */
	static void traceln(String message)
    {
		if (m_traceout != null) 
        {
			trace(message);
			trace("\n");
		}
	}

	/**
	 * print a trace 
	 * @param message message to trace
	 */
	static void trace(String message)
    {
		if (m_traceout != null) 
        {
			m_traceout.print(message);
		}
	}
	/**
	 * print a trace 
	 * @param e exception to trace
	 */
	static void trace(Exception e) 
    {
		if (m_traceout != null) 
        {
			e.printStackTrace(m_traceout);
		}
	}

	/**
	 * Clone a dictionary
	 * 
	 * @param dictionary The dictionary to clone
	 * @return a copy of the dicionary
	 */
    private Dictionary cloneProperties(Dictionary dictionary){
        Dictionary properties=new Hashtable();
        
        if (dictionary == null) {
            properties = new Hashtable();
        } else {
            Enumeration enumeration=dictionary.keys();
            while(enumeration.hasMoreElements()){
                Object key=enumeration.nextElement();
                Object value=dictionary.get(key);
                properties.put(key,value);
            }
        }
        
        return properties;
    }
	
    /**
     * This class enables calls to Producer.consumersConnected and Consumer.producersConnected
     * to be done asynchronously
     * 
     * p.333 "The WireAdmin service can call the consumersConnected or producersConnected
     * methods during the registration of the consumer of producer service"
     *
    **/
    class AsyncMethodCaller implements Runnable
    {
        private boolean m_stop = false;

        private List m_methodCallStack = new ArrayList();

        public void run()
        {
            while (!m_stop)
            {
                Object nextTarget[] = null;

                synchronized (m_methodCallStack)
                {
                    while (m_methodCallStack.size() == 0)
                    {
                        try
                        {
                            m_methodCallStack.wait();
                        } 
                        catch (InterruptedException ex)
                        {
                            // Ignore.
                        }
                    }
                    nextTarget = (Object[]) m_methodCallStack.remove(0);
                }
                
                if(nextTarget[0] instanceof Producer)
                {
                    try
                    {
                        ((Producer)nextTarget[0]).consumersConnected((Wire[])nextTarget[1]);
                    }
                    catch(Exception ex)
                    {
                        trace(ex);
                    }
                }
                // Removed else because nextTarget can be both producer and consumer                
                if(nextTarget[0] instanceof Consumer)
                {
                    try
                    {
                        ((Consumer)nextTarget[0]).producersConnected((Wire[])nextTarget[1]);
                    }
                    catch(Exception ex)
                    {
                        trace(ex);
                    }
                }
            }
        }

        /**
         * Place a call to Consumer.producersConnected on the stack
         * 
         * @param c the consumer
         * @param wires the wires
         */
        public void producersConnected(Consumer c,Wire []wires)
        {
            synchronized (m_methodCallStack)
            {
                m_methodCallStack.add(new Object[]{c,wires});
                m_methodCallStack.notify();
            }
        }

        /**
         * Place a call to Producer.consumersConnected on the stack
         * 
         * @param p the producer
         * @param wires the wires
         */
        public void consumersConnected(Producer p,Wire []wires)
        {
            synchronized (m_methodCallStack)
            {
                m_methodCallStack.add(new Object[]{p,wires});
                m_methodCallStack.notify();
            }
        }

        /**
         * stop the dispatcher
         *
         */
        void stop()
        {
            m_stop = true;
        }
    }
}