package org.litesoft.GWT.forms.client.components.nonpublic;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;

public class FormContainerErrorPanel extends AbstractSizeableOneDimensionalPanel
{
    private static final String CLASS_POP_UP_PANEL_ERROR = "litesoft-FormPopUpPanel_error";
    private static final String CLASS_POP_UP_PANEL_WARNING = "litesoft-FormPopUpPanel_warning";

    protected MessagePopUpPanel mMessagePopUpPanel = new MessagePopUpPanel();

    public FormContainerErrorPanel()
    {
        initializeElements( getHelper().create_OeTable_SeDiv_IeDiv( true ), null );
        DOM.setStyleAttribute( getHelper().getStyleElement(), "overflow", "visible" );
        LLstretchableHorizontally();
        add( mMessagePopUpPanel );
        add( mMessagePopUpPanel.getIndicatorBar() );
    }

    public void setError( String pError )
    {
        mMessagePopUpPanel.setError( pError );
    }

    public void setWarning( String pWarning )
    {
        mMessagePopUpPanel.setWarning( pWarning );
    }

    public void clearErrorOrWarning()
    {
        mMessagePopUpPanel.clearErrorOrWarning();
    }

    protected void LLdisown( Widget pWidget, int pIndex )
    {
        abstractSizeablePanel_disown( pWidget );
        getChildren().remove( pIndex );
    }

    protected void LLadopt( Widget pWidget, int pBeforeIndex )
    {
        pWidget.removeFromParent();
        abstractSizeablePanel_adopt( pWidget, getContainerElement() );
        getChildren().insert( pWidget, pBeforeIndex );
    }

    protected Element unwrap( Element pTD )
    {
        throw new UnsupportedOperationException( "unwrap?" );
    }

    protected Element wrap( Element pTD )
    {
        throw new UnsupportedOperationException( "wrap?" );
    }

    public void setHeight( String height )
    {
        mMessagePopUpPanel.reposition();
        // Do NOT pass thru!
    }

    public void setWidth( String width )
    {
        if ( (mMinimumWidth == null) && anyChildren() )
        {
            Element elem = DOM.getParent( getContainerElement() );
            int currentWidth = DOM.getElementPropertyInt( elem, "offsetWidth" );
            if ( currentWidth > 0 )
            {
                getHelper().setDimensionOnChildren( this, getWidthHelper(), currentWidth );
                mMinimumWidth = new Integer( currentWidth );
            }
        }
        DOM.setStyleAttribute( getHelper().getStyleElement(), "overflow", "hidden" );
        super.setWidth( width );
        DOM.setStyleAttribute( getHelper().getStyleElement(), "overflow", "visible" );
    }

    private Integer mMinimumWidth = null;

    protected void distributeToChildrenChangedWidth()
    {
        if ( anyChildren() )
        {
            getHelper().applyChangedDimensionToChildren( this, getWidthHelper() );
        }
    }

    public static class MessagePopUpPanel extends SizeableSimplePanel
    {
        private static final String STYLE_NONE = "_None";
        private static final String STYLE_ERROR = "Error";
        private static final String STYLE_WARNING = "Warning";

        private String mCurStyle = STYLE_NONE;
        private String mCurText = "";

        private MessageIndicatorBar mIndicatorBar = new MessageIndicatorBar();
        protected Label mErrorPopUpLabel = new Label( "", true );
        private boolean mMsgShown = false;

        public MessagePopUpPanel()
        {
            super( true, "litesoft-FormPopUpPanel" );
            stretchableHorizontally();
            setWidget( mErrorPopUpLabel );
            Element tableElement = getElement();
            DOM.setStyleAttribute( tableElement, "position", "absolute" );
            hide();
            mIndicatorBar.addClickListener( new ClickListener()
            {
                public void onClick( Widget sender )
                {
                    mIndicatorBar.updateArrowDisplay();
                    toggleDisplay();
                }
            } );
        }

        private void toggleDisplay()
        {
            if ( !mMsgShown )
            {
                show();
            }
            else
            {
                hide();
            }
        }

        public boolean isErrorStyle( String pError )
        {
            return mCurStyle.equals( STYLE_ERROR ) && mCurText.equals( pError );
        }

        public void setError( String pError )
        {
            if ( pError != null && !isErrorStyle( pError ) )
            {
                mCurStyle = STYLE_ERROR;
                boolean zSavedMsgShown = mMsgShown;
                hide();
                setErrorStyle();
                mErrorPopUpLabel.setText( mCurText = pError );
                mIndicatorBar.setErrorStyle( pError );
                if ( zSavedMsgShown )
                {
                    show();
                }
            }
        }

        public boolean isWarningStyle( String pWarning )
        {
            return mCurStyle.equals( STYLE_WARNING ) && mCurText.equals( pWarning );
        }

        public void setWarning( String pWarning )
        {
            if ( pWarning != null && !isWarningStyle( pWarning ) )
            {
                mCurStyle = STYLE_WARNING;
                boolean zSavedMsgShown = mMsgShown;
                hide();
                setWarningStyle();
                mErrorPopUpLabel.setText( mCurText = pWarning );
                mIndicatorBar.setWarningStyle( pWarning );
                if ( zSavedMsgShown )
                {
                    show();
                }
            }
        }

        public void clearErrorOrWarning()
        {
            mCurStyle = STYLE_NONE;
            hide();
            mIndicatorBar.hide();
            DOM.setElementAttribute( mIndicatorBar.getElement(), "title", "" );
            mIndicatorBar.setDefaultArrowDisplay();
            mErrorPopUpLabel.setText( "" );
            mMsgShown = false;
        }

        public MessageIndicatorBar getIndicatorBar()
        {
            return mIndicatorBar;
        }

        public void reposition()
        {
            if ( mMsgShown )
            {
                hide();
                show();
            }
        }

        public void hide()
        {
            CommonElementHelper.hide( getElement() );
            mMsgShown = false;
        }

        public void show()
        {
            position();

            CommonElementHelper.unhide( getElement() );
            mMsgShown = true;
        }

        protected void position()
        {
            int zOffsetToBottom = mIndicatorBar.getOffsetHeight();

            DOM.setStyleAttribute( getElement(), "bottom", "" + zOffsetToBottom );
        }

        public void setWarningStyle()
        {
            removeStyleName( CLASS_POP_UP_PANEL_ERROR );
            addStyleName( CLASS_POP_UP_PANEL_WARNING );
        }

        public void setErrorStyle()
        {
            removeStyleName( CLASS_POP_UP_PANEL_WARNING );
            addStyleName( CLASS_POP_UP_PANEL_ERROR );
        }
    }

    public static class MessageIndicatorBar extends SizeableHorizontalPanel
    {
        private static final String CLASS_ERROR_BAR = "litesoft-FormErrorBar";
        private static final String CLASS_ERROR_BAR_REGULAR = "litesoft-FormErrorBar_regular";
        private static final String CLASS_ERROR_BAR_MOUSEOVER = "litesoft-FormErrorBar_mouseover";

        private static final String CLASS_WARNING_BAR = "litesoft-FormWarningBar";
        private static final String CLASS_WARNING_BAR_REGULAR = "litesoft-FormWarningBar_regular";
        private static final String CLASS_WARNING_BAR_MOUSEOVER = "litesoft-FormWarningBar_mouseover";

        private static final String CLASS_BUTTON_BG = "litesoft-FormMsgBarButtonBg";

        private static final String ARROW_UP = "common/images/formcomponents/uparrow_wht.cache.gif";
        private static final String ARROW_DOWN = "common/images/formcomponents/downarrow_wht.cache.gif";

        private boolean mArrowUp = true;
        private Image mArrowWidget = new Image( ARROW_UP ); // CLASS_BUTTON_BG

        public MessageIndicatorBar()
        {
            super( true, CLASS_ERROR_BAR );

            addStyleName( CLASS_ERROR_BAR_REGULAR );

            sinkEvents( Event.MOUSEEVENTS );
            stretchableHorizontally();

            add( new SizeableSpacer().stretchableHorizontally() );
            add( mArrowWidget );
            add( new SizeableSpacer().stretchableHorizontally() );

            Element zArrowTD = DOM.getParent( mArrowWidget.getElement() );
            CommonElementHelper.setStyleClass( zArrowTD, CLASS_BUTTON_BG );
            hide();
        }

        public void setVisible( boolean visible )
        {
            throw new IllegalStateException( "Not Supported" );
        }

        public void show()
        {
            CommonElementHelper.unhide( getElement() );
        }

        public void hide()
        {
            CommonElementHelper.hide( getElement() );
        }

        public void setErrorStyle( String pError )
        {
            DOM.setElementAttribute( getElement(), "title", pError );
            removeStyleName( CLASS_WARNING_BAR );
            removeStyleName( CLASS_WARNING_BAR_REGULAR );
            addStyleName( CLASS_ERROR_BAR );
            addStyleName( CLASS_ERROR_BAR_REGULAR );

            show();
        }

        public void setWarningStyle( String pWarning )
        {
            DOM.setElementAttribute( getElement(), "title", pWarning );
            removeStyleName( CLASS_ERROR_BAR );
            removeStyleName( CLASS_ERROR_BAR_REGULAR );
            addStyleName( CLASS_WARNING_BAR );
            addStyleName( CLASS_WARNING_BAR_REGULAR );

//            mArrowWidget.setStyleName( CLASS_BUTTON_BG_WARNING );

            show();
        }

        public void updateArrowDisplay()
        {
            mArrowWidget.setUrl( (mArrowUp = !mArrowUp) ? ARROW_UP : ARROW_DOWN );
        }

        public void setDefaultArrowDisplay()
        {
            if ( !mArrowUp )
            {
                updateArrowDisplay();
            }
        }

        private void setMouseoverStyle()
        {
            String styleClasses = getStyleName();

            if ( styleClasses.indexOf( CLASS_ERROR_BAR ) > 0 )
            {
                removeStyleName( CLASS_ERROR_BAR_REGULAR );
                addStyleName( CLASS_ERROR_BAR_MOUSEOVER );
            }

            if ( styleClasses.indexOf( CLASS_WARNING_BAR ) > 0 )
            {
                removeStyleName( CLASS_WARNING_BAR_REGULAR );
                addStyleName( CLASS_WARNING_BAR_MOUSEOVER );
            }
        }

        private void setMouseoutStyle()
        {
            String styleClasses = getStyleName();

            if ( styleClasses.indexOf( CLASS_ERROR_BAR ) > 0 )
            {
                removeStyleName( CLASS_ERROR_BAR_MOUSEOVER );
                addStyleName( CLASS_ERROR_BAR_REGULAR );
            }

            if ( styleClasses.indexOf( CLASS_WARNING_BAR ) > 0 )
            {
                removeStyleName( CLASS_WARNING_BAR_MOUSEOVER );
                addStyleName( CLASS_WARNING_BAR_REGULAR );
            }
        }

        public void addClickListener( ClickListener pListener )
        {
            if ( pListener != null )
            {
                if ( mClickListeners == null )
                {
                    mClickListeners = new ClickListenerCollection();
                }
                //noinspection unchecked
                mClickListeners.add( pListener );
            }
        }

        private ClickListenerCollection mClickListeners = null;

        public void onBrowserEvent( Event event )
        {
            switch ( DOM.eventGetType( event ) )
            {
                case Event.ONMOUSEDOWN:
                {
                    if ( mClickListeners != null )
                    {
                        mClickListeners.fireClick( this );
                    }
                    break;
                }
                case Event.ONMOUSEOVER:
                    setMouseoverStyle();
                    break;
                case Event.ONMOUSEOUT:
                    setMouseoutStyle();
                    break;
            }
        }
    }
}