package com.temp.client.foundation.widget.input;

import java.util.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.user.client.ui.*;
import com.temp.client.foundation.widget.*;
import com.temp.client.foundation.widget.input.support.*;
import com.temp.shared.*;
import com.temp.shared.externalization.*;
import com.temp.shared.utils.*;

/**
 * A FormEngine manages Buttons and FormEngineMembers (FormEngines & InputFields).
 * <p/>
 * It also manages:
 * <ul>
 * <li>Focus,</li>
 * <li>Validation,</li>
 * <li>Change State,</li>
 * <li>Error State, and</li>
 * <li>Blocking User Interaction during Server Interaction</li>
 * </ul>
 * <p/>
 * Note: The FormEngine is Enableable.  A <code>disabled</code> FormEngine
 * does not mean that it prohibits entry into its members, but that it does
 * not participate in: Focus, Validation, Change or Error State!
 * <p/>
 * Note: The Focus Search Order is:
 * <nl>
 * <li>FormEngineMembers (in the order they were added),</li>
 * <li>Submit Button, and lastly</li>
 * <li>Managed Buttons (in the order they were added)</li>
 * </nl>
 */
public class FormEngine implements ServerInteractionListener,
                                   FormEngineMember
{
    public interface Callback
    {
        void submit( String name );
    }

    private final String name;

    private final List<FormEngineMember> members = new ArrayList<FormEngineMember>();
    private final List<ButtonBase> managedButtons = new ArrayList<ButtonBase>();
    private ButtonBase submitButton = null;
    private Callback submitCallback = null;
    private final List<FormEngine> subForms = new ArrayList<FormEngine>();

    private boolean enabled = true;
    private E13nResolver resolver = null;

    public FormEngine( String name )
    {
        this.name = Validate.noEmptyIdentifier( "Name", name );
    }

    public final String getName()
    {
        return name;
    }

    // Only Called in Builder Mode:

    /**
     * Add the Form's Members - The order added will be the order processed for Focus
     */
    public void add( FormEngineMember... members )
    {
        assertBuildMode( "add( members )" );
        if ( members != null )
        {
            for ( FormEngineMember member : members )
            {
                memberAdd( member );
            }
        }
    }

    public void setSubmit( ButtonBase submitButton, Callback submitCallback )
    {
        assertBuildMode( "setSubmit" );
        this.submitButton = submitButton;
        this.submitCallback = submitCallback;
    }

    public void addManaged( ButtonBase... managedButtons )
    {
        assertBuildMode( "addManaged" );
        if ( managedButtons != null )
        {
            for ( ButtonBase button : managedButtons )
            {
                managedAdd( button );
            }
        }
    }

    @Override
    public void init( E13nResolver parentResolver )
    {
        Validate.notNull( "resolver", parentResolver );
        assertBuildMode( "init" );

        if ( submitButton == null && members.isEmpty() && managedButtons.isEmpty() )
        {
            throw new IllegalStateException( "Nothing 'in' the FormEngine, No: Submit Button, Members, or Managed Buttons" );
        }

        resolver = new OptionallyPrefixingE13nResolver( name, parentResolver ); // add our name to keys!

        for ( FormEngineMember member : members )
        {
            member.init( resolver );
        }
        for ( ButtonBase button : managedButtons )
        {
            buttonInit( button );
        }
        if ( submitButton != null )
        {
            buttonInit( submitButton );
            submitButton.addClickHandler( new ClickHandler()
            {
                @Override
                public void onClick( ClickEvent event )
                {
                    if ( validate() )
                    {
                        if ( submitCallback != null )
                        {
                            submitCallback.submit( getName() );
                        }
                    }
                }
            } );
        }
    }

    // Callable anytime:

    @Override
    public boolean isRunMode()
    {
        return (resolver != null);
    }

    @Override
    public boolean isEnabled()
    {
        return enabled;
    }

    @Override
    public void setEnabled( boolean enabled )
    {
        this.enabled = enabled;
    }

    // Only callable in Run Mode:

    @Override
    public void reset()
    {
        checkRunMode( "reset" );
        for ( FormEngineMember member : members )
        {
            member.reset();
        }
    }

    @Override
    public void revert()
    {
        checkRunMode( "revert" );
        for ( FormEngineMember member : members )
        {
            member.revert();
        }
    }

    @Override
    public boolean isChanged()
    {
        checkRunMode( "isChanged" );
        if ( isEnabled() )
        {
            for ( FormEngineMember member : members )
            {
                if ( member.isEnabled() )
                {
                    if ( member.isChanged() )
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    @Override
    public Boolean isFocused()
    {
        checkRunMode( "isFocused" );
        boolean anyFalse = false;
        if ( isEnabled() )
        {
            for ( FormEngineMember member : members )
            {
                if ( member.isEnabled() )
                {
                    Boolean focused = member.isFocused();
                    if ( focused != null )
                    {
                        if ( focused )
                        {
                            return true;
                        }
                        anyFalse = true;
                    }
                }
            }
        }
        return anyFalse ? false : null;
    }

    @Override
    public boolean isErrored()
    {
        checkRunMode( "isErrored" );
        if ( isEnabled() )
        {
            for ( FormEngineMember member : members )
            {
                if ( member.isEnabled() )
                {
                    if ( member.isErrored() )
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    @Override
    public boolean validate()
    {
        checkRunMode( "validate" );
        boolean valid = true;
        if ( isEnabled() )
        {
            for ( FormEngineMember member : members )
            {
                if ( member.isEnabled() )
                {
                    valid &= member.validate();
                }
            }
        }
        return valid;
    }

    @Override
    public boolean setFocused()
    {
        checkRunMode( "setFocused" );
        if ( isEnabled() )
        {
            // 1st - Members
            for ( FormEngineMember member : members )
            {
                if ( member.isEnabled() )
                {
                    if ( member.setFocused() )
                    {
                        return true;
                    }
                }
            }
            // 2nd - Submit Button
            if ( submitButton != null && submitButton.isEnabled() )
            {
                submitButton.setFocus( true );
                return true;
            }
            // 3rd - Managed Buttons
            for ( ButtonBase button : managedButtons )
            {
                if ( button.isEnabled() )
                {
                    button.setFocus( true );
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public E13nResolver getE13nResolver()
    {
        checkRunMode( "getE13nResolver" );
        return resolver;
    }

    @Override
    public NameToID addNamedWidgetsTo( NameToID nameToID )
    {
        checkRunMode( "addNamedWidgetsTo" );
        for ( FormEngineMember member : members )
        {
            member.addNamedWidgetsTo( nameToID );
        }
        return nameToID;
    }

    @Override
    public void busyInteractingWithServer()
    {
        checkRunMode( "busyInteractingWithServer" );
        System.out.println( "FormEngine.busyInteractingWithServer" );
    }

    @Override
    public void doneInteractingWithServer()
    {
        checkRunMode( "doneInteractingWithServer" );
        System.out.println( "FormEngine.doneInteractingWithServer" );
    }

    protected final void assertBuildMode( String method )
    {
        if ( isRunMode() )
        {
            throw new IllegalStateException( "Unable to process method '" + method + "' of FormEngine Named '" + name + "', because no longer in Build Mode (init has already been called)" );
        }
    }

    protected final void checkRunMode( String method )
    {
        if ( !isRunMode() )
        {
            throw new IllegalStateException( "Unable to process method '" + method + "' of FormEngine Named '" + name + "', because not in Run Mode (init NOT called)" );
        }
    }

    private void memberAdd( FormEngineMember member )
    {
        if ( member != null )
        {
            members.add( member );
            if ( member instanceof FormEngine )
            {
                subForms.add( (FormEngine) member );
            }
        }
    }

    private void managedAdd( ButtonBase managed )
    {
        if ( managed != null )
        {
            managedButtons.add( managed );
        }
    }

    private void buttonInit( ButtonBase button )
    {
        if ( button instanceof NamedTextButton )
        {
            ((NamedTextButton) button).init( resolver );
        }
    }
}