package org.litesoft.GWT.forms.client.nonpublic;

import java.util.*;

import org.litesoft.GWT.forms.client.*;
import org.litesoft.core.util.*;
import org.litesoft.logger.*;
import org.litesoft.ui.def.nonpublic.support.*;

public class RFHMessageManager
        extends com.google.gwt.user.client.Timer // fully qualified because multiple options
{
    public static final long MAX_MESSAGE_WAIT_MSEC = 10000;

    private int mNumberSource = 0;

    private MMSent mSent = null;

    private List<MMEntry> mPendings = new ArrayList<MMEntry>();

    private AsyncFormServicePeerChannel mFormServicePeerChannel;
    private Logger mLogger;

    public RFHMessageManager( AsyncFormServicePeerChannel pFormServicePeerChannel, Logger pLogger )
    {
        mFormServicePeerChannel = pFormServicePeerChannel;
        mLogger = pLogger;
        scheduleRepeating( 250 );
    }

    public void dispose()
    {
        cancel();
        mSent = null;
        mPendings.clear();
    }

    public void run()
    {
        if ( mSent != null )
        {
            long now = System.currentTimeMillis();
            if ( now < (mSent.getWhen() + MAX_MESSAGE_WAIT_MSEC) )
            {
                return;
            }
            mLogger.warn.log( "Message Response Wait Exhausted" );
            mSent = null;
        }
        LLsendNextPending();
    }

    public void sendCollector( String pWho, FormToServicePeerDataCollector pCollector )
    {
        if ( pCollector.isDirty() )
        {
            if ( (mSent != null) || !mPendings.isEmpty() )
            {
                mPendings.add( new MMEntry( pWho, pCollector ) );
            }
            else
            {
                sendFormEvent( pWho, new FormToServicePeerData( pCollector ) );
            }
        }
    }

    private void LLsendNextPending()
    {
        MMEntry zEntry = getNextPending();
        if ( zEntry != null )
        {
            FormToServicePeerData zData = zEntry.getData();
            String zWho = zEntry.getWho();
            sendFormEvent( zWho, zData );
        }
    }

    private void sendFormEvent( String pWho, FormToServicePeerData pData )
    {
        Integer zAsyncMessageNumber = pData.getAsyncMessageNumber();
        mLogger.debug.log( "sendCollector(", zAsyncMessageNumber, "):", pWho, "|", pData );
        mSent = new MMSent( zAsyncMessageNumber );
        mFormServicePeerChannel.formEvents( pData );
    }

    public void receivedAsyncMessageNumber( Integer pAsyncMessageNumber )
    {
        mLogger.debug.log( "receivedAsyncMessageNumber:", pAsyncMessageNumber );
        if ( mSent != null )
        {
            if ( !UtilsCommon.areNonArraysEqual( mSent.getAsyncMessageNumber(), pAsyncMessageNumber ) )
            {
                return;
            }
            mSent = null;
        }
        LLsendNextPending();
    }

    private MMEntry getNextPending()
    {
        return !mPendings.isEmpty() ? mPendings.remove( 0 ) : null;
    }

    public void indicateSendForRequestValues( Integer pAsyncMessageNumber )
    {
        if ( mSent != null )
        {
            mLogger.error.log( "RequestValues, but still waiting on message: ", mSent.mAsyncMessageNumber );
            mSent = null;
        }
        for ( MMEntry entry; null != (entry = getNextPending()); )
        {
            mLogger.error.log( "RequestValues, but still waiting to send message: ", entry.getData() );
        }
        mSent = new MMSent( pAsyncMessageNumber );
    }

    public Integer getNextAsyncMessageNumber()
    {
        return ++mNumberSource;
    }

    private static class MMEntry
    {
        private String mWho;
        private FormToServicePeerData mData;

        public MMEntry( String pWho, FormToServicePeerDataCollector pCollector )
        {
            mWho = pWho;
            mData = new FormToServicePeerData( pCollector );
        }

        public String getWho()
        {
            return mWho;
        }

        public FormToServicePeerData getData()
        {
            return mData;
        }
    }

    private static class MMSent
    {
        private long mWhen = System.currentTimeMillis();
        private Integer mAsyncMessageNumber;

        public MMSent( Integer pAsyncMessageNumber )
        {
            mAsyncMessageNumber = pAsyncMessageNumber;
        }

        public long getWhen()
        {
            return mWhen;
        }

        public Integer getAsyncMessageNumber()
        {
            return mAsyncMessageNumber;
        }
    }
}