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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.datatables.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.bo.*;
import org.litesoft.commonfoundation.typeutils.*;

import com.google.gwt.user.client.ui.*;

public class QBE_FormEngine extends FormEngine
{
    protected UpdateFilterTransformer mFilterTransformer = NormalUpdateFilterTransformer.INSTANCE;
    protected BoAccessorFilter mFilter;
    protected SearchStateDefaultRequestable mSSDR;
    protected SizeableQBEboxedPanel mQBEboxedPanel;

    private Widget mPointerWidget = null;
    private Widget mCurrentPointerWidget = null;

    public QBE_FormEngine( WidgetCtrlMap pWidgetCtrlMap, IFormComponent.Listener.Factory pListenerFactory, SizeableQBEboxedPanel pQBEboxedPanel, BoAccessorFilter pFilter, SearchStateDefaultRequestable pSSDR )
    {
        super( pWidgetCtrlMap, Mode.Search, pListenerFactory );
        mFilter = (pFilter != null) ? pFilter : BoAccessorFilter.NULL;
        mSSDR = (pSSDR != null) ? pSSDR : SearchStateDefaultRequestable.NULL;
        mQBEboxedPanel = pQBEboxedPanel;
    }

    public Widget getPointerWidget()
    {
        return mPointerWidget;
    }

    public void setPointerWidget( Widget pPointerWidget )
    {
        mPointerWidget = pPointerWidget;
    }

    @Override
    public void setMode( Mode pMode )
    {
        if ( (pMode != null) && pMode.isEditing() )
        {
            mFilter.clearCache();
        }
        super.setMode( pMode );
        updateSSDR();
    }

    @Override
    protected void LLresetComponents( boolean pResetValues )
    {
        mFilter.suppressRealtimeUpdating();
        try
        {
            super.LLresetComponents( pResetValues );
            mFilter.clearAllFilterValues();
            mFilterTransformer.clearAllFilterValues( mFilter );
            if ( !mMode.shouldMonitorSearchFields() )
            {
                hideQBE();
                return;
            }
            // Assume that a setFocus will update the View appropriately
            for ( IFormComponent zComponent : mComponents )
            {
                if ( isSearchFilter( zComponent ) )
                {
                    updateFilter( zComponent );
                }
            }
        }
        finally
        {
            mFilter.releaseRealtimeUpdating();
        }
    }

    @Override
    protected void enterPressedOn( String pName, IFormComponent pComponent, KeyboardKeyModifier pModifiers )
    {
        if ( !mSSDR.defaultRequested() )
        {
            super.enterPressedOn( pName, pComponent, pModifiers );
        }
    }

    @Override
    protected void blurOccurredOn( String pName, IFormComponent pComponent )
    {
        super.blurOccurredOn( pName, pComponent );
    }

    @Override
    protected void changeOccurredOn( String pName, IFormComponent pComponent, boolean pChanged )
    {
        super.changeOccurredOn( pName, pComponent, pChanged );
        if ( isSearchFilter( pComponent ) )
        {
            updateFilter( pComponent );
            updateView( pComponent );
        }
    }

    protected void updateFilter( IFormComponent pComponent )
    {
        String zName = getComponentName( pComponent );
        if ( zName != null )
        {
            Object zValue = getNamedComponentValue( zName );
            String zValStr = (zValue != null) ? Strings.noEmpty( zValue.toString() ) : null;
            updateFilter( zName, zValStr );
        }
    }

    protected void updateFilter( String pName, String pValStr )
    {
        mFilterTransformer.updateFilter( mFilter, mWidgetCtrlMap.get( pName ).getFilterType(), pName, pValStr );
    }

    public UpdateFilterTransformer getFilterTransformer()
    {
        return mFilterTransformer;
    }

    public void setFilterTransformer( UpdateFilterTransformer pFilterTransformer )
    {
        mFilterTransformer = (pFilterTransformer != null) ? pFilterTransformer : NormalUpdateFilterTransformer.INSTANCE;
    }

    private boolean isSearchFilter( IFormComponent pComponent )
    {
        return mMode.isSearchFilter( mListeners.get( pComponent ) );
    }

    @Override
    protected void focusOccuredOn( String pName, IFormComponent pComponent )
    {
        super.focusOccuredOn( pName, pComponent );
        updateView( pComponent );
    }

    private void updateView( IFormComponent pComponent )
    {
        if ( mMode.shouldMonitorSearchFields() )
        {
            if ( mPointerWidget != null )
            {
                pointTo( mPointerWidget );
                return;
            }
            if ( isSearchFilter( pComponent ) )
            {
                pointTo( (Widget) pComponent );
                return;
            }
        }
        hideQBE();
    }

    public Widget getCurrentPointerWidget()
    {
        return mCurrentPointerWidget;
    }

    public void done()
    {
        hideQBE();
    }

    private void hideQBE()
    {
        mQBEboxedPanel.show( false );
        mFilter.showResults( false );
        mSSDR.setSearching( false );
    }

    protected void pointTo( Widget pWidget ) // also: showQBE
    {
        mQBEboxedPanel.pointTo( mCurrentPointerWidget = pWidget );
        mFilter.showResults( true );
        updateSSDR();
    }

    protected void updateSSDR()
    {
        mSSDR.setSearching( Mode.Search.equals( mMode ) );
    }

    private static class NormalUpdateFilterTransformer implements UpdateFilterTransformer
    {
        public static UpdateFilterTransformer INSTANCE = new NormalUpdateFilterTransformer();

        @Override
        public void clearAllFilterValues( BoAccessorFilter pFilter )
        {
        }

        @Override
        public void updateFilter( BoAccessorFilter pFilter, BoAccessorFilterType pFilterType, String pAttributeName, String pValue )
        {
            pFilter.filterValueChanged( pFilterType, pAttributeName, pValue );
        }
    }
}