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

import java.util.*;
import javax.servlet.http.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.eventbus.client.nonpublic.*;
import org.litesoft.GWT.eventbus.server.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.logger.*;
import org.litesoft.sequences.*;

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

    public static final ServerEventBusManager INSTANCE = new ServerEventBusManager();

    private ServerEventBusManager()
    {
    }

    private static final String SERVER_EVENT_BUSES = "ServerEventBuses";
    private static final Long MAX_CLIENT_ID = (long) (Integer.MAX_VALUE - 2000);
    private static SequenceSource sClientIdNumberSequenceSource = SequenceSource.NULL;

    public static synchronized void setClientIdNumberSequenceSource( SequenceSource pSequenceSource )
    {
        sClientIdNumberSequenceSource = (pSequenceSource != null) ? pSequenceSource : SequenceSource.NULL;
    }

    public static synchronized int getNextClientIdNumber()
    {
        long cid = sClientIdNumberSequenceSource.getNextSequenceNumber( SERVER_EVENT_BUSES, MAX_CLIENT_ID );
        return (int) cid;
    }

    private final NodeMap mNodes = new NodeMap();

    public EventPackage getPackageForNewServerEventBus( int pClientIdNumber )
    {
        return null;
    }

    public TemporaryServerEventBus createTemporaryServerEventBus( String pWhy, ServerEventBus pParent,
                                                                  ClientWindowInstanceDataManager pInitialClientWindowInstanceData )
    {
        int zClientIdNumber = getNextClientIdNumber();

        TemporaryServerEventBus zTempSEB = new TemporaryServerEventBus( zClientIdNumber );

        synchronized ( mNodes )
        {
            zTempSEB.initialize( pWhy, pParent.getClientIdNumber(), pInitialClientWindowInstanceData );
        }

        // Force use of same stuff
        ServerEventBusSessionMapper.addServerEventBus( pParent, zTempSEB );

        return zTempSEB;
    }

    public TemporaryServerEventBus createTemporaryServerEventBus( String pWhy, HttpServletRequest pRequest,
                                                                  ThreadLocalContextFactory pThreadLocalContextFactory,
                                                                  ClientWindowInstanceDataManager pInitialClientWindowInstanceData )
    {
        int zClientIdNumber = getNextClientIdNumber();

        TemporaryServerEventBus zTempSEB = new TemporaryServerEventBus( zClientIdNumber );

        synchronized ( mNodes )
        {
            zTempSEB.initialize( pWhy, null, pInitialClientWindowInstanceData );
        }

        ServerEventBusSessionMapper.addServerEventBus( pRequest, pThreadLocalContextFactory, zTempSEB );

        return zTempSEB;
    }

    /**
     * @return may return null
     */
    public Integer getParentClientID( int pClientIdNumber )
    {
        return mNodes.getNode( pClientIdNumber ).getParentClientID();
    }

    /**
     * @return may return null
     */
    public ServerEventBus getServerEventBus( int pClientIdNumber )
    {
        return mNodes.getServerEventBusOrDisposedZombie( pClientIdNumber );
    }

    /**
     * @return may return null
     */
    public ServerEventBus getRootServerEventBus( int pClientIdNumber )
    {
        return mNodes.getRootNode( pClientIdNumber ).getServerEventBus();
    }

    /**
     * @return may return null
     */
    public ServerEventBus getParentServerEventBus( int pClientIdNumber )
    {
        return mNodes.getParentNode( pClientIdNumber ).getServerEventBus();
    }

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

    /**
     * @return may return an empty array, but never null
     */
    public ServerEventBus[] getChildrenServerEventBuses( int pClientIdNumber )
    {
        return new SelectorChildren( pClientIdNumber ).select( mNodes.getNodes() );
    }

    /**
     * @return may return an empty array, but never null
     */
    public ServerEventBus[] getAllRelatedServerEventBuses( int pClientIdNumber )
    {
        Node rootNode = mNodes.getRootNode( pClientIdNumber );
        return rootNode.isReal() ? //
               new SelectorAllRelated().select( rootNode, mNodes.getNodes() ) : //
               ServerEventBus.EMPTY_ARRAY;
    }

    public void broadcast( EventPackage pEventPackage )
    {
        if ( pEventPackage != null )
        {
            ServerEventBus[] buses = getAllServerEventBuses();
            if ( buses != null )
            {
                for ( ServerEventBus bus : buses )
                {
                    if ( bus != null )
                    {
                        bus.publishIfNotDisposed( pEventPackage );
                    }
                }
            }
        }
    }

    public static class BackDoor
    {
        public static ServerEventBus updateServerEventBus( ServerEventBus pNewSEB, Integer pParentClientID )
        {
            return ServerEventBusManager.INSTANCE.mNodes.updateServerEventBus( pNewSEB, pParentClientID );
        }
    }

    private static class Node
    {
        private int mClientID;
        private Integer mParentClientID;
        private ServerEventBus mServerEventBus;
        private int mChildCount = 0;

        public Node( Integer pParentClientID, int pClientID, ServerEventBus pServerEventBus )
        {
            mParentClientID = pParentClientID;
            mClientID = pClientID;
            mServerEventBus = pServerEventBus;
        }

        public String toString()
        {
            return "" + mClientID + ":" + ((getServerEventBus() != null) ? "SEB" : "---") + " ^" +
                   mParentClientID + " c:" + mChildCount;
        }

        public int getClientID()
        {
            return mClientID;
        }

        public Integer getParentClientID()
        {
            return mParentClientID;
        }

        public synchronized ServerEventBus getServerEventBus()
        {
            return mServerEventBus;
        }

        public synchronized void replaceServerEventBus( ServerEventBus pServerEventBus )
        {
            mServerEventBus = pServerEventBus;
        }

        public synchronized ServerEventBus clearServerEventBus()
        {
            ServerEventBus rv = mServerEventBus;
            mServerEventBus = null;
            return rv;
        }

        public synchronized boolean shouldRemove()
        {
            return isReal() && (mServerEventBus == null) && (mChildCount < 1);
        }

        public synchronized void incChildCount()
        {
            mChildCount++;
        }

        public synchronized void decChildCount()
        {
            mChildCount--;
        }

        public boolean isReal()
        {
            return true;
        }
    }

    private static final Node NULL_NODE = new Node( null, 0, null )
    {
        public boolean isReal()
        {
            return false;
        }

        public void incChildCount()
        {
        }

        public void decChildCount()
        {
        }
    };

    private abstract static class AbstractSelector
    {
        public ServerEventBus[] select( Node[] pNodes )
        {
            List<ServerEventBus> buses = new ArrayList<ServerEventBus>();
            addAppropriate( buses, pNodes );
            return buses.toArray( new ServerEventBus[buses.size()] );
        }

        protected void addAppropriate( List<ServerEventBus> pBuses, Node[] pNodes )
        {
            for ( Node node : pNodes )
            {
                ServerEventBus seb = node.getServerEventBus();
                if ( (seb != null) && acceptable( node, seb ) )
                {
                    pBuses.add( seb );
                }
            }
        }

        protected boolean acceptable( Node pNode, ServerEventBus pSEB )
        {
            return true;
        }
    }

    private static class SelectorAll extends AbstractSelector
    {
        public static final AbstractSelector INSTANCE = new SelectorAll();
    }

    private static class SelectorChildren extends AbstractSelector
    {
        private Integer mParentID;

        public SelectorChildren( int pParentID )
        {
            mParentID = pParentID;
        }

        protected boolean acceptable( Node pNode, ServerEventBus pSEB )
        {
            return mParentID.equals( pNode.getParentClientID() );
        }
    }

    private static class SelectorAllRelated
    {
        public ServerEventBus[] select( Node pRoot, Node[] pNodes )
        {
            List<ServerEventBus> buses = new ArrayList<ServerEventBus>();
            new Adder( buses, pNodes ).addAppropriate( pRoot );
            return buses.toArray( new ServerEventBus[buses.size()] );
        }

        private static class Adder
        {
            private List<ServerEventBus> mBuses;
            private Node[] mNodes;

            public Adder( List<ServerEventBus> pBuses, Node[] pNodes )
            {
                mBuses = pBuses;
                mNodes = pNodes;
            }

            public void addAppropriate( Node pCurrent )
            {
                ServerEventBus seb = pCurrent.getServerEventBus();
                if ( seb != null )
                {
                    mBuses.add( seb );
                }
                Integer parentID = pCurrent.getClientID();
                for ( Node node : mNodes )
                {
                    if ( parentID.equals( node.getParentClientID() ) )
                    {
                        addAppropriate( node );
                    }
                }
            }
        }
    }

    private static class NodeMap implements ServerEventBusDisposeListener
    {
        private final Map<Integer, Node> mServerEventBusNodes = new HashMap<Integer, Node>();
        private final Set<Integer> mDisposedServerEventBuses = new HashSet<Integer>();

        public Node getNode( Integer pClientIdNumberFromParentReference )
        {
            return (pClientIdNumberFromParentReference == null) ? //
                   NULL_NODE : //
                   getNode( pClientIdNumberFromParentReference.intValue() );
        }

        public Node getNode( int pClientIdNumber )
        {
            Node node = getRealNode( pClientIdNumber );
            return (node != null) ? node : NULL_NODE;
        }

        public Node getRequiredNode( int pClientIdNumber )
        {
            Node node = getRealNode( pClientIdNumber );
            if ( node == null )
            {
                throw new IllegalStateException( "No ServerEventBus Node for ClientID: " + pClientIdNumber );
            }
            return node;
        }

        // from ServerEventBusDisposeListener
        public void init( IServerEventBus pServerEventBus )
        {
        }

        // from ServerEventBusDisposeListener
        public void disposing( IServerEventBus pServerEventBus )
        {
            int clientId = pServerEventBus.getClientIdNumber();

            List<ServerEventBus> mAncestors = Collections.emptyList();

            ServerEventBus zExistingSEB;

            synchronized ( this )
            {
                Node node = getNode( clientId );
                zExistingSEB = node.clearServerEventBus();
                if ( null != zExistingSEB )
                {
                    mAncestors = getAncestors( node );

                    mDisposedServerEventBuses.add( clientId );
                }

                while ( node.shouldRemove() )
                {
                    mServerEventBusNodes.remove( node.getClientID() );
                    node = getNode( node.getParentClientID() );
                    node.decChildCount();
                }
            }

            if ( zExistingSEB instanceof NonTemporaryServerEventBus )
            {
                LOGGER.debug.log( "---Disposed: ", zExistingSEB );
            }

            notifyAncestorsOfRemovedDecendant( mAncestors, clientId );
        }

        public synchronized ServerEventBus getServerEventBusOrDisposedZombie( int pClientIdNumber )
        {
            ServerEventBus zBus = getNode( pClientIdNumber ).getServerEventBus();
            if ( zBus != null )
            {
                return zBus;
            }
            return mDisposedServerEventBuses.contains( pClientIdNumber ) ? //
                   ZombieServerEventBus.INSTANCE : //
                   null;
        }

        public synchronized Node getRealNode( int pClientIdNumber )
        {
            return mServerEventBusNodes.get( pClientIdNumber );
        }

        public synchronized Node[] getNodes()
        {
            return mServerEventBusNodes.values().toArray( new Node[mServerEventBusNodes.size()] );
        }

        public synchronized Node getParentNode( int pClientIdNumber )
        {
            Integer parentClientID = getNode( pClientIdNumber ).getParentClientID();
            return getNode( parentClientID );
        }

        public synchronized Node getRootNode( int pClientIdNumber )
        {
            Node node = getNode( pClientIdNumber );
            for ( Integer parentClientID; null != (parentClientID = node.getParentClientID()); )
            {
                node = getNode( parentClientID );
            }
            return node;
        }

        public ServerEventBus updateServerEventBus( ServerEventBus pNewSEB, Integer pParentClientID )
        {
            if ( !pNewSEB.getType().isManagable() )
            {
                throw badType( "Managable", pNewSEB );
            }

            int clientId = pNewSEB.getClientIdNumber();

            ServerEventBus zExistingSEB = null;

            List<ServerEventBus> mAncestors = Collections.emptyList();

            synchronized ( this )
            {
                Node node = getRealNode( clientId );
                if ( node != null )
                {
                    zExistingSEB = node.getServerEventBus();
                    if ( zExistingSEB != null )
                    {
                        mAncestors = getAncestors( node );

                        // Since we are replacing we do NOT want to get the dispose notice on the old!
                        zExistingSEB.removeListener( this );

                        if ( !pNewSEB.getType().isUpdateReplacable() )
                        {
                            throw badType( "UpdateReplacable", pNewSEB );
                        }
                    }
                    node.replaceServerEventBus( pNewSEB );
                    if ( !Objects.areNonArraysEqual( pParentClientID, node.getParentClientID() ) )
                    {
                        throw new IllegalStateException( "Mismatched Parent Client IDs (" +
                                                         node.getParentClientID() + ":Existing - New:" +
                                                         pParentClientID + ") for Client ID: " + clientId );
                    }
                }
                else
                {
                    mServerEventBusNodes.put( clientId, new Node( pParentClientID, clientId, pNewSEB ) );
                    if ( pParentClientID != null )
                    {
                        getNode( pParentClientID ).incChildCount();
                    }
                }
            }
            if ( pNewSEB instanceof NonTemporaryServerEventBus )
            {
                LOGGER.debug.log( "---Alive---: ", pNewSEB );
            }
            pNewSEB.addListener( this );
            notifyAncestorsOfAddedDecendant( mAncestors, clientId );
            return zExistingSEB;
        }

        private IllegalStateException badType( String pWhy, ServerEventBus pNewSEB )
        {
            return new IllegalStateException( "Not " + pWhy + ": " + pNewSEB.getType() + " ServerEventBus!" );
        }

        /**
         * called under lock
         */
        private List<ServerEventBus> getAncestors( Node pNode )
        {
            List<ServerEventBus> zBuses = new ArrayList<ServerEventBus>();
            for ( Integer parentClientID; null != (parentClientID = pNode.getParentClientID()); )
            {
                pNode = getNode( parentClientID );
                ServerEventBus zBus = pNode.getServerEventBus();
                if ( zBus != null )
                {
                    zBuses.add( zBus );
                }
            }
            return zBuses;
        }

        /**
         * called unsynchronized
         */
        private void notifyAncestorsOfAddedDecendant( List<ServerEventBus> pAncestors, int pClientId )
        {
            notifyAncestorsWith( pAncestors, pClientId, true );
        }

        /**
         * called unsynchronized
         */
        private void notifyAncestorsOfRemovedDecendant( List<ServerEventBus> pAncestors, int pClientId )
        {
            notifyAncestorsWith( pAncestors, pClientId, false );
        }

        /**
         * called unsynchronized
         */
        private void notifyAncestorsWith( List<ServerEventBus> pAncestors, int pClientId, boolean pAdd )
        {
            if ( !pAncestors.isEmpty() )
            {
                EventPackage eventPackage =
                        new NotificationReDecendantEventPackage( "ServerEventBusManager", pClientId, pAdd );
                for ( ServerEventBus zAncestor : pAncestors )
                {
                    zAncestor.publish( eventPackage );
                }
            }
        }
    }
}