// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.GWT.client.widgets.datatables;

import java.util.*;

import org.litesoft.bo.*;
import org.litesoft.bo.views.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

public abstract class FilterManager<RowType extends IViewObject> implements FetchRowsDataProviderCallBack<RowType>
{
    public static final String TOO_MANY_ROWS_MATCHED = "Too Many Rows Matched, Found At Least: ";
    public static final String NO_ROWS_MATCHED = "No Rows Matched";
    public static final String NOTHING_ENTERED = "You must enter something";

    public interface CallBacks<OurRowType extends IViewObject>
    {
        public ImmutableArrayList<OurRowType> filterRows( ImmutableArrayList<OurRowType> pRows );

        public void setNewList( List<OurRowType> pList, String pMsgText );
    }

    private BoMetaData mMetaData;
    private CallBacks<RowType> mCallBacks;
    private BoAccessorFilters mFilters = new BoAccessorFilters();
    private BoAccessorFilters mBaseLineFilters = null;
    private List<RowType> mBaseLineRows = null;
    private int mVsFilters, mVsList;

    public FilterManager( BoMetaData pMetaData, CallBacks<RowType> pCallBacks )
    {
        Objects.assertNotNull( "MetaData", mMetaData = pMetaData );
        Objects.assertNotNull( "CallBacks", mCallBacks = pCallBacks );
    }

    public void clearCache()
    {
        mBaseLineFilters = null;
        mBaseLineRows = null;
    }

    public boolean clear()
    {
        boolean rv = !mFilters.isEmpty();
        if ( rv )
        {
            mFilters.clear();
            mVsFilters++;
        }
        return rv;
    }

    public boolean setFilter( BoAccessorFilterType pFilterType, String pAttributeName, String pValue )
    {
        boolean zAdded = mFilters.setFilter( pFilterType, pAttributeName, pValue );
        if ( zAdded )
        {
            mVsFilters++;
        }
        return zAdded;
    }

    public boolean isEmpty()
    {
        return mFilters.isEmpty();
    }

    public int activeFilters()
    {
        return mFilters.activeFilters();
    }

    /**
     * @return false if the tables data model is up to date!
     */
    public boolean updateList()
    {
        if ( mVsFilters == mVsList ) // Filter & List Match!
        {
            return false;
        }
        if ( mFilters.isEmpty() )
        {
            setNewList( new ArrayList<RowType>(), NOTHING_ENTERED );
        }
        else if ( mPendingRequest == null )
        {
            requestRows();
        }
        return true;
    }

    private void setNewList( List<RowType> pList, String pMsgText )
    {
        mVsList = mVsFilters;
        mCallBacks.setNewList( pList, pMsgText );
    }

    private void requestRows()
    {
        if ( (mBaseLineFilters != null) && !FilterUtil.needsRefresh( mMetaData, mBaseLineFilters, mFilters ) )
        {
            Filter zFilter = FilterUtil.createFilter( mMetaData, mFilters.getFilters() );
            ArrayList<RowType> zNewList = new ArrayList<RowType>();
            for ( RowType zType : mBaseLineRows )
            {
                if ( zFilter.isSatisfiedBy( zType ) )
                {
                    zNewList.add( zType );
                }
            }
            setNewList( zNewList, zNewList.isEmpty() ? NO_ROWS_MATCHED : null );
            return;
        }
        mPendingRequest = new PendingRequestStructure( mVsFilters, mFilters );
        requestRowsFromServer( mPendingRequest.getFilters() );
    }

    protected void addBaseline( BoAccessorFilters pFilters, List<RowType> pList )
    {
        mBaseLineFilters = pFilters; // Simply save it - Not Shared/Used anymore
        mBaseLineRows = new ArrayList<RowType>( pList ); // Save it - Used by others - Copy it
    }

    abstract protected void requestRowsFromServer( BoAccessorFilters pFilters );

    private static class PendingRequestStructure
    {
        private int mVsFilters;
        private BoAccessorFilters mFilters;

        public PendingRequestStructure( int pVsFilters, BoAccessorFilters pFilters )
        {
            mVsFilters = pVsFilters;
            mFilters = pFilters.copy(); // Snap shot Filters
        }

        public int getVsFilters()
        {
            return mVsFilters;
        }

        public BoAccessorFilters getFilters()
        {
            return mFilters;
        }
    }

    private PendingRequestStructure mPendingRequest;

    private void filteredResponse( List<RowType> pList, // !null means that this could be a legitimate base line!
                                   String pMsgText )
    {
        PendingRequestStructure zPendingRequest = mPendingRequest; // Capture & clear the current PendingRequest
        mPendingRequest = null;
        if ( pList != null )
        {
            addBaseline( zPendingRequest.getFilters(), pList );
        }
        if ( mVsList == mVsFilters ) // This should only be possible if the user has cleared the filters while the response was pending
        {
            return;
        }
        if ( mVsFilters != zPendingRequest.getVsFilters() ) // Filters have changed since request
        {
            requestRows();
            return;
        }
        setNewList( (pList != null) ? pList : new ArrayList<RowType>(), pMsgText );
    }

    @Override
    public void success( ImmutableArrayList<RowType> pRows )
    {
        if ( (pRows == null) || pRows.isEmpty() )
        {
            filteredResponse( new ArrayList<RowType>(), NO_ROWS_MATCHED );
        }
        else
        {
            filteredResponse( mCallBacks.filterRows( pRows ).getSortedList(), null );
        }
    }

    @Override
    public void tooMany( long pCount )
    {
        filteredResponse( null, TOO_MANY_ROWS_MATCHED + pCount );
    }

    @Override
    public void error( String pError )
    {
        filteredResponse( null, "Error: " + pError );
    }
}