// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.eventbus.client.nonpublic;

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

public class NullStatePeerSupportingEventBus implements IStatePeerSupportingEventBus {
    private static final Logger LOGGER = LoggerFactory.getLogger( NullStatePeerSupportingEventBus.class );

    public static final IStatePeerSupportingEventBus INSTANCE = new NullStatePeerSupportingEventBus();

    private static final String DISPOSED = "Disposed ";

    private NullStatePeerSupportingEventBus() {
    }

    public void disposing() {
    }

    public void dispose() {
    }

    public void subscribeAndPublish( EventSubscriptionStructure[] pSubscriptions, EventPackage[] pPackages ) {
        for ( int i = 0; i < pSubscriptions.length; i++ ) {
            EventSubscriptionStructure subscription = pSubscriptions[i];
            if ( subscription != null ) {
                LLsubscribe( subscription.getSubscribeWith() );
            }
        }
        for ( int i = 0; i < pPackages.length; i++ ) {
            EventPackage eventPackage = pPackages[i];
            if ( eventPackage != null ) {
                LLpublish( eventPackage );
            }
        }
    }

    public void publishExpectingResponse( EventPackage pPackage ) {
        LLpublish( pPackage );
    }

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

    public void problemFromRemotePeerService( EventPackage pProblem ) {
        LOGGER.warn.log( DISPOSED, "problemFromRemotePeerService", pProblem );
    }

    public boolean propagateFromRemotePeerService( ChannelServicePackage pFromPeer ) {
        LOGGER.warn.log( DISPOSED, "propagateFromRemotePeerService", pFromPeer );
        return false;
    }

    public boolean ping() {
        LOGGER.warn.log( DISPOSED, "ping" );
        return false;
    }

    public IStatePeerSupportingEventBus suspendedToRegular( EventConstrictor pEventConstrictor,
                                                            EventBus pEventBus ) {
        throw new IllegalStateException( "Not Suspended" );
    }

    public boolean releaseCollected() {
        LOGGER.warn.log( DISPOSED, "releaseCollected" );
        return false;
    }

    private void LLpublish( EventPackage pPackage ) {
        LOGGER.warn.log( DISPOSED, "publish", pPackage );
    }

    private void LLsubscribe( String pEventName ) {
        LOGGER.warn.log( DISPOSED, "subscribe", pEventName );
    }

    private void LLunsubscribe( String pEventName ) {
        LOGGER.warn.log( DISPOSED, "unsubscribe", pEventName );
    }

    public String toString() {
        return DISPOSED;
    }
}