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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.Button;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.bo.*;
import org.litesoft.bo.views.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.core.util.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.gen2.table.client.TableModelHelper.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

/**
 * List mutations are not supported.
 */
public class FilteringTableModel<RowType extends IViewObject> extends ListTableModel<RowType> implements SearchStateDefaultRequestable,
                                                                                                         BoAccessorFilter,
                                                                                                         FilterManager.CallBacks<RowType>

{
    private static final String STYLE_STATUS = "QBEstatus";
    private static final String QBE_MSG = "QBEmsg";
    private static final String STYLE_HAS_MSG = "HasMsg";
    private static final String STYLE_NO_MSG = "NoMsg";

    private FilterManager<RowType> mFilterManager;
    private TableClickCommand<RowType> mDefaultSingleRowTableClickCommand, mDefaultNoRowTableClickCommand;
    private boolean mUnique, mSearching = false;
    private TableDataReloadable mReloadable = null;
    private MessageLabel mMessage = new MessageLabel();
    private Button mNewButton, mSelectButton;
    private ButtonHelper mNewButtonHelper, mSelectButtonHelper;
    private boolean mShowing = false;
    private int mRealtimeUpdatingSuppressed = 0;
    private boolean mUpdateRequested = false;

    public FilteringTableModel( VoDataProvider<RowType> pDataProvider, boolean pUnique, //
                                TableClickCommand<RowType> pDefaultSingleRowTableClickCommand, //
                                TableClickCommand<RowType> pDefaultNoRowTableClickCommand, boolean pNewAllowed ) {
        mFilterManager = new DataProviderFilterManager<RowType>( pDataProvider, this );
        mDefaultSingleRowTableClickCommand = pDefaultSingleRowTableClickCommand;
        mDefaultNoRowTableClickCommand = pDefaultNoRowTableClickCommand;
        mUnique = pUnique;

        mNewButtonHelper = new ButtonHelper( pNewAllowed, mNewButton = NewButton.factory().enabledToolTip( "Create New Record" ).add( new ClickHandler() {
            @Override
            public void onClick( ClickEvent event ) {
                requestNew();
            }
        } ).create() );
        updateNewButton();
        mSelectButtonHelper = new ButtonHelper( true, mSelectButton = SelectButton.factory().enabledToolTip( "Single Row Select" ).add( new ClickHandler() {
            @Override
            public void onClick( ClickEvent event ) {
                requestSingle();
            }
        } ).create() );
        updateSelectButton();
    }

    private void updateNewButton() {
        mNewButtonHelper.update( !mUnique || mList.isEmpty() );
    }

    private void updateSelectButton() {
        mSelectButtonHelper.update( mList.size() == 1 );
    }

    public Widget addReloadable( TableDataReloadable pReloadable ) {
        SizeableHorizontalPanel zStatusBar = new SizeableHorizontalPanel().style( STYLE_STATUS ).stretchableHorizontally();
        zStatusBar.setVerticalAlignment( HasVerticalAlignment.ALIGN_MIDDLE );
        zStatusBar.add( mNewButton );
        zStatusBar.add( new Spacer().width( 20 ) );
        zStatusBar.add( mMessage );
        zStatusBar.add( new Spacer().width( 20 ) );
        zStatusBar.add( mSelectButton );

        SizeableVerticalPanel zPanel = new SizeableVerticalPanel().stretchable();
        zPanel.add( (Widget) (mReloadable = pReloadable) );
        zPanel.add( zStatusBar );

        return zPanel;
    }

    @Override
    public void setSearching( boolean pSearching ) {
        if ( mSearching != pSearching ) {
            mSearching = pSearching;
            updateNewButton();
            updateSelectButton();
        }
    }

    @Override
    public boolean defaultRequested() {
        if ( mSearching ) {
            switch ( mList.size() ) {
                case 0:
                    return requestNew();
                case 1:
                    return requestSingle();
                default:
                    break;
            }
        }
        return false;
    }

    private boolean requestSingle() {
        if ( (mDefaultSingleRowTableClickCommand != null) && (mList.size() == 1) ) {
            mDefaultSingleRowTableClickCommand.execute( mList.get( 0 ) );
            return true;
        }
        return false;
    }

    private boolean requestNew() {
        if ( mDefaultNoRowTableClickCommand != null ) {
            mDefaultNoRowTableClickCommand.execute( null );
            return true;
        }
        return false;
    }

    @Override
    public boolean isRealtimeUpdatingSuppressed() {
        return mRealtimeUpdatingSuppressed != 0;
    }

    @Override
    public void suppressRealtimeUpdating() {
        mRealtimeUpdatingSuppressed++;
    }

    @Override
    public void releaseRealtimeUpdating() {
        if ( 0 > --mRealtimeUpdatingSuppressed ) {
            mRealtimeUpdatingSuppressed = 0;
        }
        chkList();
    }

    @Override
    public void showResults( boolean pShow ) {
        mShowing = pShow;
        chkList();
    }

    @Override
    public void clearCache() {
        mFilterManager.clearCache();
    }

    @Override
    public void clearAllFilterValues() {
        if ( mFilterManager.clear() ) {
            chkList();
        }
    }

    @Override
    public void filterValueChanged( BoAccessorFilterType pFilterType, String pAttributeName, String pValue ) {
        if ( mFilterManager.setFilter( pFilterType, pAttributeName, pValue ) ) {
            chkList();
        }
    }

    @Override
    public int activeFilters() {
        return mFilterManager.activeFilters();
    }

    private void chkList() {
        if ( mShowing && !isRealtimeUpdatingSuppressed() && (mReloadable != null) ) {
            boolean zPrevState = mUpdateRequested;
            mUpdateRequested = true;
            if ( !mFilterManager.updateList() ) {
                mUpdateRequested = zPrevState;
            }
        }
    }

    @Override
    public ImmutableArrayList<RowType> filterRows( ImmutableArrayList<RowType> pRows ) {
        return pRows;
    }

    @Override
    public void setNewList( List<RowType> pList, String pMsgText ) {
        mUpdateRequested = false;
        mMessage.setText( pMsgText );
        if ( mAsyncPending == null ) {
            mNewList = pList;
            if ( mReloadable != null ) {
                mReloadable.loadData();
            }
        } else {
            mNewList = null; // just in case
            AsyncPending<RowType> zPending = mAsyncPending;
            mAsyncPending = null;
            updateUnderlyingList( pList, zPending.getRequest(), zPending.getCallback() );
        }
    }

    private void updateUnderlyingList( List<RowType> pList, Request pRequest, Callback<RowType> pCallback ) {
        mList = pList;
        updateRowCount();
        updateNewButton();
        updateSelectButton();
        super.requestRows( pRequest, pCallback );
    }

    private static class AsyncPending<RowType> {
        private Request mRequest;
        private Callback<RowType> mCallback;

        private AsyncPending( Request pRequest, Callback<RowType> pCallback ) {
            mRequest = pRequest;
            mCallback = pCallback;
        }

        public Request getRequest() {
            return mRequest;
        }

        public Callback<RowType> getCallback() {
            return mCallback;
        }
    }

    private AsyncPending<RowType> mAsyncPending = null;
    private List<RowType> mNewList = null;

    @Override
    public void requestRows( Request pRequest, Callback<RowType> pCallback ) {
        if ( mNewList != null ) {
            List<RowType> zNewList = mNewList;
            mNewList = null;
            updateUnderlyingList( zNewList, pRequest, pCallback );
        } else if ( mUpdateRequested ) {
            mAsyncPending = new AsyncPending<RowType>( pRequest, pCallback );
        } else {
            super.requestRows( pRequest, pCallback );
        }
    }

    private ImmutableArrayList<RowType> getImmutableArrayList() {
        return new ImmutableArrayList<RowType>( mList );
    }

    @Override
    public Iterator<RowType> iterator() {
        return getImmutableArrayList().iterator();
    }

    @Override
    public ListIterator<RowType> listIterator() {
        return getImmutableArrayList().listIterator();
    }

    @Override
    public ListIterator<RowType> listIterator( int pIndex ) {
        return getImmutableArrayList().listIterator( pIndex );
    }

    @Override
    @Deprecated
    public void add( int pIndex, RowType pElement ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean add( RowType pO ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean addAll( Collection<? extends RowType> pC ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean addAll( int pIndex, Collection<? extends RowType> pC ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public void clear() {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public RowType remove( int pIndex ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean remove( Object pO ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean removeAll( Collection<?> pC ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public boolean retainAll( Collection<?> pC ) {
        throw new UnsupportedOperationException();
    }

    @Override
    @Deprecated
    public RowType set( int pIndex, RowType pElement ) {
        throw new UnsupportedOperationException();
    }

    private static class MessageLabel extends SizeableLabel {
        private MessageLabel() {
            super( FilterManager.NOTHING_ENTERED, false );
            addStyleName( STYLE_HAS_MSG );
            addStyleName( QBE_MSG );
            stretchableHorizontally();
        }

        @Override
        public void setText( String pLabelText ) {
            pLabelText = ConstrainTo.significantOrNull( pLabelText );
            if ( pLabelText == null ) {
                removeStyleName( STYLE_HAS_MSG );
                addStyleName( STYLE_NO_MSG );
                super.setText( " " );
            } else {
                removeStyleName( STYLE_NO_MSG );
                addStyleName( STYLE_HAS_MSG );
                super.setText( pLabelText );
            }
        }
    }

    private class ButtonHelper {
        private boolean mVisible = true;
        private boolean mEnabled = true;
        private boolean mAllowed;
        private Button mButton;

        public ButtonHelper( boolean pAllowed, Button pButton ) {
            mAllowed = pAllowed;
            mButton = pButton;
        }

        public void update( boolean pPossiblyEnable ) {
            if ( !mAllowed ) {
                if ( mVisible ) {
                    UtilsGwt.setHidden( mButton, !(mVisible = false) );
                }
                return;
            }
            if ( mSearching != mVisible ) {
                UtilsGwt.setHidden( mButton, !(mVisible = mSearching) );
                if ( !mVisible ) {
                    return;
                }
            }
            boolean zEnabled = pPossiblyEnable && !mFilterManager.isEmpty();
            if ( mEnabled != zEnabled ) {
                mButton.setEnabled( mEnabled = zEnabled );
            }
        }
    }
}