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

import java.util.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.eventbus.client.nonpublic.*;
import org.litesoft.GWT.eventbus.server.nonpublic.*;
import org.litesoft.delayed.*;

public abstract class ServerEventBus extends AbstractPeerSupportingEventBus implements IServerEventBus
{
    public static final ServerEventBus[] EMPTY_ARRAY = new ServerEventBus[0];

    public static final String TRANSLATED_PATH = "TranslatedPath";
    public static final String REMOTE_ADDR = "RemoteAddr";

    protected ServerEventBus( int pClientIdNumber )
    {
        super( "Server", pClientIdNumber, TimedRunnableManager.INSTANCE,
               LoggingUnexpectedEventPackageHandler.INSTANCE );
    }

    protected void sharedInitialization( String pWhy, Integer pParentClientID,
                                         ClientWindowInstanceDataManager pInitialClientWindowInstanceData )
    {
        addAllClientWindowInstanceDataFrom( pInitialClientWindowInstanceData );

        ServerEventBus zExistingSEB = ServerEventBusManager.BackDoor.updateServerEventBus( this, //
                                                                                           pParentClientID );
        if ( zExistingSEB != null )
        {
            zExistingSEB.dispose( pWhy );
        }

        mLogger.debug.log( "*** create! - ", getClientIdNumber(), " - ", pWhy );
    }

    protected void LLdisposing( String pWhy )
    {
        for ( ServerEventBusDisposeListener listener : getServerEventBusDisposeListeners() )
        {
            try
            {
                listener.disposing( this );
            }
            catch ( RuntimeException e )
            {
                mLogger.error.log( e, "disposing SEB: ", getClientIdNumber() );
            }
        }
        super.LLdisposing( pWhy );
    }

    protected void LLdispose( String pWhy )
    {
        synchronized ( this )
        {
            mRelatedBusCommonObject = null;
        }
        clrServerEventBusDisposeListeners();
        mLogger.debug.log( "*** dispose - ", getClientIdNumber(), " - ", pWhy );
        super.LLdispose( pWhy );
    }

    public synchronized void setRelatedBusCommonObject( Object pRelatedBusCommonObject )
    {
        mRelatedBusCommonObject = pRelatedBusCommonObject;
    }

    private Object mRelatedBusCommonObject;

    public synchronized Object getRelatedBusCommonObject()
    {
        return mRelatedBusCommonObject;
    }

    /**
     * @return may return an empty array, but never null
     */
    public ServerEventBus[] getAllServerEventBuses()
    {
        return ServerEventBusManager.INSTANCE.getAllServerEventBuses();
    }

    /**
     * @return may return null
     */
    public ServerEventBus getRootServerEventBus()
    {
        return ServerEventBusManager.INSTANCE.getRootServerEventBus( getClientIdNumber() );
    }

    /**
     * @return may return null
     */
    public ServerEventBus getParentServerEventBus()
    {
        return ServerEventBusManager.INSTANCE.getParentServerEventBus( getClientIdNumber() );
    }

    /**
     * @return may return an empty array, but never null
     */
    public ServerEventBus[] getChildrenServerEventBuses()
    {
        return ServerEventBusManager.INSTANCE.getChildrenServerEventBuses( getClientIdNumber() );
    }

    /**
     * @return may return an empty array, but never null
     */
    public ServerEventBus[] getAllRelatedServerEventBuses()
    {
        return ServerEventBusManager.INSTANCE.getAllRelatedServerEventBuses( getClientIdNumber() );
    }

    public AuthenticationData getAuthenticationData()
    {
        return null;
    }

    public void apply( ServerEventBusSubscriptionCollector pCollector )
    {
        if ( pCollector != null )
        {
            for ( ServerEventBusDisposeListener zListener : pCollector.getListeners() )
            {
                addListener( zListener );
            }
            subscribe( pCollector );
        }
    }

    public void addListener( ServerEventBusDisposeListener pServerEventBusDisposeListener )
    {
        if ( pServerEventBusDisposeListener != null )
        {
            synchronized ( this )
            {
                if ( mListeners.add( pServerEventBusDisposeListener ) )
                {
                    pServerEventBusDisposeListener.init( this );
                }
            }
        }
    }

    public void removeListener( ServerEventBusDisposeListener pServerEventBusDisposeListener )
    {
        if ( pServerEventBusDisposeListener != null )
        {
            synchronized ( this )
            {
                mListeners.remove( pServerEventBusDisposeListener );
            }
        }
    }

    public synchronized ServerEventBusDisposeListener[] getServerEventBusDisposeListeners()
    {
        return mListeners.toArray( new ServerEventBusDisposeListener[mListeners.size()] );
    }

    private synchronized void clrServerEventBusDisposeListeners()
    {
        mListeners.clear();
    }

    private Set<ServerEventBusDisposeListener> mListeners = new HashSet<ServerEventBusDisposeListener>();
}