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

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

import java.util.*;

public class EventBusMessageCollector
{
    public EventBusMessageCollector( Logger pLogger )
    {
        // Local Group
        mPublishedEvents = new LoggingEventList( pLogger, "publishEvent" );
        mSubscribes = new SubscriptionList( pLogger, "subscribe" );
        mUnsubscribes = new SubscriptionList( pLogger, "unsubscribe" );
        // Remote Group
        mFromRemotePeerEvents = new LoggingEventList( pLogger, "fromRemotePeerEvent" );
        mAddRemotePeerInterests = new LoggingStringSet( pLogger, "addRemotePeerInterest" );
        mRemoveRemotePeerInterests = new LoggingStringSet( pLogger, "removeRemotePeerInterest" );
        mFromRemoteAckPeerInterests = new LoggingStringSet( pLogger, "fromRemoteAckPeerInterest" );
    }

    // Local Group
    private LoggingEventList mPublishedEvents;
    private SubscriptionList mSubscribes;
    private SubscriptionList mUnsubscribes;
    // Remote Group
    private LoggingEventList mFromRemotePeerEvents;
    private LoggingStringSet mAddRemotePeerInterests;
    private LoggingStringSet mRemoveRemotePeerInterests;
    private LoggingStringSet mFromRemoteAckPeerInterests;

    public String toString()
    {
        StringBuilder sb = new StringBuilder( "EventBusMessageCollector:" );
        if ( isEmpty() )
        {
            sb.append( " Empty " );
        }
        else
        {
            appendTo( sb, mPublishedEvents );
            appendTo( sb, mSubscribes );
            appendTo( sb, mUnsubscribes );
            appendTo( sb, mFromRemotePeerEvents );
            appendTo( sb, mAddRemotePeerInterests );
            appendTo( sb, mRemoveRemotePeerInterests );
            appendTo( sb, mFromRemoteAckPeerInterests );
        }

        return sb.toString();
    }

    private void appendTo( StringBuilder pSb, LoggingCollection pToAppend )
    {
        if ( !pToAppend.isEmpty() )
        {
            pSb.append( "\n    " ).append( pToAppend );
        }
    }

    public void clear()
    {
        // Local Group
        mPublishedEvents.clear();
        mSubscribes.clear();
        mUnsubscribes.clear();
        // Remote Group
        mFromRemotePeerEvents.clear();
        mAddRemotePeerInterests.clear();
        mRemoveRemotePeerInterests.clear();
        mFromRemoteAckPeerInterests.clear();
    }

    public boolean isEmpty()
    {
        return  // Local Group
                mPublishedEvents.isEmpty() && //
                mSubscribes.isEmpty() && //
                mUnsubscribes.isEmpty() && //
                // Remote Group
                mFromRemotePeerEvents.isEmpty() && //
                mAddRemotePeerInterests.isEmpty() && //
                mRemoveRemotePeerInterests.isEmpty() && //
                mFromRemoteAckPeerInterests.isEmpty();
    }

    public void addSubscribes( EventSubscriptionStructure[] pSubscriptions )
    {
        mSubscribes.add( pSubscriptions );
    }

    public Iterator getSubscribes()
    {
        return mSubscribes.iterator();
    }

    public void addUnsubscribes( EventSubscriptionStructure[] pSubscriptions )
    {
        mUnsubscribes.add( pSubscriptions );
    }

    public Iterator getUnsubscribes()
    {
        return mUnsubscribes.iterator();
    }

    public void addPublishedEvent( EventPackage pPackage )
    {
        mPublishedEvents.add( pPackage );
    }

    public void addPublishedEvents( EventPackage[] pPackages )
    {
        mPublishedEvents.add( pPackages );
    }

    public Iterator getPublishedEvents()
    {
        return mPublishedEvents.iterator();
    }

    public void addFromRemotePeerEvent( EventPackage pPackage )
    {
        mFromRemotePeerEvents.add( pPackage );
    }

    public void addFromRemotePeerEvents( EventPackage[] pPackages )
    {
        mFromRemotePeerEvents.add( pPackages );
    }

    public Iterator getFromRemotePeerEvents()
    {
        return mFromRemotePeerEvents.iterator();
    }

    public void addRemotePeerInterests( String[] pInterests )
    {
        mAddRemotePeerInterests.add( pInterests );
    }

    public Set getAddRemotePeerInterests()
    {
        return mAddRemotePeerInterests.getAndClearSet();
    }

    public void removeRemotePeerInterests( String[] pInterests )
    {
        mRemoveRemotePeerInterests.add( pInterests );
    }

    public Set getRemoveRemotePeerInterests()
    {
        return mRemoveRemotePeerInterests.getAndClearSet();
    }

    public void addFromRemoteAckPeerInterests( String[] pInterests )
    {
        mFromRemoteAckPeerInterests.add( pInterests );
    }

    public Iterator getFromRemoteAckPeerInterests()
    {
        return mFromRemoteAckPeerInterests.iterator();
    }

    public static class SubscriptionList implements LoggingCollection
    {
        private List mMembers = new ArrayList();
        private Logger mLogger;
        private String mLogText;

        public SubscriptionList( Logger pLogger, String pLogText )
        {
            mLogger = pLogger;
            mLogText = pLogText;
        }

        public void add( EventSubscriptionStructure[] pNewMembers )
        {
            if ( pNewMembers != null )
            {
                for ( int i = 0; i < pNewMembers.length; i++ )
                {
                    add( pNewMembers[i] );
                }
            }
        }

        public void add( EventSubscriptionStructure pNewMember )
        {
            if ( pNewMember != null )
            {
                mLogger.trace.log( "(", mLogText, "):", pNewMember );
                mMembers.add( pNewMember );
            }
        }

        @Override
        public void clear()
        {
            mMembers.clear();
        }

        @Override
        public boolean isEmpty()
        {
            return mMembers.isEmpty();
        }

        @Override
        public Iterator iterator()
        {
            return isEmpty() ? Iterators.empty() : mMembers.iterator();
        }

        public String toString()
        {
            return mLogText + ":" + mMembers;
        }
    }
}