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

import org.litesoft.externalization.shared.*;

import com.google.gwt.user.client.ui.*;
import com.temp.foundation.client.widget.*;
import com.temp.foundation.client.widget.input.fieldsupport.*;
import com.temp.common.shared.utils.*;

import java.util.*;

/**
 * This is not a "real" Widget backed InputField, but a Proxy to a number of RadioButtonInputFields
 */
public class RadioButtonGroupInputField extends AbstractInputField<String, RadioButtonGroupInputField> {

    private final Panel container;
    private final FieldAccessor fieldAccessor;

    private E13nResolver resolver = null;

    public RadioButtonGroupInputField( Panel container, //
                                       RadioButtonInputField radioButton1, //
                                       RadioButtonInputField radioButton2, //
                                       RadioButtonInputField... additionalRadioButtons ) {
        this.container = container;
        fieldAccessor = new FieldAccessor( radioButton1, radioButton2, additionalRadioButtons, //
                                           new ChangeListener<Boolean>() {
                                               @Override
                                               public void changed( InputField<Boolean> radioButton ) {
                                                   processDataChanged();
                                               }
                                           }, //
                                           new FocusChangedListener() {
                                               @Override
                                               public void focusChanged() {
                                                   processFocusChanged();
                                               }
                                           } //
        );
    }

    @Override
    protected Panel getContainer() {
        return container;
    }

    @Override
    protected HasEnabled getEnableable() {
        return fieldAccessor;
    }

    @Override
    public String getName() {
        return fieldAccessor.groupName;
    }

    @Override
    public void setName( String name ) {
        throw new IllegalStateException( "Name Not Settable, Determined automatically" );
    }

    @Override
    public void init( E13nResolver parentResolver ) {
        resolver = new ContextualE13nResolver( parentResolver, getName() );
        fieldAccessor.init( resolver );
    }

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

    // Only callable in Run Mode

    @Override
    public final void reset() {
        checkRunMode( "reset" ).setValue( null );
    }

    @Override
    public final String setCurrentValue( String value ) {
        assertRunMode( "setCurrentValue" );
        fieldAccessor.setValue( value );
        return fieldAccessor.getValue();
    }

    @Override
    public final String getCurrentValue() {
        return checkRunMode( "getCurrentValue" ).getValue();
    }

    @Override
    public final String getBaseValue() {
        return checkRunMode( "getBaseValue" ).getBaseValue();
    }

    @Override
    public final void revert() {
        assertRunMode( "revert" );
        fieldAccessor.setValue( fieldAccessor.getBaseValue() );
    }

    @Override
    public final boolean isChanged() {
        return checkRunMode( "isChanged" ).isChanged();
    }

    @Override
    public final Boolean isFocused() {
        assertRunMode( "isFocused" );
        Boolean focused = fieldAccessor.isFocused();
        return Boolean.TRUE.equals( focused ) ? isVisible() : focused;
    }

    @Override
    public final boolean isErrored() {
        assertRunMode( "isErrored" );
        return false;
    }

    @Override
    public final E13nData getErrorData() {
        assertRunMode( "getErrorData" );
        return null;
    }

    @Override
    public final boolean validate() {
        assertRunMode( "validate" );
        updateStyle( fieldAccessor );
        return true;
    }

    @Override
    public final boolean setFocused() {
        assertRunMode( "setFocused" );
        return isVisible() && fieldAccessor.setFocused();
    }

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

    @Override
    public NameToID addNamedWidgetsTo( NameToID nameToID ) {
        return checkRunMode( "addNamedWidgetsTo" ).addNamedWidgetsTo( nameToID );
    }

    // Support Methods...

    protected void processDataChanged() {
        updateStyle( checkRunMode( "processDataChanged" ) );
        notifyChangeListeners();
    }

    protected void processFocusChanged() {
        updateStyle( checkRunMode( "processFocusChanged" ) );
        notifyFocusChangeListeners();
    }

    protected void updateStyle( FieldAccessor fieldAccessor ) {
        updateStyle( StateInputField.BASE //
                             .focused( Boolean.TRUE.equals( fieldAccessor.isFocused() ) ) //
                             .changed( fieldAccessor.isChanged() ) );
    }

    protected final FieldAccessor checkRunMode( String method ) {
        assertRunMode( method );
        return fieldAccessor;
    }

    private static class FieldAccessor implements HasEnabled {
        private final String groupName;
        private final List<RadioButtonInputField> radioButtons = new ArrayList<RadioButtonInputField>();
        private RadioButtonInputField nullValue;
        private RadioButtonInputField baseValue;

        public FieldAccessor( RadioButtonInputField radioButton1, //
                              RadioButtonInputField radioButton2, //
                              RadioButtonInputField[] additionalRadioButtons, //
                              ChangeListener<Boolean> changeListener,
                              FocusChangedListener focusChangedListener ) {

            groupName = getGroup( radioButton1 );

            add( radioButton1, changeListener, focusChangedListener );
            add( radioButton2, changeListener, focusChangedListener );
            if ( additionalRadioButtons != null ) {
                for ( RadioButtonInputField radioButton : additionalRadioButtons ) {
                    add( radioButton, changeListener, focusChangedListener );
                }
            }
        }

        private static String getGroup( RadioButtonInputField radioButton ) {
            String groupName = StringUtils.noEmpty( radioButton.getGroup() );
            if ( groupName != null ) {
                return groupName;
            }
            throw new IllegalStateException( "RadioButton named '" + radioButton.getName() + "', had No Group (name)" );
        }

        private void add( RadioButtonInputField radioButton, ChangeListener<Boolean> changeListener, FocusChangedListener focusChangedListener ) {
            String group = getGroup( radioButton );
            if ( !groupName.equals( group ) ) {
                throw new IllegalArgumentException( "RadioButton named '" + radioButton.getName() + "', " + //
                                                    "Group (name) mismatch, expected '" + groupName + "', but got '" + group + "'" );
            }
            radioButtons.add( radioButton );
            radioButton.add( changeListener );
            radioButton.add( focusChangedListener );
        }

        public void init( E13nResolver resolver ) {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                radioButton.init( resolver );
                if ( Boolean.TRUE.equals( radioButton.getCurrentValue() ) ) {
                    if ( nullValue == null ) {
                        nullValue = radioButton;
                    } else {
                        radioButton.setCurrentValue( false );
                    }
                }
            }
            if ( nullValue == null ) {
                nullValue = radioButtons.get( 0 );
                nullValue.setCurrentValue( true );
            }
            baseValue = nullValue;
        }

        public boolean isChanged() {
            return (baseValue != findSelected());
        }

        public String getBaseValue() {
            return baseValue.getName();
        }

        public String getValue() {
            return findSelected().getName();
        }

        public void setValue( String radioButtonName ) {
            baseValue = ObjectUtils.deNull( findByName( radioButtonName ), nullValue );
            baseValue.setCurrentValue( true );
        }

        private RadioButtonInputField findSelected() {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                if ( Boolean.TRUE.equals( radioButton.getCurrentValue() ) ) {
                    return radioButton;
                }
            }
            nullValue.setCurrentValue( true );
            return nullValue;
        }

        private RadioButtonInputField findByName( String radioButtonName ) {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                if ( radioButton.getName().equals( radioButtonName ) ) {
                    return radioButton;
                }
            }
            return null;
        }

        public Boolean isFocused() {
            boolean anyUnableToDetermineFocus = false;
            for ( RadioButtonInputField radioButton : radioButtons ) {
                Boolean focused = radioButton.isFocused();
                if ( focused == null ) {
                    anyUnableToDetermineFocus = true;
                } else if ( focused ) {
                    return true;
                }
            }
            return anyUnableToDetermineFocus ? null : false;
        }

        public boolean setFocused() {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                Boolean focused = radioButton.isFocused();
                if ( Boolean.TRUE.equals( focused ) ) {
                    return true;
                }
            }
            for ( RadioButtonInputField radioButton : radioButtons ) {
                if ( radioButton.setFocused() ) {
                    return true;
                }
            }
            return false;
        }

        public NameToID addNamedWidgetsTo( NameToID nameToID ) {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                radioButton.addNamedWidgetsTo( nameToID );
            }
            return nameToID;
        }

        @Override
        public boolean isEnabled() {
            int enabled = 0;
            for ( RadioButtonInputField radioButton : radioButtons ) {
                if ( radioButton.isEnabled() ) {
                    enabled++;
                }
            }
            return (enabled > 1);
        }

        @Override
        public void setEnabled( boolean enabled ) {
            for ( RadioButtonInputField radioButton : radioButtons ) {
                radioButton.setEnabled( enabled );
            }
        }
    }
}