package org.litesoft.GWT.client.nonpublic;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.util.*;
import org.litesoft.logger.*;

import com.google.gwt.event.logical.shared.*;
import com.google.gwt.user.client.*;

public class CookieNet
{
    public static final String NO_GRAND_POOBAH_PREFIX = "noGP_";

    public interface Listener
    {
        public void changes( CookieNetDelta pDelta );
    }

    public static final Logger LOGGER = LoggerFactory.getLogger( CookieNet.class );

    public static final Long NORMAL_POLL_TIME = 1000L;

    private static final String PREFIX_MEMBER = "CN:";
    private static final String GRAND_POOBAH = "CN-GP";

    public static final String MSG_NEW = "+";
    public static final String MSG_ATTN = "!";
    public static final String MSG_DEAD = "-";

    private static boolean mAllowUsToBeGrandPoobah = false;

    public static void initialize( boolean pAllowUsToBeGrandPoobah )
    {
        mAllowUsToBeGrandPoobah = pAllowUsToBeGrandPoobah;
        String zName = WindowName.get();
        if ( zName == null )
        {
            WindowName.add( new MyListener() );
        }
        else
        {
            Window.addCloseHandler( new MyListener() );
            windowOpenedWithName();
        }
    }

    public static void add( Listener pListener )
    {
        if ( (pListener != null) && (-1 == indexOf( pListener )) )
        {
            sListeners = append( sListeners, pListener );
        }
    }

    public static void remove( Listener pListener )
    {
        if ( pListener != null )
        {
            int zAt = indexOf( pListener );
            if ( zAt != -1 )
            {
                sListeners = removeAt( sListeners, zAt );
            }
        }
    }

    public static Map<String, String> dumpCookies()
    {
        Collection<String> zNames = Cookies.getCookieNames();
        Map<String, String> zCookies = new HashMap<String, String>();
        for ( String zName : zNames )
        {
            zCookies.put( zName, Cookies.getCookie( zName ) );
        }
        return zCookies;
    }

    private static int sLastNumber = 0;

    public static int getNextNumber()
    {
        int zNextNumber = --sLastNumber;
        return zNextNumber < -99999 ? (sLastNumber = -1) : zNextNumber;
    }

    private static void windowClosedWithName()
    {
        sClosing = true;
        setOurCookie( MSG_DEAD );
    }

    private static void windowOpenedWithName()
    {
        setOurCookie( MSG_NEW );
        Long zPollAgainIn = checkForCookieChanges();

        if ( zPollAgainIn != null )
        {
            TimedRunnableManager.INSTANCE.runIn( new TimedRunnable()
            {
                public Again runOnce()
                {
                    Long zPollAgainIn = checkForCookieChanges();
                    return (zPollAgainIn != null) ? new RunAgainIn( zPollAgainIn ) : null;
                }
            }, zPollAgainIn );
        }
    }

    private static void setOurCookie( String pMsg )
    {
        String zName = WindowName.get();
        setCookie( PREFIX_MEMBER + zName, sMyLastValue = pMsg );
    }

    private static void setCookie( String pCookieName, String pValue )
    {
        Cookies.setCookie( pCookieName, pValue );
    }

    private static void removeCookie( String pCookieName )
    {
        Cookies.removeCookie( pCookieName );
    }

    private static boolean sClosing = false;

    private static boolean sIamGrandPoobah = false;

    private static String sMyLastValue = "?";
    private static Set<String> sMembers = new HashSet<String>();

    private static CookieNetDelta createDelta( CurrentMemberState pNewState, String pWindowName )
    {
        CookieNetDelta zDelta = new CookieNetDelta();
        sIamGrandPoobah = zDelta.setNowGrandPoobah( sIamGrandPoobah, pNewState.isGrandPoobah( pWindowName ) );
        sMyLastValue = zDelta.setWasPoked( sMyLastValue, pNewState.getMemberValue( pWindowName ) );
        sMembers = zDelta.adjustMembers( sMembers, pNewState.getMembers() );
        return zDelta;
    }

    private static String sLastRawDocCookies = null;

    /**
     * @return RunAgainIn
     */
    private static Long checkForCookieChanges()
    {
        CurrentMemberState zNewState = null;
        for ( CookieSnapshot zSnapshot = new CookieSnapshot( GRAND_POOBAH ); //
              !sClosing && !zSnapshot.getRawDocCookies().equals( sLastRawDocCookies ); //
              zSnapshot = new CookieSnapshot( GRAND_POOBAH ) )
        {
            sLastRawDocCookies = zSnapshot.getRawDocCookies();
            zNewState = createNewState( zSnapshot );
        }
        if ( sClosing )
        {
            return null;
        }
        if ( zNewState != null )
        {
            String zName = WindowName.get();
            if ( mAllowUsToBeGrandPoobah && !zNewState.hasGrandPoobah() )
            {
                String zCandidate = zNewState.getGrandPoobahCandidate();
                if ( zName.equals( zCandidate ) )
                {
                    setCookie( GRAND_POOBAH, zName );
                    return checkForCookieChanges();
                }
                if ( zCandidate == null )
                {
                    String zError = "No Members? from: " + zName;
                    LOGGER.error.log( zError );
                }
                return 1000L; // Everyone else BACK-OFF!
            }
            CookieNetDelta zDelta = createDelta( zNewState, zName );
            Listener[] zListeners = sListeners; // Snag the List
            for ( Listener zListener : zListeners )
            {
                zListener.changes( zDelta );
            }
        }
        return NORMAL_POLL_TIME;
    }

    private static CurrentMemberState createNewState( CookieSnapshot pSnapshot )
    {
        String zGrandPoobah = pSnapshot.getPrimaryCookieValue();
        CurrentMemberState rv = new CurrentMemberState();
        for ( String zName : Cookies.getCookieNames() )
        {
            if ( zName.startsWith( PREFIX_MEMBER ) )
            {
                String zWindowName = zName.substring( PREFIX_MEMBER.length() );
                String zValue = UtilsCommon.deNull( Cookies.getCookie( zName ) );
                if ( (zValue.length() == 0) || MSG_DEAD.equals( zValue ) )
                {
                    removeCookie( zName );
                    if ( zWindowName.equals( zGrandPoobah ) )
                    {
                        removeCookie( GRAND_POOBAH );
                        zGrandPoobah = null;
                    }
                }
                else
                {
                    rv.addMember( zWindowName, zValue );
                }
            }
        }
        rv.setGrandPoobah( zGrandPoobah );
        return rv;
    }

    private static Listener[] sListeners = new Listener[0];

    private static int indexOf( Listener pListener )
    {
        for ( int i = 0; i < sListeners.length; i++ )
        {
            Listener zListener = sListeners[i];
            if ( zListener == pListener ) // Identity
            {
                return i;
            }
        }
        return -1;
    }

    private static Listener[] append( Listener[] pArray, Listener pListener )
    {
        int zLength = pArray.length;
        if ( zLength == 0 )
        {
            return new Listener[]{pListener};
        }
        Listener[] zNew = new Listener[zLength + 1];
        System.arraycopy( pArray, 0, zNew, 1, zLength );
        zNew[0] = pListener;
        return zNew;
    }

    private static Listener[] removeAt( Listener[] pArray, int pIndexToRemove )
    {
        int zNewLength = pArray.length - 1;
        Listener[] zNew = new Listener[zNewLength];
        if ( pIndexToRemove != 0 )
        {
            System.arraycopy( pArray, 0, zNew, 0, pIndexToRemove );
        }
        if ( pIndexToRemove != zNewLength )
        {
            System.arraycopy( pArray, pIndexToRemove + 1, zNew, pIndexToRemove, zNewLength - pIndexToRemove );
        }
        return zNew;
    }

    private static class MyListener implements CloseHandler<Window>,
                                               WindowName.Listener
    {
        public void windowNameChanged()
        {
            WindowName.remove( this );
            Window.addCloseHandler( this );
            windowOpenedWithName();
        }

        public void onClose( CloseEvent<Window> event )
        {
            windowClosedWithName();
        }
    }

    private static class CurrentMemberState
    {
        private String mGrandPoobah = null;
        private Map<String, String> mMembers = new HashMap<String, String>();

        public boolean hasGrandPoobah()
        {
            return mGrandPoobah != null;
        }

        public String getGrandPoobah()
        {
            return mGrandPoobah;
        }

        public void setGrandPoobah( String pGrandPoobah )
        {
            mGrandPoobah = pGrandPoobah;
        }

        public void addMember( String pWindowName, String pValue )
        {
            mMembers.put( pWindowName, pValue );
        }

        public boolean isGrandPoobah( String pWindowName )
        {
            return hasGrandPoobah() && mGrandPoobah.equals( pWindowName );
        }

        public String getMemberValue( String pWindowName )
        {
            return mMembers.get( pWindowName );
        }

        public Set<String> getMembers()
        {
            return mMembers.keySet();
        }

        public String getGrandPoobahCandidate()
        {
            if ( !hasGrandPoobah() && !mMembers.isEmpty() )
            {
                ArrayList<String> zMemberWinNames = new ArrayList<String>( mMembers.keySet() );
                Collections.sort( zMemberWinNames );
                for ( String zWinName : zMemberWinNames )
                {
                    if ( !zWinName.startsWith( NO_GRAND_POOBAH_PREFIX ) )
                    {
                        return zWinName;
                    }
                }
            }
            return null;
        }
    }
}