// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.bo.views;

import org.litesoft.bo.views.caching.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.delayed.*;

public abstract class VoDataProvider<T extends IViewObject> extends AbstractCommonSupport
{
    protected final VoMetaData<T> mMetaData;

    protected VoDataProvider( VoMetaData<T> pMetaData )
    {
        Objects.assertNotNull( "VoMetaData", mMetaData = pMetaData );
    }

    public VoMetaData<T> getMetaData()
    {
        return mMetaData;
    }

    public T insureInTS( T pInstance )
    {
        return (pInstance.getTransactionSet() != null) ? pInstance : copyIntoNewTS( pInstance );
    }

    @SuppressWarnings({"unchecked"})
    public T copyIntoNewTS( T pInstance )
    {
        return (T) pInstance.copyInto( createTransactionSet() );
    }

    public TransactionSet createTransactionSet()
    {
        return ClientTransactionSet.create();
    }

    abstract public void requestRow( ObjectURL pObjectURL, FetchRowDataProviderCallBack<T> pCallBack );

    abstract public void requestRows( ObjectURL[] pObjectURLs, FetchRowsDataProviderCallBack<T> pCallBack );

    abstract public void requestRows( BoAccessorFilters pFilters, FetchRowsDataProviderCallBack<T> pCallBack );

    abstract public void requestAllRows( FetchRowsDataProviderCallBack<T> pCallBack );

    abstract public void commit( TransactionSet pTransactionSet, CommitCallBack<T> pCallBack, ObjectURL... pReturnOnSuccess );

    public void commit( T pInstance, CommitCallBack<T> pCallBack )
    {
        commit( pInstance.getTransactionSet(), pCallBack, pInstance.getObjectURL() );
    }

    public void requestTemporalTriggerPolling( TimedRunner pTimedRunner, boolean pFast )
    {
        checkPollingRequest( autoPollingAllowed(), "" );
        checkPollingRequest( !pFast || fastPollingAllowed(), "Fast " );
        POLLER.start( pTimedRunner, this, pFast );
        if ( pFast )
        {
            requestTemporalTriggerPoll();
        }
    }

    private void checkPollingRequest( boolean pFalseIsError, String pPrefix )
    {
        if ( !pFalseIsError )
        {
            throw new IllegalStateException( pPrefix + "Polling not supported for " + getForViewObjectRegisteredName() + "'s Data Provider" );
        }
    }

    abstract protected String getForViewObjectRegisteredName();

    public abstract void requestTemporalTriggerPoll();

    protected boolean autoPollingAllowed()
    {
        return true;
    }

    protected boolean fastPollingAllowed()
    {
        return false;
    }

    protected void checkOnPolling()
    {
        POLLER.checkOnPolling( autoPollingAllowed(), fastPollingAllowed() );
    }

    private static Poller POLLER = new Poller();

    private static class Poller implements TemporalTriggerManager.AnyResponseListener,
                                           TimedRunnable
    {
        private MillisecTimeSource mMillisecTimeSource = MillisecTimeSource.INSTANCE; // TODO: Inject?
        private boolean mPolling = false;
        private boolean mFast = false;
        private int mOutstandingRequests = 0;
        private long mLastMessageRecieved;
        private long mNextPollOnOrAfter;
        private VoDataProvider mDP;

        public void response()
        {
            if ( 0 == --mOutstandingRequests )
            {
                if ( mPolling )
                {
                    mLastMessageRecieved = mMillisecTimeSource.now();
                }
            }
        }

        public void checkOnPolling( boolean pPollingAllowed, boolean pFastPollingAllowed )
        {
            mOutstandingRequests++;
            if ( !pPollingAllowed )
            {
                mPolling = false;
            }
            else if ( !pFastPollingAllowed )
            {
                mFast = false;
            }
        }

        public void start( TimedRunner pTimedRunner, VoDataProvider pDP, boolean pFast )
        {
            mDP = pDP;
            mFast = pFast;
            long zNow = mMillisecTimeSource.now();
            mLastMessageRecieved = zNow; // fool our self!
            long zDesiredOnOrAfter = zNow + getPollDelay();
            if ( mPolling )
            {
                // check if less than 2 Secs till next poll (this is the norm, otherwise > 2 Secs should only happen when switching from Slow to Fast)
                if ( (mNextPollOnOrAfter - zDesiredOnOrAfter) < 2000 )
                {
                    return;
                }
                pTimedRunner.cancel( this ); // Too long, stop current timed & start a shorter!
            }
            else
            {
                mPolling = true;
            }
            pTimedRunner.runOnOrAfter( this, setNextPollOnOrAfter( zDesiredOnOrAfter ) );
        }

        public Again runOnce()
        {
            if ( !mPolling )
            {
                return null;
            }

            long zNow = mMillisecTimeSource.now();
            long zPollDelay = getPollDelay();
            long zDesiredOnOrAfter = mLastMessageRecieved + zPollDelay;

            // check if less than 2 Secs till the next poll should happen, happy case, Poll!
            if ( (zDesiredOnOrAfter - zNow) < 2000 )
            {
                mDP.requestTemporalTriggerPoll();
                zDesiredOnOrAfter = zNow + zPollDelay;
            }
            return new RunAgainOnOrAfter( setNextPollOnOrAfter( zDesiredOnOrAfter ) );
        }

        private long setNextPollOnOrAfter( long zDesiredOnOrAfter )
        {
            // System.out.println( "Next Poll In: " + (zDesiredOnOrAfter - now()) );
            return (mNextPollOnOrAfter = zDesiredOnOrAfter);
        }

        private long getPollDelay()
        {
            return mFast ? FAST_POLLING_DELAY : SLOW_POLLING_DELAY;
        }

        public static final int SLOW_POLLING_DELAY = 60000; // 1 Min
        public static final int FAST_POLLING_DELAY = 10000; // 10 Secs
    }
}