package org.litesoft.changemanagement.nonpublic;

import java.io.*;
import java.util.*;
import java.util.concurrent.*;

import org.litesoft.changemanagement.*;
import org.litesoft.logger.*;
import org.litesoft.util.*;

public class LowLevelChangeListenerManager
{
    private static final Logger LOGGER = LoggerFactory.getLogger( LowLevelChangeListenerManager.class );

    private static abstract class InterestHelper
    {
        private ServerStateChangedListener mListener;

        protected InterestHelper( ServerStateChangedListener pListener )
        {
            mListener = pListener;
        }

        public ServerStateChangedListener getListener()
        {
            return mListener;
        }

        public boolean isAll()
        {
            return false;
        }

        abstract public boolean isAll( String pName );

        abstract public boolean hasAll( String[] pNames );

        abstract public boolean hasAll( String pName, Serializable[] pUniqueKeys );

        abstract public ServerStateChangeSet createListFrom( ServerStateChangeSet pAllChanges_Immutable );
    }

    private Map<ServerStateChangedListener, InterestHelper> mListenersToHelpers =
            new HashMap<ServerStateChangedListener, InterestHelper>();
    private InterestHelper[] mHelpers = null;

    public synchronized void clearAllListeners()
    {
        mHelpers = null;
        mListenersToHelpers.clear();
        mRemoteListeners.clear();
    }

    private synchronized void putHelper( InterestHelper pHelper )
    {
        mHelpers = null;
        mListenersToHelpers.put( pHelper.getListener(), pHelper );
    }

    private synchronized InterestHelper[] getHelpers()
    {
        if ( mHelpers == null )
        {
            mHelpers = mListenersToHelpers.values().toArray( new InterestHelper[mListenersToHelpers.size()] );
        }
        return mHelpers;
    }

    public synchronized void removeLocalListener( ServerStateChangedListener pListener )
    {
        if ( pListener != null )
        {
            if ( null != mListenersToHelpers.remove( pListener ) )
            {
                mHelpers = null;
            }
        }
    }

    public synchronized void addLocalListener( ServerStateChangedListener pListener )
    {
        if ( pListener != null )
        {
            InterestHelper helper = mListenersToHelpers.get( pListener );
            if ( (helper == null) || !helper.isAll() )
            {
                putHelper( new AllInterestHelper( pListener ) );
            }
        }
    }

    /**
     * @param pNames - normally just Object Class Names (getClass().getName())
     */
    public synchronized void addLocalListener( ServerStateChangedListener pListener, String... pNames )
    {
        if ( Utils.areNotNull( pListener, pNames ) )
        {
            InterestHelper helper = mListenersToHelpers.get( pListener );
            if ( (helper == null) || !helper.hasAll( pNames ) )
            {
                putHelper( new FilteringInterestHelper( pListener, helper, pNames ) );
            }
        }
    }

    /**
     * @param pName - normally just Object Class Name (getClass().getName())
     */
    public void addLocalListener( ServerStateChangedListener pListener, String pName,
                                  Serializable... pUniqueKeys )
    {
        if ( Utils.areNotNull( pListener, pName, pUniqueKeys ) )
        {
            InterestHelper helper = mListenersToHelpers.get( pListener );
            if ( (helper == null) || !helper.hasAll( pName, pUniqueKeys ) )
            {
                putHelper( new FilteringInterestHelper( pListener, helper, pName, pUniqueKeys ) );
            }
        }
    }

    public void removeRemoteListener( ServerStateChangedListener pListener )
    {
        if ( pListener != null )
        {
            mRemoteListeners.remove( pListener );
        }
    }

    public void addRemoteListener( ServerStateChangedListener pListener )
    {
        if ( pListener != null )
        {
            mRemoteListeners.add( pListener );
        }
    }

    public void distributeRemoteChanges( ServerStateChangeSet pRemoteChanges )
    {
        if ( pRemoteChanges != null )
        {
            notifyAllLocalListeners( pRemoteChanges );
        }
    }

    private Set<ServerStateChangedListener> mRemoteListeners =
            new CopyOnWriteArraySet<ServerStateChangedListener>();

    /**
     * @param pChange Not Null or Empty & is Immutable!
     */
    public void notifyAllListeners( ServerStateChangeSet pChange )
    {
        notifyAllLocalListeners( pChange );
        notifyAllRemoteListeners( pChange );
    }

    /**
     * @param pChange Not Null or Empty & is Immutable!
     */
    public void notifyAllRemoteListeners( ServerStateChangeSet pChange )
    {
        for ( ServerStateChangedListener listener : mRemoteListeners )
        {
            notifyListener( listener, pChange );
        }
    }

    public void waitForNotificationQueueEmpty()
    {
        mQueue.waitTillEmpty();
    }

    /**
     * @param pAllChanges Not Null or Empty & is Immutable!
     */
    private void notifyAllLocalListeners( ServerStateChangeSet pAllChanges )
    {
        for ( InterestHelper helper : getHelpers() )
        {
            ServerStateChangeSet zChanges = helper.createListFrom( pAllChanges );
            if ( zChanges != null )
            {
                notifyListener( helper.getListener(), zChanges );
            }
        }
    }

    private void notifyListener( ServerStateChangedListener listener, ServerStateChangeSet pAllChanges )
    {
        mQueue.put( listener, pAllChanges );
    }

    private static class AllInterestHelper extends InterestHelper
    {
        public AllInterestHelper( ServerStateChangedListener pListener )
        {
            super( pListener );
        }

        public boolean isAll()
        {
            return true;
        }

        public boolean isAll( String pName )
        {
            return true;
        }

        public boolean hasAll( String[] pNames )
        {
            return true;
        }

        public boolean hasAll( String pName, Serializable[] pUniqueKeys )
        {
            return true;
        }

        public ServerStateChangeSet createListFrom( ServerStateChangeSet pAllChanges_Immutable )
        {
            return pAllChanges_Immutable;
        }

        public String toString()
        {
            return "All POs";
        }
    }

    private static class FilteringInterestHelper extends InterestHelper
    {
        public FilteringInterestHelper( ServerStateChangedListener pListener, InterestHelper pHelper,
                                        String[] pNames )
        {
            super( pListener );
            for ( String zName : pNames )
            {
                if ( zName != null )
                {
                    mNamesToKeyInterestHelpers.put( zName, new AllKeyInterestHelper( zName ) );
                }
            }
            if ( pHelper != null )
            {
                Collection<KeyInterestHelper> oldHelpers =
                        ((FilteringInterestHelper) pHelper).mNamesToKeyInterestHelpers.values();
                for ( KeyInterestHelper helper : oldHelpers )
                {
                    String key = helper.getClassName();
                    if ( !mNamesToKeyInterestHelpers.containsKey( key ) )
                    {
                        mNamesToKeyInterestHelpers.put( key, helper );
                    }
                }
            }
        }

        public FilteringInterestHelper( ServerStateChangedListener pListener, InterestHelper pHelper,
                                        String pName, Serializable[] pUniqueKeys )
        {
            super( pListener );
            FilteringKeyInterestHelper newHelper = new FilteringKeyInterestHelper( pName, pUniqueKeys );
            mNamesToKeyInterestHelpers.put( pName, newHelper );
            if ( pHelper != null )
            {
                Collection<KeyInterestHelper> oldHelpers =
                        ((FilteringInterestHelper) pHelper).mNamesToKeyInterestHelpers.values();
                for ( KeyInterestHelper helper : oldHelpers )
                {
                    String key = helper.getClassName();
                    if ( key.equals( pName ) )
                    {
                        newHelper.addAll( (FilteringKeyInterestHelper) helper );
                    }
                    else
                    {
                        mNamesToKeyInterestHelpers.put( key, helper );
                    }
                }
            }
        }

        private Map<String, KeyInterestHelper> mNamesToKeyInterestHelpers =
                new HashMap<String, KeyInterestHelper>();

        public String toString()
        {
            StringBuilder sb = new StringBuilder( "Only: " );
            String[] keys = mNamesToKeyInterestHelpers.keySet().toArray(
                    new String[mNamesToKeyInterestHelpers.size()] );
            Arrays.sort( keys );
            sb.append( mNamesToKeyInterestHelpers.get( keys[0] ) );
            for ( int i = 1; i < keys.length; i++ )
            {
                sb.append( ", " ).append( mNamesToKeyInterestHelpers.get( keys[i] ) );
            }
            return sb.toString();
        }

        private boolean isInterestedIn( ServerStateChange pChange )
        {
            return (pChange != null) &&
                   isInterestedIn( pChange.getChangedObjectTypeName(), pChange.getChangedObjectUniqueKey() );
        }

        private boolean isInterestedIn( String pName, Serializable pUniqueKey )
        {
            KeyInterestHelper helper = mNamesToKeyInterestHelpers.get( pName );
            return (helper != null) && helper.isInterestedIn( pUniqueKey );
        }

        public boolean isAll( String pName )
        {
            KeyInterestHelper helper = mNamesToKeyInterestHelpers.get( pName );
            return (helper != null) && helper.isAll();
        }

        public boolean hasAll( String[] pNames )
        {
            for ( String zName : pNames )
            {
                if ( (zName != null) && !isAll( zName ) )
                {
                    return false;
                }
            }
            return true;
        }

        public boolean hasAll( String pName, Serializable[] pUniqueKeys )
        {
            KeyInterestHelper helper = mNamesToKeyInterestHelpers.get( pName );
            return (helper != null) && helper.isInterestedInAll( pUniqueKeys );
        }

        public ServerStateChangeSet createListFrom( ServerStateChangeSet pAllChanges )
        {
            List<ServerStateChange> zAllChanges_Immutable = pAllChanges.getChanges();
            int z1stOfInterest = get1stOfInterest( zAllChanges_Immutable );
            if ( z1stOfInterest == -1 )
            {
                return null;
            }
            int z1stNotOfInterest = get1stNotOfInterest( zAllChanges_Immutable, z1stOfInterest + 1 );
            if ( z1stNotOfInterest == -1 )
            {
                if ( z1stOfInterest == 0 )
                {
                    return pAllChanges;
                }
                z1stNotOfInterest = zAllChanges_Immutable.size();
            }
            List<ServerStateChange> rv =
                    new ArrayList<ServerStateChange>( zAllChanges_Immutable.size() - z1stOfInterest );

            do
            {
                rv.add( zAllChanges_Immutable.get( z1stOfInterest++ ) );
            }
            while ( z1stOfInterest < z1stNotOfInterest );

            for ( int i = z1stNotOfInterest + 1; i < zAllChanges_Immutable.size(); i++ )
            {
                ServerStateChange zChange = zAllChanges_Immutable.get( i );
                if ( isInterestedIn( zChange ) )
                {
                    rv.add( zChange );
                }
            }
            return new ServerStateChangeSet( pAllChanges, Collections.unmodifiableList( rv ) );
        }

        private int get1stNotOfInterest( List<ServerStateChange> pList, int pFrom )
        {
            for ( ; pFrom < pList.size(); pFrom++ )
            {
                if ( !isInterestedIn( pList.get( pFrom ) ) )
                {
                    return pFrom;
                }
            }
            return -1;
        }

        private int get1stOfInterest( List<ServerStateChange> pList )
        {
            for ( int i = 0; i < pList.size(); i++ )
            {
                if ( isInterestedIn( pList.get( i ) ) )
                {
                    return i;
                }
            }
            return -1;
        }
    }

    private static abstract class KeyInterestHelper
    {
        private String mClassName;

        protected KeyInterestHelper( String pClassName )
        {
            mClassName = pClassName;
        }

        public String getClassName()
        {
            return mClassName;
        }

        abstract public boolean isAll();

        abstract public boolean isInterestedIn( Serializable pUniqueKey );

        abstract public boolean isInterestedInAll( Serializable[] pUniqueKeys );
    }

    private static class AllKeyInterestHelper extends KeyInterestHelper
    {
        public AllKeyInterestHelper( String pClassName )
        {
            super( pClassName );
        }

        public boolean isAll()
        {
            return true;
        }

        public boolean isInterestedIn( Serializable pUniqueKey )
        {
            return true;
        }

        public boolean isInterestedInAll( Serializable[] pUniqueKeys )
        {
            return true;
        }

        public String toString()
        {
            return getClassName();
        }
    }

    private static class FilteringKeyInterestHelper extends KeyInterestHelper
    {
        private Set<Serializable> mUniqueKeys = new HashSet<Serializable>();

        public FilteringKeyInterestHelper( String pClassName, Serializable[] pUniqueKeys )
        {
            super( pClassName );
            mUniqueKeys.addAll( Arrays.asList( pUniqueKeys ) );
        }

        public FilteringKeyInterestHelper( String pClassName, Serializable pUniqueKey )
        {
            super( pClassName );
            mUniqueKeys.add( pUniqueKey );
        }

        public void addAll( FilteringKeyInterestHelper pHelper )
        {
            mUniqueKeys.addAll( pHelper.mUniqueKeys );
        }

        public boolean isAll()
        {
            return false;
        }

        public boolean isInterestedIn( Serializable pUniqueKey )
        {
            return mUniqueKeys.contains( pUniqueKey );
        }

        public boolean isInterestedInAll( Serializable[] pUniqueKeys )
        {
            for ( Serializable key : pUniqueKeys )
            {
                if ( !isInterestedIn( key ) )
                {
                    return false;
                }
            }
            return true;
        }

        public String toString()
        {
            return getClassName() + mUniqueKeys;
        }
    }

    private static class NodeQueue
    {
        public NodeQueue start()
        {
            return this;
        }

        public void waitTillEmpty()
        {
        }

        public void put( ServerStateChangedListener pListener, ServerStateChangeSet pAllChanges )
        {
            notifyListener( pListener, pAllChanges );
        }

        protected final void notifyListener( ServerStateChangedListener pListener,
                                             ServerStateChangeSet pAllChanges )
        {
            try
            {
                pListener.serverStateChanged( pAllChanges );
            }
            catch ( RuntimeException e )
            {
                LOGGER.error.log( e, " calling ", pListener, " with ", pAllChanges );
            }
        }
    }

    private static class ThreadedNodeQueue extends NodeQueue implements Runnable
    {
        private static class Node
        {
            private ServerStateChangedListener mListener;
            private ServerStateChangeSet mAllChanges;
            private Node mNext = null;

            public Node( ServerStateChangedListener pListener, ServerStateChangeSet pAllChanges )
            {
                mListener = pListener;
                mAllChanges = pAllChanges;
            }

            public ServerStateChangedListener getListener()
            {
                return mListener;
            }

            public ServerStateChangeSet getAllChanges()
            {
                return mAllChanges;
            }

            public Node getNext()
            {
                return mNext;
            }

            public void setNext( Node pNext )
            {
                mNext = pNext;
            }
        }

        private Node mHead = null;
        private Node mTail = null;

        public NodeQueue start()
        {
            Thread zThread = new Thread( this );
            zThread.setDaemon( true );
            zThread.start();
            return this;
        }

        @SuppressWarnings({"InfiniteLoopStatement"})
        public void run()
        {
            while ( true )
            {
                notifyNextListener();
            }
        }

        public synchronized void waitTillEmpty()
        {
            while ( mHead != null )
            {
                try
                {
                    wait();
                }
                catch ( InterruptedException e )
                {
                    // Whatever...
                }
            }
        }

        private void notifyNextListener()
        {
            synchronized ( this )
            {
                while ( mHead == null )
                {
                    try
                    {
                        wait();
                    }
                    catch ( InterruptedException e )
                    {
                        // Whatever...
                    }
                }
            }
            notifyListener( mHead.getListener(), mHead.getAllChanges() );
            synchronized ( this )
            {
                if ( null == (mHead = mHead.getNext()) )
                {
                    mTail = null;
                }
                notifyAll();
            }
        }

        public synchronized void put( ServerStateChangedListener pListener, ServerStateChangeSet pAllChanges )
        {
            Node zNode = new Node( pListener, pAllChanges );
            if ( mTail == null )
            {
                mHead = zNode;
            }
            else
            {
                mTail.setNext( zNode );
            }
            mTail = zNode;
            notifyAll();
        }
    }

    //    private NodeQueue mQueue = new NodeQueue().start();
    private NodeQueue mQueue = new ThreadedNodeQueue().start();
}