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

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

public abstract class StatePeerSupportingEventBus implements IStatePeerSupportingEventBus
{
    protected boolean mDisposed = false;
    protected Logger mLogger;
    protected PeerSupportingEventBus mPeerSupportingEventBus;
    protected SavedEventsExpectingResponseTracker mSavedEventsExpectingResponseTracker;

    protected StatePeerSupportingEventBus( Logger pLogger, PeerSupportingEventBus pPeerSupportingEventBus,
                                           SavedEventsExpectingResponseTracker pSavedEventsExpectingResponseTracker )
    {
        mLogger = pLogger;
        mPeerSupportingEventBus = pPeerSupportingEventBus;
        mSavedEventsExpectingResponseTracker = pSavedEventsExpectingResponseTracker;
    }

    abstract protected EventBusMessageCollector getEventBusMessageCollector();

    public synchronized void dispose()
    {
        mDisposed = true;
        // Leave everything for normal GC
    }

    public final void subscribeAndPublish( EventSubscriptionStructure[] pSubscriptions,
                                           EventPackage[] pPackages )
    {
        synchronized ( this )
        {
            EventBusMessageCollector collector = getEventBusMessageCollector();
            collector.addSubscribes( pSubscriptions );
            collector.addPublishedEvents( pPackages );
        }
        releaseCollected();
    }

    public final void unsubscribe( EventSubscriptionStructure[] pSubscriptions )
    {
        synchronized ( this )
        {
            getEventBusMessageCollector().addUnsubscribes( pSubscriptions );
        }
        releaseCollected();
    }

    public final void problemFromRemotePeerService( EventPackage pProblem )
    {
        synchronized ( this )
        {
            getEventBusMessageCollector().addFromRemotePeerEvent( pProblem );
        }
        releaseCollected();
    }

    public final boolean propagateFromRemotePeerService( ChannelServicePackage pFromPeer )
    {
        if ( (pFromPeer == null) || pFromPeer.isEmpty() )
        {
            return true;
        }
        synchronized ( this )
        {
            EventBusMessageCollector collector = getEventBusMessageCollector();
            if ( pFromPeer.anyAddPeerInterests() )
            {
                collector.addRemotePeerInterests( pFromPeer.getAddPeerInterests() );
            }
            if ( pFromPeer.anyRemovePeerInterests() )
            {
                collector.removeRemotePeerInterests( pFromPeer.getRemovePeerInterests() );
            }
            if ( pFromPeer.anyEvents() )
            {
                collector.addFromRemotePeerEvents( pFromPeer.getEvents() );
            }
            if ( pFromPeer.anyAckPeerInterests() )
            {
                collector.addFromRemoteAckPeerInterests( pFromPeer.getAckPeerInterests() );
            }
        }
        return releaseCollected();
    }

    public boolean ping()
    {
        return true;
    }

    public String toString()
    {
        return mPeerSupportingEventBus.getForm();
    }
}