// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.GWT.forms.client.components.impls.input;

import org.litesoft.commonfoundation.html.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.core.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.ui.*;
import org.litesoft.uispecification.*;

import com.google.gwt.core.client.*;
import com.google.gwt.dom.client.*;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.ui.*;

public class FormRadioGroup extends AbstractFormElement implements ChangeHandler
{
    protected final InfoIndicator mInfoIndicator = new InfoIndicator();

    public FormRadioGroup( String pGroupLabel, UiFont pLabelFont, String pTooltip, SimpleKeyValuePair... pOptions )
    {
        super( DOM.createFieldSet() );
        mFieldLabel = pGroupLabel;
        mTooltip = pTooltip;
        int zInstanceNumber = StaticSimpleIdSource.getNext();

        mInfoIndicator.setTooltip( Strings.deNull( pTooltip ).trim() );

        pGroupLabel = Strings.noEmpty( pGroupLabel );

        String zGroupName = "RadioGroup" + zInstanceNumber;
        String legendId = "lgnd" + zInstanceNumber;
        String legendHTML = (pGroupLabel == null) ? "" : "<legend id=" + legendId + " class='litesoft-FormComponentRadioGroupLegend'" + ApplyFont.toHtmlStyle( pLabelFont ) + "><img src='common/images/misc/TransparentSpacer_h18.gif'>" + pGroupLabel + "</legend>";
        String html = legendHTML + "<div id='" + zGroupName + "'></div>";

        initializeHTML( html );
        if ( (legendHTML.length() != 0) && mInfoIndicator.mCanShow )
        {
            mInnerHTMLpanel.add( mInfoIndicator, legendId );
        }

        if ( pOptions != null )
        {
            for ( SimpleKeyValuePair option : pOptions )
            {
                if ( option != null )
                {
                    RadioButtonProxy radioButtonProxy = new RadioButtonProxy( zGroupName, option, this );
                    mRadioButtons.add( radioButtonProxy );
                    mInnerHTMLpanel.add( radioButtonProxy, zGroupName );
                }
            }
        }
        if ( mRadioButtons.size() < 2 )
        {
            throw new IllegalArgumentException( "Radio Groups Must have at least two options" );
        }
        setDefaultSelection();
    }

    public FormRadioGroup( String pGroupLabel, UiFont pLabelFont, String pTooltip, String... pOptions )
    {
        this( pGroupLabel, pLabelFont, pTooltip, convertToKeyValuePairs( pOptions ) );
    }

    private ArrayList<RadioButtonProxy> mRadioButtons = new ArrayList<RadioButtonProxy>();

    private RadioButtonProxy getRadioButon( int pI )
    {
        return mRadioButtons.get( pI );
    }

    // Changehandler

    @Override
    public void onChange( ChangeEvent event ) // possibleStateChange
    {
        if ( mDelayedStateChecker == null )
        {
            mDelayedStateChecker = new DelayedStateChecker();
        }
        Scheduler.get().scheduleDeferred( mDelayedStateChecker.getCommandToDefer() );
    }

    // SizeManaged

    @Override
    public void relayout()
    {
        Widget parent = getParent();
        if ( parent instanceof SizeManaged )
        {
            ((SizeManaged) parent).relayout();
        }
    }

    // IFormComponent

    @Override
    public boolean setFocus()
    {
        pullFocusTo( getRadioButon( 0 ) );
        return true;
    }

    @Override
    public Object getCurrentValue()
    {
        return (mLastSelection != null) ? mLastSelection.getKeyValuePair() : setDefaultSelection();
    }

    @Override
    public void setCurrentValue( Object pNewValue )
    {
        if ( pNewValue != null )
        {
            setSelected( getProxyFor( pNewValue ) );
        }
    }

    @Override
    public void setEnabled( boolean pEnabled )
    {
        mEnabled = pEnabled;
        for ( int i = 0; i < mRadioButtons.size(); i++ )
        {
            RadioButtonProxy radioButtonProxy = getRadioButon( i );
            radioButtonProxy.setEnabled( pEnabled );
        }
        stateChanged();
    }

    // AbstractFormElement

    @Override
    protected void setEnabledStyles()
    {
        super.setEnabledStyles();
        mInfoIndicator.setVisible( hasFocus() );
    }

    @Override
    public void publishAnyPendingChanges()
    {
        FocusSelection zFS = determineFocusSelection();
        RadioButtonProxy prevLastSelection = mLastSelection;
        if ( zFS.getSelected() != null )
        {
            setLastSelected( zFS.getSelected() );
        }
        RadioButtonProxy curLastSelection = mLastSelection;
        if ( prevLastSelection != curLastSelection )
        {
            fireChangeListeners();
        }
        if ( mReportedFocus )
        {
            mReportedFocus = false;
            fireBlurListeners();
        }
        super.publishAnyPendingChanges();
    }

    // Support...

    @Override
    public void simulateUserTextEntry( String pText )
    {
        RadioButtonProxy zCurrentSelection = mLastSelection;
        setLastSelected( determineItemToSelect( Strings.deNull( pText ).trim() ) );
        if ( zCurrentSelection != mLastSelection )
        {
            mLastSelection.setChecked();
            fireChangeListeners();
        }
        pullFocusTo( mLastSelection );
    }

    private RadioButtonProxy determineItemToSelect( String pText )
    {
        for ( int i = 0; i < mRadioButtons.size(); i++ )
        {
            RadioButtonProxy radioButtonProxy = getRadioButon( i );
            if ( pText.equals( radioButtonProxy.getKeyValuePair().toStringValue() ) )
            {
                return radioButtonProxy;
            }
        }
        throw new IllegalArgumentException( "simulateUserTextEntry on '" + mFieldLabel + "' to:" + pText );
    }

    //vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv//

    private RadioButtonProxy getProxyFor( Object pNewValue )
    {
        Object pairKey;
        if ( pNewValue instanceof SimpleKeyValuePair )
        {
            pairKey = ((SimpleKeyValuePair) pNewValue).getKey();
        }
        else if ( pNewValue instanceof String )
        {
            pairKey = pNewValue;
        }
        else
        {
            pairKey = "?" + pNewValue;
        }
        for ( int i = 0; i < mRadioButtons.size(); i++ )
        {
            RadioButtonProxy radioButtonProxy = getRadioButon( i );
            if ( pairKey.equals( radioButtonProxy.getKeyValuePair().getKey() ) )
            {
                return radioButtonProxy;
            }
        }
        throw new IllegalArgumentException( "No Valid Option in Radio Group of: " + pNewValue );
    }

    private SimpleKeyValuePair setDefaultSelection()
    {
        SimpleKeyValuePair rv = getRadioButon( 0 ).getKeyValuePair();
        setCurrentValue( rv );
        return rv;
    }

    private void setSelected( RadioButtonProxy pRadioButtonProxy )
    {
        setInitialSelection( pRadioButtonProxy );
        setLastSelected( pRadioButtonProxy );
        /*
         * Work around for IE bug where you can select multiple radio buttons
         * when not attached (part 1)
         */
        if ( isAttached() )
        {
            pRadioButtonProxy.setChecked();
        }
    }

    @Override
    protected void onLoad()
    {
        super.onLoad();
        /*
         * Work around for IE bug where you can select multiple radio buttons
         * when not attached (part 2)
         */
        if ( mLastSelection != null )
        {
            mLastSelection.setChecked();
        }
    }

    private FocusSelection determineFocusSelection()
    {
        boolean anyFocus = false;
        RadioButtonProxy selected = null;
        for ( int i = 0; i < mRadioButtons.size(); i++ )
        {
            RadioButtonProxy radioButtonProxy = getRadioButon( i );
            if ( radioButtonProxy.isChecked() )
            {
                selected = radioButtonProxy;
            }
            anyFocus |= radioButtonProxy.hasFocus();
        }
        return new FocusSelection( anyFocus, selected );
    }

    private static class FocusSelection
    {
        private boolean mFocused;
        private RadioButtonProxy mSelected;

        public FocusSelection( boolean pFocused, RadioButtonProxy pSelected )
        {
            mFocused = pFocused;
            mSelected = pSelected;
        }

        public boolean isFocused()
        {
            return mFocused;
        }

        public RadioButtonProxy getSelected()
        {
            return mSelected;
        }
    }

    public void publishAnyDelayedChanges()
    {
        if ( mPendingReentries++ != 0 )
        {
            return;
        }
        do
        {
            FocusSelection zFS = determineFocusSelection();
            boolean shouldIssueBlur = false;
            if ( zFS.isFocused() != mReportedFocus )
            {
                if ( zFS.isFocused() )
                {
                    mReportedFocus = true;
                    fireFocusListeners();
                }
                else
                {
                    shouldIssueBlur = true;
                }
            }
            RadioButtonProxy prevLastSelection = mLastSelection;
            if ( zFS.getSelected() != null )
            {
                setLastSelected( zFS.getSelected() );
            }
            RadioButtonProxy curLastSelection = mLastSelection;
            if ( prevLastSelection != curLastSelection )
            {
                fireChangeListeners();
            }
            if ( shouldIssueBlur )
            {
                mReportedFocus = false;
                fireBlurListeners();
            }
        }
        while ( --mPendingReentries > 0 );
    }

    private int mPendingReentries = 0;
    private boolean mReportedFocus = false;
    private RadioButtonProxy mInitialSelection = null;
    private RadioButtonProxy mLastSelection = null;

    private void setInitialSelection( RadioButtonProxy pInitialSelection )
    {
        RadioButtonProxy prev = mInitialSelection;
        switchChangeFromTo( prev, mInitialSelection = pInitialSelection );
    }

    private RadioButtonProxy setLastSelected( RadioButtonProxy pSelected )
    {
        return mLastSelection = switchChangeFromTo( mLastSelection, pSelected );
    }

    private RadioButtonProxy switchChangeFromTo( RadioButtonProxy pPrev, RadioButtonProxy pNew )
    {
        if ( pPrev != pNew )
        {
            if ( pPrev != null )
            {
                pPrev.removeChangeIndicator();
            }
            if ( pNew != null )
            {
                if ( pNew != mInitialSelection )
                {
                    mInitialSelection.addChangeIndicator();
                    pNew.addChangeIndicator();
                }
                else
                {
                    mInitialSelection.removeChangeIndicator();
                    pNew.removeChangeIndicator();
                }
            }
        }
        return pNew;
    }

    //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

    private DelayedStateChecker mDelayedStateChecker = null;

    private class DelayedStateChecker implements Command
    {
        private int mPendingDelays = 0;

        public Command getCommandToDefer()
        {
            mPendingDelays++;
            return this;
        }

        @Override
        public void execute()
        {
            if ( --mPendingDelays == 0 )
            {
                publishAnyDelayedChanges();
            }
        }
    }

    private static class RadioButtonProxy extends Composite implements Focusable,
                                                                       FocusHandler,
                                                                       BlurHandler,
                                                                       ClickHandler
    {
        private SimpleKeyValuePair mKeyValuePair;
        private ChangeHandler mChangeHandler;
        private RadioButton mRadioButton;
        private boolean mHasFocus = false;
        private boolean mChangeIndicated = false;

        public RadioButtonProxy( String pRadioGroupName, SimpleKeyValuePair pKeyValuePair, ChangeHandler pChangeHandler )
        {
            mKeyValuePair = pKeyValuePair;
            mChangeHandler = pChangeHandler;
            String zLabel = HTMLize.escapeNoWrap( pKeyValuePair.toStringValue() );
            mRadioButton = new RadioButton( pRadioGroupName, zLabel, true );
            //noinspection GWTStyleCheck
            mRadioButton.setStyleName( "frmRadioBtn" );

            initWidget( buildComponentPanel() );

            mRadioButton.addFocusHandler( this );
            mRadioButton.addBlurHandler( this );
            mRadioButton.addClickHandler( this );

//            setStyleName( BASE_STYLE_NAME );
        }

        private HTMLPanel buildComponentPanel()
        {
            String inputId = "input" + StaticSimpleIdSource.getNext();
            String html = "<nowrap><table cellpadding='0' cellspacing='0'><tr><td id='" + inputId + "'></td></tr></table></nowrap>";

            HTMLPanel panel = new HTMLPanel( html );
            panel.add( mRadioButton, inputId );
            return panel;
        }

        @Override
        public int getTabIndex()
        {
            return mRadioButton.getTabIndex();
        }

        @Override
        public void setTabIndex( int index )
        {
            mRadioButton.setTabIndex( index );
        }

        @Override
        public void setAccessKey( char key )
        {
            mRadioButton.setAccessKey( key );
        }

        @Override
        public void setFocus( boolean pFocus )
        {
            mRadioButton.setFocus( pFocus );
        }

        @Override
        public void onFocus( FocusEvent event )
        {
            // System.out.println( "RadioButtonProxy.onFocus: " + mKeyValuePair );
            mHasFocus = true;
            mChangeHandler.onChange( null );
        }

        @Override
        public void onBlur( BlurEvent event )
        {
            // System.out.println( "RadioButtonProxy.onLostFocus: " + mKeyValuePair );
            mHasFocus = false;
            mChangeHandler.onChange( null );
        }

        @Override
        public void onClick( ClickEvent event )
        {
            // System.out.println( "RadioButtonProxy.onClick: " + mKeyValuePair );
            mChangeHandler.onChange( null );
        }

        public SimpleKeyValuePair getKeyValuePair()
        {
            return mKeyValuePair;
        }

        public void setChecked()
        {
            mRadioButton.setValue( true );
        }

        public void setEnabled( boolean pEnabled )
        {
            mRadioButton.setEnabled( pEnabled );
        }

        public boolean isChecked()
        {
            return mRadioButton.getValue();
        }

        public boolean hasFocus()
        {
            return mHasFocus;
        }

        public void addChangeIndicator()
        {
            if ( !mChangeIndicated )
            {
                mChangeIndicated = true;
                //noinspection GWTStyleCheck
                mRadioButton.addStyleName( "frmRadioBtn-Changed" );
            }
        }

        public void removeChangeIndicator()
        {
            if ( mChangeIndicated )
            {
                mChangeIndicated = false;
                //noinspection GWTStyleCheck
                mRadioButton.removeStyleName( "frmRadioBtn-Changed" );
            }
        }

        @Override
        public String toString()
        {
            return "RadioButtonProxy: " + mKeyValuePair.toStringValue();
        }
    }

    private static class InfoIndicator extends Widget
    {
        private Element iconImg = DOM.createImg();
        private boolean mCanShow = false;

        public InfoIndicator()
        {
            Element span = DOM.createSpan();
//            DOM.setElementProperty( span, "className", "litesoft-FormComponentIndicatorContainer" );
            setElement( span );

            CommonElementHelper.setImgSrc( iconImg, TransparentImage.URL );
            CommonElementHelper.setStyleClass( iconImg, "litesoft-FormComponentIndicator" );
            DOM.appendChild( span, iconImg );

            setVisible( false );
        }

        public void setTooltip( String pTooltip )
        {
            mCanShow = (pTooltip.length() != 0);
            DOM.setElementProperty( iconImg, "title", pTooltip );
        }

        @Override
        public void setVisible( boolean pVisible )
        {
            getElement().getStyle().setDisplay( (mCanShow && pVisible) ? Style.Display.INLINE : Style.Display.NONE );
        }
    }

    private static SimpleKeyValuePair[] convertToKeyValuePairs( String[] pOptions )
    {
        if ( pOptions == null )
        {
            return SimpleKeyValuePair.EMPTY_ARRAY;
        }
        SimpleKeyValuePair[] rv = new SimpleKeyValuePair[pOptions.length];
        for ( int i = 0; i < pOptions.length; i++ )
        {
            rv[i] = convertToKeyValuePair( pOptions[i] );
        }
        return rv;
    }

    private static SimpleKeyValuePair convertToKeyValuePair( String pOption )
    {
        return (pOption != null) ? new StringKeyValuePair( pOption, pOption ) : null;
    }
}