package org.litesoft.GWT.eventbus.client.nonpublic;

import java.util.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.logger.*;

public class StatePeerSupportingEventBusSuspended extends StatePeerSupportingEventBus
{
    private Logger mOriginalLogger;
    private TrackingEBMcollector mCollector;
    private RemotePeerService mRemotePeerService;

    public StatePeerSupportingEventBusSuspended( Logger pLogger, //
                                                 PeerSupportingEventBus pPeerSupportingEventBus, //
                                                 RemotePeerService pRemotePeerService )
    {
        super( PrefixingLogger.decorate( "(Collecting)", pLogger ), pPeerSupportingEventBus,
               new SavedEventsExpectingResponseTracker( pLogger ) );
        mOriginalLogger = pLogger;
        mCollector = new TrackingEBMcollector( mLogger );
        mRemotePeerService = pRemotePeerService;
    }

    public void disposing()
    {
    }

    public synchronized void dispose()
    {
        mRemotePeerService = null;
        if ( mCollector != null )
        {
            mCollector.clear();
            mCollector = null; // should be passed to Regular...
        }
        if ( mSavedEventsExpectingResponseTracker != null )
        {
            mSavedEventsExpectingResponseTracker.clear();
            mSavedEventsExpectingResponseTracker = null; // should be passed to Regular...
        }
        super.dispose();
    }

    public synchronized IStatePeerSupportingEventBus suspendedToRegular( EventConstrictor pEventConstrictor,
                                                                         EventBus pEventBus )
    {
        StatePeerSupportingEventBusRegular regular = //
                new StatePeerSupportingEventBusRegular( mOriginalLogger, mPeerSupportingEventBus, //
                                                        pEventConstrictor, pEventBus, //
                                                        new ProcessingManagerClientImpl(), //
                                                        mRemotePeerService, //
                                                        mCollector, //
                                                        mSavedEventsExpectingResponseTracker );
        mCollector = null;
        mSavedEventsExpectingResponseTracker = null;
        return regular;
    }

    public synchronized void publishExpectingResponse( EventPackage pPackage )
    {
        String sourceName = pPackage.getSourceName();
        if ( !mCollector.hasPendingSubscribeWith( sourceName ) )
        {
            throw new IllegalArgumentException(
                    "No Subscribers for '" + sourceName + "' in Event: " + pPackage );
        }
        mSavedEventsExpectingResponseTracker.add( pPackage );
    }

    public boolean releaseCollected()
    {
        return true; // Do nothing...
    }

    protected EventBusMessageCollector getEventBusMessageCollector()
    {
        return mCollector;
    }

    public String toString()
    {
        return super.toString() + "Suspended";
    }

    private static class TrackingEBMcollector extends EventBusMessageCollector
    {
        private Set mPendingSubscribeWiths = new HashSet();

        public TrackingEBMcollector( Logger pLogger )
        {
            super( pLogger );
        }

        public boolean hasPendingSubscribeWith( String pName )
        {
            return mPendingSubscribeWiths.contains( pName );
        }

        public void addSubscribes( EventSubscriptionStructure[] pSubscriptions )
        {
            super.addSubscribes( pSubscriptions );
            for ( int i = 0; i < pSubscriptions.length; i++ )
            {
                EventSubscriptionStructure subscription = pSubscriptions[i];
                if ( subscription != null )
                {
                    mPendingSubscribeWiths.add( subscription.getSubscribeWith() );
                }
            }
        }

        public void addUnsubscribes( EventSubscriptionStructure[] pSubscriptions )
        {
            super.addUnsubscribes( pSubscriptions );
            for ( int i = 0; i < pSubscriptions.length; i++ )
            {
                EventSubscriptionStructure subscription = pSubscriptions[i];
                if ( subscription != null )
                {
                    mPendingSubscribeWiths.remove( subscription.getSubscribeWith() );
                }
            }
        }

        public void clear()
        {
            super.clear();
            mPendingSubscribeWiths.clear();
        }
    }
}