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

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

public abstract class AbstractPeerSupportingEventBus extends EventBus implements PeerSupportingEventBus,
                                                                                 EventConstrictor
{
    private IStatePeerSupportingEventBus mStatePeerSupportingEventBus =
            NullStatePeerSupportingEventBus.INSTANCE;

    protected AbstractPeerSupportingEventBus( String pForm, int pClientIdNumber, // 
                                              TimedRunner pTimedRunner,
                                              UnexpectedEventPackageHandler pUnexpectedHandler )
    {
        super( pForm, pClientIdNumber, pTimedRunner, pUnexpectedHandler );
    }

    protected void LLdisposing( String pWhy )
    {
        getStatePeerSupportingEventBus().disposing();
        super.LLdisposing( pWhy );
    }

    protected void LLdispose( String pWhy )
    {
        IStatePeerSupportingEventBus peer = getStatePeerSupportingEventBus();
        mStatePeerSupportingEventBus = NullStatePeerSupportingEventBus.INSTANCE;
        peer.dispose();
        super.LLdispose( pWhy );
    }

    /**
     * @noinspection NonJREEmulationClassesInClientCode
     */
    protected synchronized void initialize( Logger pLogger,
                                            IStatePeerSupportingEventBus pStatePeerSupportingEventBus )
    {
        if ( pLogger != null )
        {
            mLogger = pLogger;
        }
        mStatePeerSupportingEventBus = pStatePeerSupportingEventBus;
    }

    protected synchronized IStatePeerSupportingEventBus getStatePeerSupportingEventBus()
    {
        return mStatePeerSupportingEventBus;
    }

    protected IStatePeerSupportingEventBus switchFromSuspendedToRegular()
    {
        IStatePeerSupportingEventBus suspended;
        synchronized ( this )
        {
            suspended = mStatePeerSupportingEventBus;
            mStatePeerSupportingEventBus = suspended.suspendedToRegular( this, this );
        }
        suspended.dispose();
        return mStatePeerSupportingEventBus;
    }

    /**
     * @noinspection NonJREEmulationClassesInClientCode
     */
    protected Logger createLogger()
    {
        Logger logger = LoggerFactory.getLogger( getForm() + "EB" );
        return PrefixingLogger.decorate( "(" + getClientIdNumber() + ")", logger );
    }

    public String isLocalDistributionFromPeerOK( EventPackage pPackage )
    {
        return null;
    }

    protected void LLpublishNonNullNotDisposedExpectingResponse( EventPackage pPackage )
    {
        getStatePeerSupportingEventBus().publishExpectingResponse( pPackage );
    }

    protected void LLsubscribeAndPublish( EventSubscriptionStructure[] pSubscriptions,
                                          EventPackage[] pPackages )
    {
        if ( (pSubscriptions.length != 0) || (pPackages.length != 0) )
        {
            getStatePeerSupportingEventBus().subscribeAndPublish( pSubscriptions, pPackages );
        }
    }

    protected void LLunsubscribe( EventSubscriptionStructure[] pSubscriptions )
    {
        if ( pSubscriptions.length != 0 )
        {
            getStatePeerSupportingEventBus().unsubscribe( pSubscriptions );
        }
    }

    public void problemFromRemotePeerService( EventPackage pProblem )
    {
        getStatePeerSupportingEventBus().problemFromRemotePeerService( pProblem );
    }

    public boolean propagateFromRemotePeerService( ChannelServicePackage pFromPeer )
    {
        return getStatePeerSupportingEventBus().propagateFromRemotePeerService( pFromPeer );
    }

    public boolean ping()
    {
        return getStatePeerSupportingEventBus().ping();
    }

    public String toString()
    {
        return getForm() + "EventBus(" + getClientIdNumber() + ")";
    }
}