package org.litesoft.GWT.client.view;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.context.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.forms.client.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.bo.views.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.*;
import org.litesoft.security.*;
import org.litesoft.uispecification.*;

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

import static org.litesoft.uispecification.FormWidgetCtrl.*;

public class ChangePassword<T extends SecurityUserView<T>> extends DialogView implements SecurityUserViewNames
{
    private FormEngine mFE;

    private SecurityUserViewDataProvider<T> mDataProvider;
    private FormBinder<T> mFormBinder;
    private ButtonBase mSubmitButton;
    private boolean mAllowCancel;

    public ChangePassword( String pSection, ViewDef pViewDef )
    {
        this( title( pSection, pViewDef ), true );
    }

    public ChangePassword( String pTitle ) // e.g. Reset Password
    {
        this( title( pTitle ), false );
    }

    private ChangePassword( CO pCO, boolean pAllowCancel )
    {
        super( pCO, Opaqueness.Semi );

        mAllowCancel = pAllowCancel;

        ClientContext zContext = ClientContext.get();

        mDataProvider = zContext.get( SecurityUserViewDataProvider.class );
        SecurityUserViewMetaData<T> zUserViewMetaData = zContext.get( SecurityUserViewMetaData.class );

        final T zUser = ((AbstractCurrentUserViewAccessor<T>) zContext.get( AbstractCurrentUserViewAccessor.class )).getUser();

        WidgetCtrlMap zWidgetCtrlMap = new WidgetCtrlMap( VISIBLE_AND_ACTIVE_ENABLED );

        zWidgetCtrlMap.add( VISIBLE_BUT_DISABLED, aLogonEmail );
        zWidgetCtrlMap.add( EDIT_ONLY.required(), aCurrentPassword, aNewPassword, aConfirmPassword );

        mFE = new FormEngine( zWidgetCtrlMap, FormEngine.Mode.EditRegular, new MyListenerFactory() )
        {
            @Override
            protected void changeOccurredOn( String pName, IFormComponent pComponent, boolean pChanged )
            {
                super.changeOccurredOn( pName, pComponent, pChanged );
                setDialogErrorMessage( null );
            }

            @Override
            protected void enterPressedOn( String pName, IFormComponent pComponent, KeyboardKeyModifier pModifiers )
            {
                if ( !focusFromTo( pName, aCurrentPassword, aNewPassword ) )
                {
                    if ( !focusFromTo( pName, aNewPassword, aConfirmPassword ) )
                    {
                        if ( pName.equals( aConfirmPassword ) && (mSubmitButton != null) && mSubmitButton.isEnabled() )
                        {
                            submitRequested();
                        }
                        else
                        {
                            super.enterPressedOn( pName, pComponent, pModifiers );
                        }
                    }
                }
            }

            private boolean focusFromTo( String pNameActual, String pFrom, String pTo )
            {
                if ( pFrom.equals( pNameActual ) )
                {
                    getNamedComponent( pTo ).setFocus();
                    return true;
                }
                return false;
            }
        };
        mFormBinder = new FormBinder<T>( mFE, zUserViewMetaData );

        mContent.setHorizontalAlignment( HasHorizontalAlignment.ALIGN_CENTER );
        add( new OurLabel( zUser.getFullName() ).style( "ChangePasswordUserName" ) );
        addLogonAndPasswords();
        add( new SizeableSpacer( 5 ).stretchable() );

        mFormBinder.setExistingObject( mDataProvider.copyIntoNewTS( zUser ).clearPasswordFields(), FormEngine.Mode.EditRegular );
    }

    private void addLogonAndPasswords()
    {
        SizeableHorizontalPanel zPanel = new SizeableHorizontalPanel().stretchableHorizontally();
        zPanel.add( mFormBinder.add( aLogonEmail, 0 ) );
        zPanel.add( mFormBinder.add( aCurrentPassword, PASSWORD_LENGTH ) );
        add( zPanel );
        add( new Spacer( 5 ) );
        zPanel = new SizeableHorizontalPanel().stretchableHorizontally();
        zPanel.setVerticalAlignment( HasVerticalAlignment.ALIGN_MIDDLE );
        zPanel.add( new SizeableSpacer( 5 ).stretchableHorizontally() );
        zPanel.add( new Label( "New Password: " ) );
        zPanel.add( mFormBinder.add( aNewPassword, PASSWORD_LENGTH, "" ) );
        add( zPanel );
        add( new Spacer( 5 ) );
        zPanel = new SizeableHorizontalPanel().stretchableHorizontally();
        zPanel.setVerticalAlignment( HasVerticalAlignment.ALIGN_MIDDLE );
        zPanel.add( new SizeableSpacer( 5 ).stretchableHorizontally() );
        zPanel.add( new Label( "Confirm New Password: " ) );
        zPanel.add( mFormBinder.add( aConfirmPassword, PASSWORD_LENGTH, "" ) );
        add( zPanel );
    }

    @Override
    public Widget getBottomBar()
    {
        LeftCenterRightHorizontalPanel zActionPanel = new LeftCenterRightHorizontalPanel();
        if ( mAllowCancel )
        {
            zActionPanel.addLeft( createCancelButton() );
        }
        zActionPanel.addRight( mFE.addEditSubmitButton( mSubmitButton = createSubmitButton() ) );
        return zActionPanel;
    }

    @Override
    public void aboutToShow()
    {
        super.aboutToShow();
        mFE.initialize();
    }

    @Override
    protected void justLoaded()
    {
        super.justLoaded();
        getStatusMessageSinc().clearMessage();
        mFE.setFocus();
    }

    @Override
    public void cancel()
    {
        getStatusMessageSinc().clearMessage();
        super.cancel();
    }

    @Override
    protected void submitRequested()
    {
        mFormBinder.commitForm();
        mDataProvider.changePassword( mFormBinder.getObject(), new SimpleDataProviderCallBack()
        {
            @Override
            public void error( String pError )
            {
                if ( Strings.isNotNullOrEmpty( pError ) )
                {
                    setDialogErrorMessage( pError );
                }
                else
                {
                    submitSucceeded();
                }
            }
        } );
    }

    protected void submitSucceeded()
    {
        getStatusMessageSinc().setWarningMessage( "Password Updated" );
        close();
    }

    private static class MyListenerFactory implements IFormComponent.Listener.Factory,
                                                      SecurityUserViewNames
    {
        private MyListener mNewPasswordListener, mConfirmPasswordListener;

        @Override
        public IFormComponent.Listener createListenerFor( String pName, IFormComponent pComponent )
        {
            if ( aNewPassword.equals( pName ) )
            {
                return mNewPasswordListener = new MyListener( pName, pComponent );
            }
            if ( aConfirmPassword.equals( pName ) )
            {
                return mConfirmPasswordListener = new MyListener( pName, pComponent );
            }
            return NoOpFormListener.INSTANCE;
        }

        private MyListener getOtherListener( MyListener pUs )
        {
            return (mNewPasswordListener == pUs) ? mConfirmPasswordListener : mNewPasswordListener;
        }

        private class MyListener extends NoOpFormListener
        {
            private String mLabel;
            private IFormComponent mComponent;

            private MyListener( String pName, IFormComponent pComponent )
            {
                mLabel = DeCamelizer.resolve( pName );
                mComponent = pComponent;
            }

            private String getCurrentValue()
            {
                Object zValue = mComponent.getCurrentValue();
                return (zValue != null) ? Strings.noEmpty( zValue.toString() ) : null;
            }

            @Override
            public void changeOccurred()
            {
                super.changeOccurred();
                MyListener them = getOtherListener( this );
                String zThisValue = this.getCurrentValue();
                String zThemValue = them.getCurrentValue();
                if ( (zThisValue != null) && (zThemValue != null) )
                {
                    boolean zMatches = zThisValue.equals( zThemValue );
                    this.updateError( them, zMatches );
                    them.updateError( this, zMatches );
                }
            }

            private void updateError( MyListener pThem, boolean pMatches )
            {
                mComponent.setError( pMatches ? null : mLabel + " does not match " + pThem.mLabel );
            }
        }
    }
}