// This Source Code is in the Public Domain per: http://unlicense.org
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.base.*;

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) ? ConstrainTo.significantOrNull( 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 );
        }
    }
}