/*
 * 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.tuscany.sca.binding.notification;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;

import org.apache.tuscany.sca.binding.notification.encoding.Broker;
import org.apache.tuscany.sca.binding.notification.encoding.BrokerConsumerReference;
import org.apache.tuscany.sca.binding.notification.encoding.BrokerID;
import org.apache.tuscany.sca.binding.notification.encoding.BrokerProducerReference;
import org.apache.tuscany.sca.binding.notification.encoding.Brokers;
import org.apache.tuscany.sca.binding.notification.encoding.Constants;
import org.apache.tuscany.sca.binding.notification.encoding.EncodingException;
import org.apache.tuscany.sca.binding.notification.encoding.EncodingObject;
import org.apache.tuscany.sca.binding.notification.encoding.EncodingRegistry;
import org.apache.tuscany.sca.binding.notification.encoding.EncodingUtils;
import org.apache.tuscany.sca.binding.notification.encoding.EndConsumers;
import org.apache.tuscany.sca.binding.notification.encoding.EndProducers;
import org.apache.tuscany.sca.binding.notification.encoding.EndpointAddress;
import org.apache.tuscany.sca.binding.notification.encoding.EndpointReference;
import org.apache.tuscany.sca.binding.notification.encoding.EndpointReferenceWrapper;
import org.apache.tuscany.sca.binding.notification.encoding.NeighborBrokerConsumers;
import org.apache.tuscany.sca.binding.notification.encoding.Neighbors;
import org.apache.tuscany.sca.binding.notification.encoding.NewBroker;
import org.apache.tuscany.sca.binding.notification.encoding.NewBrokerAck;
import org.apache.tuscany.sca.binding.notification.encoding.NewBrokerResponse;
import org.apache.tuscany.sca.binding.notification.encoding.NewConsumer;
import org.apache.tuscany.sca.binding.notification.encoding.NewConsumerResponse;
import org.apache.tuscany.sca.binding.notification.encoding.NewProducer;
import org.apache.tuscany.sca.binding.notification.encoding.NewProducerResponse;
import org.apache.tuscany.sca.binding.notification.encoding.RemoveBroker;
import org.apache.tuscany.sca.binding.notification.encoding.RemovedBroker;
import org.apache.tuscany.sca.binding.notification.encoding.ReplaceBrokerConnection;
import org.apache.tuscany.sca.binding.notification.util.IOUtils;
import org.apache.tuscany.sca.binding.notification.util.NotificationServlet;
import org.apache.tuscany.sca.binding.notification.util.URIUtil;
import org.apache.tuscany.sca.binding.notification.util.IOUtils.IOUtilsException;
import org.apache.tuscany.sca.binding.notification.util.IOUtils.ReadableContinuation;
import org.apache.tuscany.sca.binding.notification.util.IOUtils.Writeable;
import org.apache.tuscany.sca.binding.notification.util.NotificationServlet.NotificationServletStreamHandler;
import org.apache.tuscany.sca.host.http.ServletHost;

/**
 * A notification type manager serves as a registry of producers and consumers, or brokers, for
 * any notification type. This class implements an interface that allows a reference provider
 * (a producer), a service provider (a consumer), or both (a broker, via the provider factory),
 * to access locally the ntm for its notification type, regardless of whether the ntm resides
 * locally or remotely.
 * At a given host there is only one reference provider and/or one service provider for any given
 * notification type. So, if the ntm for a notification type resides locally, then it is invoked
 * exclusively by either a reference provider (newProducer), a service provider (newConsumer), or
 * a provider factory (newBroker). And since these invocations occur when the providers are being
 * created then all three of consumerLists, producerLists and brokerLists must be null when these
 * invocations occur.
 * 
 * @version $Rev$ $Date$
 */
public class NotificationTypeManagerImpl implements NotificationTypeManager {

    private static final String ntmPathBase = "/ntm";

    private ServletHost servletHost;
    private EncodingRegistry encodingRegistry;
    private Map<URI, NotificationTypeManagerHandler> ntmHandlers;
    
    public NotificationTypeManagerImpl() {
    }

    public void setServletHost(ServletHost servletHost) {
        this.servletHost = servletHost;
    }

    public void setEncodingRegistry(EncodingRegistry encodingRegistry) {
        this.encodingRegistry = encodingRegistry;
    }

    public void init() {
        ntmHandlers = new HashMap<URI, NotificationTypeManagerHandler>();
    }
    
    public String newConsumer(URI notificationType, URL consumerUrl, URL remoteNtmUrl, List<URL> producerListResult) {
        if (ntmUrlIsRemote(consumerUrl, remoteNtmUrl)) {
            try {
                WriteableEPW wEPW = new WriteableEPW(new NewConsumer(), consumerUrl);
                InputStreamDecoder isd = new InputStreamDecoder();
                NewConsumerResponse ncr =
                    (NewConsumerResponse)IOUtils.sendHttpRequest(remoteNtmUrl, Constants.NEW_CONSUMER_OP, wEPW, isd);
                String sequenceType = ncr.getSequenceType();
                if (Constants.EndProducers.equals(sequenceType) || Constants.BrokerProducers.equals(sequenceType)) {
                    for (EndpointReference epr : ncr.getReferenceSequence()) {
                        producerListResult.add(epr.getEndpointAddress().getAddress());
                    }
                }
                return sequenceType;
            } catch(Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        } else {
            NotificationTypeManagerHandler ntmHandler = ntmHandlers.get(notificationType);
            if (ntmHandler != null) {
                throw new RuntimeException("Trying to deploy local consumer with existing local producer, consumer or broker");
            }
            
            createNtmHandler(consumerUrl.getAuthority(), notificationType, consumerUrl, null, null);
            
            return Constants.NoProducers;
        }
    }
    
    private void createNtmHandler(String ntmUriAuthority, URI notificationType, URL consumerUrl, URL producerUrl, BrokerStruct broker) {
        String ntmUri = "http://" + ntmUriAuthority + ntmPathBase + URIUtil.getPath(notificationType);
        NotificationTypeManagerHandler ntmh = new NotificationTypeManagerHandler(notificationType, consumerUrl, producerUrl, broker);
        ntmHandlers.put(notificationType, ntmh);
        servletHost.addServletMapping(ntmUri, new NotificationServlet(ntmh));
    }
    
    public String newProducer(URI notificationType, URL producerUrl, URL remoteNtmUrl, List<URL> consumerListResult) {
        if (ntmUrlIsRemote(producerUrl, remoteNtmUrl)) {
            try {
                WriteableEPW wEPW = new WriteableEPW(new NewProducer(), producerUrl);
                InputStreamDecoder isd = new InputStreamDecoder();
                NewProducerResponse npr =
                    (NewProducerResponse)IOUtils.sendHttpRequest(remoteNtmUrl, Constants.NEW_PRODUCER_OP, wEPW, isd);
                String sequenceType = npr.getSequenceType();
                if (Constants.EndConsumers.equals(sequenceType) || Constants.BrokerConsumers.equals(sequenceType)) {
                    for (EndpointReference epr : npr.getReferenceSequence()) {
                        consumerListResult.add(epr.getEndpointAddress().getAddress());
                    }
                }
                return sequenceType;
            } catch(Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        } else {
            NotificationTypeManagerHandler ntmHandler = ntmHandlers.get(notificationType);
            if (ntmHandler != null) {
                throw new RuntimeException("Trying to deploy local producer with existing local producer, consumer or broker");
            }
            
            createNtmHandler(producerUrl.getAuthority(), notificationType, null, producerUrl, null);
            
            return Constants.NoConsumers;
        }
    }
    
    public boolean newBroker(URI notificationType,
                             URL consumerUrl,
                             URL producerUrl,
                             String brokerID,
                             URL remoteNtmUrl,
                             List<EndpointReference> consumerListResult,
                             List<EndpointReference> producerListResult) {
        String ntmUriAuthority = producerUrl.getAuthority();
        if (!ntmUriAuthority.equals(consumerUrl.getAuthority())) {
            throw new RuntimeException("Producer url and consumer url do not match");
        }
        if (ntmUrlIsRemote(producerUrl, remoteNtmUrl)) {
            try {
                WriteableNewBroker wnb = new WriteableNewBroker(consumerUrl, producerUrl, brokerID);
                InputStreamDecoder isd = new InputStreamDecoder();
                NewBrokerResponse nbr =
                    (NewBrokerResponse)IOUtils.sendHttpRequest(remoteNtmUrl, Constants.NEW_BROKER_OP, wnb, isd);
                if (nbr.isFirstBroker()) {
                    if (nbr.getEndConsumers().getSequenceType().equals(Constants.EndConsumers)) {
                        for (EndpointReference epr : nbr.getEndConsumers().getReferenceSequence()) {
                            consumerListResult.add(epr);
                        }
                    }
                    if (nbr.getEndProducers().getSequenceType().equals(Constants.EndProducers)) {
                        for (EndpointReference epr : nbr.getEndProducers().getReferenceSequence()) {
                            producerListResult.add(epr);
                        }
                    }
                } else {
                    for (Broker broker : nbr.getBrokers().getBrokerSequence()) {
                        consumerListResult.add(broker.getBrokerConsumerReference().getReference());
                        producerListResult.add(broker.getBrokerProducerReference().getReference());
                    }
                }
                return nbr.isFirstBroker();
            } catch(Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        } else {
            NotificationTypeManagerHandler ntmHandler = ntmHandlers.get(notificationType);
            if (ntmHandler != null) {
                throw new RuntimeException("Trying to deploy local broker with existing local producer, consumer or broker");
            }
            
            BrokerStruct broker = new BrokerStruct(consumerUrl, producerUrl, brokerID);
            createNtmHandler(ntmUriAuthority, notificationType, null, null, broker);
            
            return true;
        }
    }
    
    private boolean ntmUrlIsRemote(URL localUrl, URL ntmUrl) {
        if (ntmUrl == null) {
            return false;
        }
        if (localUrl.getPort() != ntmUrl.getPort()) {
            return true;
        }
        String remoteNtmUrlAuthority = ntmUrl.getAuthority();
        if (remoteNtmUrlAuthority.indexOf("localhost") >= 0) {
            return false;
        }
        return !localUrl.getAuthority().equals(remoteNtmUrlAuthority);
    }
    
    public void newBrokerAck(URL remoteNtmUrl) {
        try {
            IOUtils.sendHttpRequest(remoteNtmUrl, Constants.NEW_BROKER_ACK_OP, new WriteableNewBrokerAck(), null);
        } catch(Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    public void removeBroker(EndpointReference brokerConsumerEpr, List<EndpointReference> neighborBrokerConsumerEprs, URL remoteNtmUrl) {
        WriteableRemoveBroker wrb = new WriteableRemoveBroker(brokerConsumerEpr, neighborBrokerConsumerEprs);
        
        try {
            IOUtils.sendHttpRequest(remoteNtmUrl, Constants.REMOVE_BROKER_OP, wrb, null);
        } catch(Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    private class NotificationTypeManagerHandler implements NotificationServletStreamHandler {
        
        private URI notificationType;
        List<URL> consumerList;
        List<URL> producerList;
        List<BrokerStruct> brokerList;
        private NotificationTypeLock notificationTypeLock;
        private BrokerStruct pendingBroker;
        
        public NotificationTypeManagerHandler(URI notificationType) {
            this.notificationType = notificationType;
            this.notificationTypeLock = new NotificationTypeLock();
            this.pendingBroker = null;
        }
        
        public NotificationTypeManagerHandler(URI notificationType, URL consumerUrl, URL producerUrl, BrokerStruct broker) {
            this(notificationType);
            if (consumerUrl != null) {
                addConsumer(consumerUrl);
            } else if (producerUrl != null) {
                addProducer(producerUrl);
            } else if (broker != null) {
                addBroker(broker);
            }
        }
        
        private void addConsumer(URL consumerUrl) {
            if (consumerList == null) {
                consumerList = new ArrayList<URL>();
            }
            consumerList.add(consumerUrl);
        }
        
        private void addProducer(URL producerUrl) {
            if (producerList == null) {
                producerList = new ArrayList<URL>();
            }
            producerList.add(producerUrl);
        }
        
        private void addBroker(BrokerStruct broker) {
            if (brokerList == null) {
                brokerList = new ArrayList<BrokerStruct>();
            }
            brokerList.add(broker);
        }
        
        public void handle(Map<String, String> headers, ServletInputStream istream, int contentLength, ServletOutputStream ostream) {
            String opHeader = headers.get(IOUtils.Notification_Operation);
            EncodingObject eo = null;
            try {
                eo = EncodingUtils.decodeFromStream(encodingRegistry, istream);
            } catch(EncodingException e) {
                throw new RuntimeException(e);
            }
            
            if (Constants.NEW_CONSUMER_OP.equals(opHeader)) {
                handleNewConsumer((NewConsumer)eo, ostream);
            } else if(Constants.NEW_PRODUCER_OP.equals(opHeader)) {
                handleNewProducer((NewProducer)eo, ostream);
            } else if(Constants.NEW_BROKER_OP.equals(opHeader)) {
                handleNewBroker((NewBroker)eo, ostream);
            } else if (Constants.NEW_BROKER_ACK_OP.equals(opHeader)) {
                handleNewBrokerAck();
            } else if (Constants.REMOVE_BROKER_OP.equals(opHeader)) {
                handleRemoveBroker((RemoveBroker)eo);
            }
        }
        
        private void handleNewConsumer(NewConsumer nc, ServletOutputStream ostream) {
            synchronized(notificationTypeLock) {
                if (notificationTypeLock.isLocked) {
                    try { notificationTypeLock.wait(); } catch(InterruptedException e) {}
                }
                URL consumerUrl = nc.getReference().getEndpointAddress().getAddress();
                if (brokerList == null) {
                    addConsumer(consumerUrl);
                }
    
                NewConsumerResponse ncr = new NewConsumerResponse();
                if (producerList != null) {
                    ncr.setSequenceType(Constants.EndProducers);
                    for (URL producerUrl : producerList) {
                        ncr.addReferenceToSequence(EncodingUtils.createEndpointReference(producerUrl, null));
                    }
                } else if(brokerList != null) {
                    ncr.setSequenceType(Constants.BrokerProducers);
                    for (BrokerStruct broker : brokerList) {
                        ncr.addReferenceToSequence(EncodingUtils.createEndpointReference(broker.producerUrl, null));
                    }
                } else {
                    ncr.setSequenceType(Constants.NoProducers);
                }
                try {
                    EncodingUtils.encodeToStream(encodingRegistry, ncr, ostream);
                } catch(IOUtilsException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        
        private void handleNewProducer(NewProducer np, ServletOutputStream ostream) {
            synchronized(notificationTypeLock) {
                if (notificationTypeLock.isLocked) {
                    try { notificationTypeLock.wait(); } catch(InterruptedException e) {}
                }
                URL producerUrl = np.getReference().getEndpointAddress().getAddress();
                if (brokerList == null) {
                    addProducer(producerUrl);
                }
    
                NewProducerResponse npr = new NewProducerResponse();
                if (consumerList != null) {
                    npr.setSequenceType(Constants.EndConsumers);
                    for (URL consumerUrl : consumerList) {
                        npr.addReferenceToSequence(EncodingUtils.createEndpointReference(consumerUrl, null));
                    }
                } else if(brokerList != null) {
                    npr.setSequenceType(Constants.BrokerConsumers);
                    for (BrokerStruct broker : brokerList) {
                        npr.addReferenceToSequence(EncodingUtils.createEndpointReference(broker.consumerUrl, null));
                    }
                } else {
                    npr.setSequenceType(Constants.NoConsumers);
                }
                try {
                    EncodingUtils.encodeToStream(encodingRegistry, npr, ostream);
                } catch(IOUtilsException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        
        private void handleNewBroker(NewBroker nb, ServletOutputStream ostream) {
            synchronized(notificationTypeLock) {
                if (notificationTypeLock.isLocked) {
                    try { notificationTypeLock.wait(); } catch(InterruptedException e) {}
                }
               NewBrokerResponse nbr = new NewBrokerResponse();
                if (consumerList != null || producerList != null || brokerList == null) {
                    nbr.setFirstBroker(true);
                    EndConsumers endConsumers = new EndConsumers();
                    if (consumerList != null) {
                        endConsumers.setSequenceType(Constants.EndConsumers);
                        for (URL consumerUrl : consumerList) {
                            endConsumers.addReferenceToSequence(EncodingUtils.createEndpointReference(consumerUrl, null));
                        }
                    } else {
                        endConsumers.setSequenceType(Constants.NoConsumers);
                    }
                    nbr.setEndConsumers(endConsumers);
                    EndProducers endProducers = new EndProducers();
                    if (producerList != null) {
                        endProducers.setSequenceType(Constants.EndProducers);
                        for (URL producerUrl : producerList) {
                            endProducers.addReferenceToSequence(EncodingUtils.createEndpointReference(producerUrl, null));
                        }
                    } else {
                        endProducers.setSequenceType(Constants.NoProducers);
                    }
                    nbr.setEndProducers(endProducers);
                } else {
                    nbr.setFirstBroker(false);
                    Brokers brokers = new Brokers();
                    for (BrokerStruct brokerStruct : brokerList) {
                        Broker brokerElt = new Broker();
                        BrokerConsumerReference bcr = new BrokerConsumerReference();
                        bcr.setReference(EncodingUtils.createEndpointReference(brokerStruct.consumerUrl, brokerStruct.brokerID));
                        brokerElt.setBrokerConsumerReference(bcr);
                            
                        BrokerProducerReference bpr = new BrokerProducerReference();
                        bpr.setReference(EncodingUtils.createEndpointReference(brokerStruct.producerUrl, brokerStruct.brokerID));
                        brokerElt.setBrokerProducerReference(bpr);
                        brokers.addBrokerToSequence(brokerElt);
                    }
                    nbr.setBrokers(brokers);
                }
                EndpointReference consumerEPR = nb.getBrokerConsumerReference().getReference();
                URL consumerUrl = consumerEPR.getEndpointAddress().getAddress();
                BrokerID consumerBrokerID = consumerEPR.getReferenceProperties().getProperty(BrokerID.class);
                EndpointReference producerEPR = nb.getBrokerProducerReference().getReference(); 
                URL producerUrl = producerEPR.getEndpointAddress().getAddress();
                BrokerID producerBrokerID = producerEPR.getReferenceProperties().getProperty(BrokerID.class);
                if (consumerBrokerID == null ||
                        producerBrokerID == null ||
                            !consumerBrokerID.getID().equals(producerBrokerID.getID())) {
                    throw new RuntimeException("Producer and consumer broker ids do not match");
                }
                // only add broker if consumerList == null && producerList == null
                // otherwise, make it a pending broker and wait for ack
                // TODO block for a configurable amount of time
                BrokerStruct broker = new BrokerStruct(consumerUrl, producerUrl, consumerBrokerID.getID());
                if (consumerList == null && producerList == null) {
                    addBroker(broker);
                } else {
                    pendingBroker = broker;
                    notificationTypeLock.isLocked = true;
                }
                try {
                    EncodingUtils.encodeToStream(encodingRegistry, nbr, ostream);
                } catch(IOUtilsException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        
        private void handleNewBrokerAck() {
            synchronized(notificationTypeLock) {
                if (!notificationTypeLock.isLocked) {
                    notificationTypeLock.notifyAll();
                    throw new RuntimeException("Notification type should be locked");
                }
                if (brokerList != null) {
                    notificationTypeLock.isLocked = false;
                    notificationTypeLock.notifyAll();
                    throw new RuntimeException("Can't add pending broker to non-empty broker list");
                }
                if (pendingBroker == null) {
                    notificationTypeLock.isLocked = false;
                    notificationTypeLock.notifyAll();
                    throw new RuntimeException("Missing pending broker");
                }
                addBroker(pendingBroker);
                consumerList = null;
                producerList = null;
                pendingBroker = null;
                notificationTypeLock.isLocked = false;
                notificationTypeLock.notifyAll();
            }
        }
        
        private void handleRemoveBroker(RemoveBroker rb) {
            synchronized(notificationTypeLock) {
                if (notificationTypeLock.isLocked) {
                    try { notificationTypeLock.wait(); } catch(InterruptedException e) {}
                }
                
                if (brokerList == null) {
                    throw new RuntimeException("No broker to remove for [" + notificationType + "]");
                }
                
                NeighborBrokerConsumers nbcs = rb.getNeighborBrokerConsumers();
                EndpointReference rbEpr = rb.getBrokerConsumerReference().getReference();
                if (nbcs != null && nbcs.getReferenceSequence() != null) {
                    List<Broker> neighborBrokers = new ArrayList<Broker>();
                    for (EndpointReference neighborBrokerConsumerEpr : nbcs.getReferenceSequence()) {
                        BrokerStruct neighborBrokerStruct = null;
                        URL neighborBrokerConsumerEprUrl = neighborBrokerConsumerEpr.getEndpointAddress().getAddress();
                        for (BrokerStruct brokerStruct : brokerList) {
                            if (brokerStruct.consumerUrl.equals(neighborBrokerConsumerEprUrl)) {
                                neighborBrokerStruct = brokerStruct;
                                break;
                            }
                        }
                        if (neighborBrokerStruct == null) {
                            throw new RuntimeException("Can't find neighbor broker for consumer EPR [" +
                                                       neighborBrokerConsumerEprUrl + "]");
                        }
                        BrokerConsumerReference bcr = new BrokerConsumerReference();
                        bcr.setReference(EncodingUtils.createEndpointReference(neighborBrokerStruct.consumerUrl, neighborBrokerStruct.brokerID));
                        BrokerProducerReference bpr = new BrokerProducerReference();
                        bpr.setReference(EncodingUtils.createEndpointReference(neighborBrokerStruct.producerUrl, neighborBrokerStruct.brokerID));
                        Broker neighborBroker = new Broker();
                        neighborBroker.setBrokerConsumerReference(bcr);
                        neighborBroker.setBrokerProducerReference(bpr);
                        neighborBrokers.add(neighborBroker);
                    }
                    int lastIndex = neighborBrokers.size() - 1;
                    for (int index = lastIndex; index >= 0; index--) {
                        List<Broker> writeableNeighborBrokers = ((index > 0) ? neighborBrokers.subList(0, index) : null);
                        WriteableReplaceBrokerConnection wrbc = new WriteableReplaceBrokerConnection(rbEpr, writeableNeighborBrokers);
                        URL targetUrl =
                            neighborBrokers.get(index).getBrokerProducerReference().getReference().getEndpointAddress().getAddress();
                        try {
                            IOUtils.sendHttpRequest(targetUrl, Constants.REPLACE_BROKER_CONNECTION_OP, wrbc, null);
                        } catch(Exception e) {
                            e.printStackTrace();
                            throw new RuntimeException(e);
                        }
                    }
                }
                
                BrokerStruct removedBrokerStruct = null;
                URL rbEprUrl = rbEpr.getEndpointAddress().getAddress();
                for (BrokerStruct brokerSruct : brokerList) {
                    if (brokerSruct.consumerUrl.equals(rbEprUrl)) {
                        removedBrokerStruct = brokerSruct;
                        break;
                    }
                }
                if (removedBrokerStruct == null) {
                    throw new RuntimeException("Can't find broker to remove for EPR [" + rbEprUrl + "]");
                }
                if(!brokerList.remove(removedBrokerStruct)) {
                    throw new RuntimeException("Broker was not removed");
                }
            }
        }
    }
    
    class NotificationTypeLock {
        public boolean isLocked;
    }
    
    class WriteableEPW implements Writeable {
        private EndpointReferenceWrapper epw;
        
        public WriteableEPW(EndpointReferenceWrapper epw, URL url) {
            EndpointAddress epa = new EndpointAddress();
            epa.setAddress(url);
            EndpointReference epr = new EndpointReference();
            epr.setEndpointAddress(epa);
            epw.setReference(epr);
            this.epw = epw;
        }
        
        public void write(OutputStream os) throws IOUtilsException {
            EncodingUtils.encodeToStream(encodingRegistry, epw, os);
        }
    }
    
    class InputStreamDecoder implements ReadableContinuation {
        
        public Object read(InputStream istream) throws IOUtilsException {
            try {
                return EncodingUtils.decodeFromStream(encodingRegistry, istream);
            } catch(EncodingException e) {
                throw new IOUtilsException(e);
            }
        }
    }
    
    class BrokerStruct {
        public URL consumerUrl;
        public URL producerUrl;
        public String brokerID;
        
        public BrokerStruct(URL consumerUrl, URL producerUrl, String brokerID) {
            this.consumerUrl = consumerUrl;
            this.producerUrl = producerUrl;
            this.brokerID = brokerID;
        }
    }
    
    class WriteableNewBroker implements Writeable {
        private NewBroker newBroker;
        
        public WriteableNewBroker(URL consumerUrl, URL producerUrl, String brokerID) {
            newBroker = new NewBroker();
            BrokerConsumerReference bcr = new BrokerConsumerReference();
            bcr.setReference(EncodingUtils.createEndpointReference(consumerUrl, brokerID));
            newBroker.setBrokerConsumerReference(bcr);
            
            BrokerProducerReference bpr = new BrokerProducerReference();
            bpr.setReference(EncodingUtils.createEndpointReference(producerUrl, brokerID));
            newBroker.setBrokerProducerReference(bpr);
        }
        
        public void write(OutputStream os) throws IOUtilsException {
            EncodingUtils.encodeToStream(encodingRegistry, newBroker, os);
        }
    }

    class WriteableNewBrokerAck implements Writeable {
        public void write(OutputStream os) throws IOUtilsException {
            EncodingUtils.encodeToStream(encodingRegistry, new NewBrokerAck(), os);
        }
    }
    
    class WriteableRemoveBroker implements Writeable {
        private RemoveBroker removeBroker;
        
        public WriteableRemoveBroker(EndpointReference brokerConsumerEpr, List<EndpointReference> neighborBrokerConsumerEprs) {
            removeBroker = new RemoveBroker();
            BrokerConsumerReference brokerConsumerReference = new BrokerConsumerReference();
            brokerConsumerReference.setReference(brokerConsumerEpr);
            removeBroker.setBrokerConsumerReference(brokerConsumerReference);
            if (neighborBrokerConsumerEprs != null) {
                NeighborBrokerConsumers neighborBrokerConsumers = new NeighborBrokerConsumers();
                neighborBrokerConsumers.setReferenceSequence(neighborBrokerConsumerEprs);
                neighborBrokerConsumers.setSequenceType(Constants.BrokerConsumers);
                removeBroker.setNeighborBrokerConsumers(neighborBrokerConsumers);
            }
        }
        
        public void write(OutputStream os) throws IOUtilsException {
            EncodingUtils.encodeToStream(encodingRegistry, removeBroker, os);
        }
    }
    
    class WriteableReplaceBrokerConnection implements Writeable {
        private ReplaceBrokerConnection replaceBrokerConnection;
        
        public WriteableReplaceBrokerConnection(EndpointReference removedBrokerEpr, List<Broker> brokerSequence) {
            replaceBrokerConnection = new ReplaceBrokerConnection();
            RemovedBroker removedBroker = new RemovedBroker();
            removedBroker.setReference(removedBrokerEpr);
            replaceBrokerConnection.setRemovedBroker(removedBroker);
            if (brokerSequence != null) {
                Neighbors neighbors = new Neighbors();
                neighbors.setBrokerSequence(brokerSequence);
                replaceBrokerConnection.setNeighbors(neighbors);
            }
        }
        
        public void write(OutputStream os) throws IOUtilsException {
            EncodingUtils.encodeToStream(encodingRegistry, replaceBrokerConnection, os);
        }
    }
}