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

import org.litesoft.core.util.externalization.*;

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.utils.*;

@SuppressWarnings("deprecation")
public class CompleteInputFieldAccessor<T> extends InputFieldAccessor<T> {
    private final E13nResolver e13nResolver;
    private final Widget labelLabel;
    private final Widget extendedLabel;
    private final Widget exampleLabel;
    private final Widget errorLabel;
    private final HelpWidget helpWidget;
    private final Boolean[] focusableFocused;
    private final Focusable focusable;
    private final boolean anyFocusTracking;
    private FocusChangedListener focusChangedListener;

    public CompleteInputFieldAccessor( E13nResolver e13nResolver, TextLabel labelLabel, TextLabel extendedLabel, InputFieldAccessor<T> inputFieldAccessor,
                                       HelpWidget helpWidget, TextLabel exampleLabel, TextLabel errorLabel, Focusable... additionalFocusables ) {
        super( inputFieldAccessor.getInput(), inputFieldAccessor.getValidator(), inputFieldAccessor.getValueAdapter(), inputFieldAccessor.getInputWidget(),
               append( inputFieldAccessor.getFocusables(), additionalFocusables ) );
        this.e13nResolver = e13nResolver;
        this.labelLabel = labelLabel;
        this.extendedLabel = extendedLabel;
        this.exampleLabel = exampleLabel;
        this.errorLabel = errorLabel;
        this.helpWidget = helpWidget;
        focusableFocused = new Boolean[focusables.length];
        Focusable firstFocusable = null;
        boolean anyFocusTracking = false;
        for ( int i = 0; i < focusables.length; i++ ) {
            Focusable focusable = focusables[i];
            if ( focusable != null ) {
                if ( firstFocusable == null ) {
                    firstFocusable = focusable;
                }
                if ( registerFocusTracking( i, focusable ) ) {
                    focusableFocused[i] = false; // Not currently Focused!
                    anyFocusTracking = true;
                }
            }
        }
        this.focusable = firstFocusable;
        this.anyFocusTracking = anyFocusTracking;
    }

    private boolean registerFocusTracking( int index, Focusable focusable ) {
        if ( focusable instanceof HasAllFocusHandlers ) {
            createFocusHandler( index, (HasAllFocusHandlers) focusable );
            return true;
        }
        if ( focusable instanceof SourcesFocusEvents ) {
            createFocusListener( index, (SourcesFocusEvents) focusable );
            return true;
        }
        return false;
    }

    public E13nResolver getE13nResolver() {
        return e13nResolver;
    }

    public Widget getLabelLabel() {
        return labelLabel;
    }

    public Widget getExtendedLabel() {
        return extendedLabel;
    }

    public Widget getExampleLabel() {
        return exampleLabel;
    }

    public Widget getErrorLabel() {
        return errorLabel;
    }

    public HelpWidget getHelpWidget() {
        return helpWidget;
    }

    public void init( boolean enabled, FocusChangedListener focusChangedListener ) {
        setEnabled( enabled );
        this.focusChangedListener = focusChangedListener;
    }

    /**
     * Return if the Field has Focus (or null indicating that the Focus state is not tracked)
     */
    public Boolean isFocused() {
        if ( !anyFocusTracking ) {
            return null;
        }
        if ( isEnabled() ) {
            for ( Boolean focused : focusableFocused ) {
                if ( Boolean.TRUE.equals( focused ) ) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Pull the Focus to this Field (return false if the field is "thought" to be currently un-focusable, e.g. has no Focusable components or disabled)
     */
    public boolean setFocused() {
        if ( isEnabled() && (focusable != null) ) {
            focusable.setFocus( true );
            // We "should" get the appropriate events...
            return true;
        }
        return false;
    }

    private void focusChange( int index, boolean focused ) {
        if ( focusableFocused[index] != focused ) {
            focusableFocused[index] = focused;
            if ( focusChangedListener != null ) {
                focusChangedListener.focusChanged();
            }
        }
    }

    private void createFocusListener( final int index, SourcesFocusEvents focusable ) {
        focusable.addFocusListener( new FocusListener() {
            @Override
            public void onFocus( Widget sender ) {
                focusChange( index, true );
            }

            @Override
            public void onLostFocus( Widget sender ) {
                focusChange( index, false );
            }
        } );
    }

    private void createFocusHandler( int index, HasAllFocusHandlers focusable ) {
        FocusBlurHandler handler = new FocusBlurHandler( index );
        focusable.addFocusHandler( handler );
        focusable.addBlurHandler( handler );
    }

    private class FocusBlurHandler implements FocusHandler,
                                              BlurHandler {
        private final int index;

        public FocusBlurHandler( int index ) {
            this.index = index;
        }

        @Override
        public void onFocus( FocusEvent event ) {
            focusChange( index, true );
        }

        @Override
        public void onBlur( BlurEvent event ) {
            focusChange( index, false );
        }
    }

    private static Focusable[] append( Focusable[] focusables1, Focusable[] focusables2 ) {
        if ( CollectionsUtils.isEmpty( focusables2 ) ) {
            return focusables1;
        }
        if ( CollectionsUtils.isEmpty( focusables1 ) ) {
            return focusables2;
        }
        Focusable[] merged = new Focusable[focusables1.length + focusables2.length];
        System.arraycopy( focusables1, 0, merged, 0, focusables1.length );
        System.arraycopy( focusables2, 0, merged, focusables1.length, focusables2.length );
        return merged;
    }
}