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

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.commonfoundation.charstreams.*;
import org.litesoft.commonfoundation.html.*;
import org.litesoft.uispecification.*;

import com.google.gwt.core.client.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

public class FormTextarea extends AbstractTextElement
{
    private DeckPanel mDeck;
    private DisabledTextArea mDisabledTextArea;

    public FormTextarea( String pFieldLabel, UiFont pLabelFont, String pTooltip, boolean pNoWrapContents, //
                         Integer pInitialWidth, boolean pWidthNotStretchable, //
                         Integer pInitialLines, boolean pHeightNotStretchable )
    {
        super( new TextAreaChangeListenable( pInitialWidth, pInitialLines, pNoWrapContents ), pTooltip, "frmTxtArea" );
        mWidthHelper = pWidthNotStretchable ? NullWidthHelper.INSTANCE : new StretchableWidthHelper( this );
        mHeightHelper = pHeightNotStretchable ? NullHeightHelper.INSTANCE : new StretchableHeightHelper( this );

        mDisabledTextArea = new DisabledTextArea( pNoWrapContents );

        mDeck = new MyDeckPanel( new SizingWrapper( mInputWidget, mInputWidget ), //
                                 new SizingWrapper( mDisabledTextArea, mDisabledTextArea.getSizeablePanel() ) );

        initialize( pFieldLabel, pLabelFont, pTooltip );
    }

    @Override
    protected String buildInputRow( String pTrId, String pInputId, int pUniqueID )
    {
        return "<tr>" + //
               "<td id='" + pInputId + "' class='litesoft-FormComponentInputRow'></td>" + //
               "<td valign='top'>" + //
               "<table cellpadding='0' cellspacing='0'>" + "<tr><td style='font-size:1px;'>&nbsp;</td></tr><tr id='" + pTrId + "' class='litesoft-FormComponentInputRow'></tr>" + //
               "</table>" + //
               "</td>" +//
               "</tr>";
    }

    @Override
    protected Widget getInjectedInputWidget()
    {
        return mDeck;
    }

    @Override
    public void setEnabled( boolean pEnabled )
    {
        super.setEnabled( pEnabled );
        if ( pEnabled )
        {
            enableTextArea();
        }
        else
        {
            disableTextArea();
        }
    }

    public void disableTextArea()
    {
        copyValueToDisabledTextArea();
        mDeck.showWidget( 1 );
    }

    public void enableTextArea()
    {
        mDeck.showWidget( 0 );
    }

    public String getValue()
    {
        return ((TextArea) mInputWidget).getText();
    }

    @Override
    public void setCurrentText( String pNewText )
    {
        super.setCurrentText( pNewText );
        if ( !isEnabled() )
        {
            copyValueToDisabledTextArea();
        }
    }

    // Support...

    private void copyValueToDisabledTextArea()
    {
        String value = getValue();
        mDisabledTextArea.setText( convertDisplayText( value ) );
    }

    private String convertDisplayText( String pInput )
    {
        StringBuilder sb = new StringBuilder();

        CharSource zCS = new CharSourceFromSequence( pInput );
        while ( zCS.anyRemaining() )
        {
            int c = zCS.get();
            if ( c == '\r' )
            {
                if ( '\n' == zCS.peek() )
                {
                    continue;
                }
                sb.append( "<br>" );
            }
            else if ( (c == ' ') && (' ' == zCS.peek()) )
            {
                sb.append( HTMLConstants.NBSP );
            }
            else if ( c == '\n' )
            {
                sb.append( "<br>" );
            }
            else if ( c == '<' )
            {
                sb.append( "&lt;" );
            }
            else
            {
                sb.append( (char) c );
            }
        }

        sb.append( HTMLConstants.NBSP );
        return sb.toString();
    }

    private static class StretchableHeightHelper extends AbstractHeightHelper
    {
        private FormTextarea mOurWidget;
        private Integer mInputDecorationSize = null;

        public StretchableHeightHelper( FormTextarea pOurWidget )
        {
            super( true );
            mOurWidget = pOurWidget;
        }

        @Override
        public void setDimension( int pDimension )
        {
            setDimension( mOurWidget, pDimension );
        }

        @Override
        public int getDimension()
        {
            return getDimension( mOurWidget );
        }

        @Override
        public int getDimensionMaxShrinkability()
        {
            return getDimension( mOurWidget.getInjectedInputWidget() ) - 6;
        }

        @Override
        public int getDecorationSize()
        {
            return getDimension() - getDimension( mOurWidget.mDeck );
        }

        @Override
        public void deligateSetDimensionFromWidget( int pDimension )
        {
            Label label = mOurWidget.mLabel;
            if ( label != null )
            {
                pDimension -= getDimension( label );
            }
            pDimension -= getInputDecorationSize();
            pDimension -= getOuterSandwichDecorationSize();
            if ( pDimension > 6 )
            {
                setDimension( mOurWidget.getInjectedInputWidget(), pDimension );
            }
        }

        private int getInputDecorationSize()
        {
            if ( mInputDecorationSize == null )
            {
                if ( !mOurWidget.isAttached() )
                {
                    return 9999;
                }
                mInputDecorationSize = getDimension( getGrandParent( mOurWidget.getInjectedInputWidget() ) ) - //
                                       getDimension( mOurWidget.getInjectedInputWidget() );
            }
            return mInputDecorationSize;
        }

        private Integer mOuterSandwichDecorationSize = null;

        private int getOuterSandwichDecorationSize()
        {
            if ( mOuterSandwichDecorationSize == null )
            {
                if ( !mOurWidget.isAttached() )
                {
                    return 9999;
                }
                Element zDivOrFS = mOurWidget.mInnerHTMLpanel.getElement();
                int children = DOM.getChildCount( zDivOrFS );
                Element zInnerBread = DOM.getChild( zDivOrFS, children - 1 );
                mOuterSandwichDecorationSize = getDimension( mOurWidget ) - getDimension( zInnerBread );
            }
            return mOuterSandwichDecorationSize;
        }

        private Element getGrandParent( Widget pWidget )
        {
            return getGrandParent( pWidget.getElement() );
        }

        private Element getGrandParent( Element pElement )
        {
            return getParent( getParent( pElement ) );
        }

        private Element getParent( Element pElement )
        {
            return DOM.getParent( pElement );
        }
    }

    private static class MyDeckPanel extends DeckPanel
    {
        private SizingWrapper mWidget0, mWidget1;

        public MyDeckPanel( SizingWrapper pWidget0, SizingWrapper pWidget1 )
        {
            add( mWidget0 = pWidget0 );
            add( mWidget1 = pWidget1 );
            showWidget( 0 );
        }

        @Override
        public void showWidget( int index )
        {
            super.showWidget( index );
            mWidget0.shown( 0 == index );
            mWidget1.shown( 1 == index );
        }

        @Override
        public void setWidth( String width )
        {
            mWidget0.setWidth( width );
            mWidget1.setWidth( width );
        }

        @Override
        public void setHeight( String height )
        {
            mWidget0.setHeight( height );
            mWidget1.setHeight( height );
        }

// matg: commented out for GWT 1.5. Have to call super or DeckPanel breaks
//        public void add( Widget w )
//        {
//            add( w, getElement() );
//            w.setVisible( false );
//        }

        @Override
        public void insert( Widget w, int beforeIndex )
        {
            throw new IllegalStateException( "Only use add( w )" );
        }
    }

    private static class SizingWrapper extends HorizontalPanel
    {
        private SizeHelper mHeightHelper, mWidthHelper;

        public SizingWrapper( Widget pChild, Widget pSizingWidget )
        {
            add( pChild );
            mHeightHelper = new HeightHelper( this, pSizingWidget );
            mWidthHelper = new WidthHelper( this, pSizingWidget );
        }

        public void shown( boolean pShown )
        {
            mHeightHelper.shown( pShown );
            mWidthHelper.shown( pShown );
        }

        @Override
        public void setWidth( String width )
        {
            mWidthHelper.setSize( width );
        }

        @Override
        public void setHeight( String height )
        {
            mHeightHelper.setSize( height );
        }

        private static abstract class SizeHelper implements Command
        {
            private SizingWrapper mWrapper;
            private Widget mSizingWidget;
            private Integer mPendingSize = null;
            private Integer mOverheadSize = null;

            protected SizeHelper( SizingWrapper pWrapper, Widget pSizingWidget )
            {
                mWrapper = pWrapper;
                mSizingWidget = pSizingWidget;
            }

            abstract protected int getSize( Widget pWidget );

            abstract protected void setSize( Widget pWidget, int pSize );

            public void setSize( String pSize )
            {
                try
                {
                    mPendingSize = AbstractSizeableWidget.parse( pSize );
                }
                catch ( NumberFormatException e )
                {
                    return;
                }
                applySize();
            }

            public void shown( boolean pShown )
            {
                if ( pShown )
                {
                    applySize();
                }
            }

            private boolean mDeferred = false;

            private void applySize()
            {
                if ( mOverheadSize == null )
                {
                    if ( shouldDefer() )
                    {
                        if ( !mDeferred )
                        {
                            mDeferred = true;
                            Scheduler.get().scheduleDeferred( this );
                        }
                        return;
                    }
                    int zWrapperSize = getSize( mWrapper );
                    int zSizingSize = getSize( mSizingWidget );
//                    System.out.println( this + ".applySize: " + zWrapperSize + "|" + zSizingSize );
                    mOverheadSize = zWrapperSize - zSizingSize;
                }
                if ( mPendingSize != null )
                {
                    setSize( mSizingWidget, mPendingSize - mOverheadSize );
                }
            }

            private boolean shouldDefer()
            {
                boolean zAttached = mWrapper.isAttached();
                boolean zVisible = mWrapper.isVisible();
                int zSize = getSize( mWrapper );
                return !zAttached || !zVisible || (zSize < 20);
            }

            @Override
            public void execute()
            {
                mDeferred = false;
                applySize();
            }
        }

        private static class HeightHelper extends SizeHelper
        {
            public HeightHelper( SizingWrapper pWrapper, Widget pSizingWidget )
            {
                super( pWrapper, pSizingWidget );
            }

            @Override
            protected int getSize( Widget pWidget )
            {
                return pWidget.getOffsetHeight();
            }

            @Override
            protected void setSize( Widget pWidget, int pSize )
            {
                pWidget.setHeight( "" + pSize );
            }
        }

        private static class WidthHelper extends SizeHelper
        {
            public WidthHelper( SizingWrapper pWrapper, Widget pSizingWidget )
            {
                super( pWrapper, pSizingWidget );
            }

            @Override
            protected int getSize( Widget pWidget )
            {
                return pWidget.getOffsetWidth();
            }

            @Override
            protected void setSize( Widget pWidget, int pSize )
            {
                pWidget.setWidth( "" + pSize );
            }
        }
    }

    private static class DisabledTextArea extends SimplePanel
    {
        private InnerText mInnerTextAsHtml;
        private Widget mSizeablePanel;

        public DisabledTextArea( boolean pNoWrapContents )
        {
            //noinspection GWTStyleCheck
            addStyleName( "litesoft-OuterDisabledTextArea" );

            SimplePanel innerPanel = new SimplePanel();
            //noinspection GWTStyleCheck
            innerPanel.addStyleName( "litesoft-InnerDisabledTextArea" );
            add( innerPanel );

            mInnerTextAsHtml = new InnerText();

            if ( pNoWrapContents )
            {
                SimplePanel zSimplePanel = new SimplePanel();
                CommonElementHelper.setOverflowAuto( zSimplePanel.getElement() );
                CommonElementHelper.setWhiteSpaceWrap( mInnerTextAsHtml.getElement(), false );
                zSimplePanel.add( mInnerTextAsHtml );

                mSizeablePanel = zSimplePanel;
            }
            else
            {
                CommonElementHelper.setOverflowAuto( mInnerTextAsHtml.getElement() );

                mSizeablePanel = mInnerTextAsHtml;
            }
            innerPanel.add( mSizeablePanel );
            mSizeablePanel.setSize( "50", "50" );
        }

        public Widget getSizeablePanel()
        {
            return mSizeablePanel;
        }

        public void setText( String pText )
        {
            if ( pText != null )
            {
                mInnerTextAsHtml.setText( pText );
            }
        }

        public void setInnerHtml( String pText )
        {
            if ( pText != null )
            {
                DOM.setInnerHTML( mInnerTextAsHtml.getElement(), pText );
            }
        }

        @Override
        public void setWidth( String pWidth )
        {
            mSizeablePanel.setWidth( pWidth );
        }

        @Override
        public void setHeight( String pHeight )
        {
            mSizeablePanel.setHeight( pHeight );
        }
    }

    private static class InnerText extends Widget
    {
        public InnerText()
        {
            setElement( DOM.createDiv() );
            //noinspection GWTStyleCheck
            setStyleName( "litesoft-DisabledTextareaInnerText" );
        }

        public InnerText( String pText )
        {
            this();
            setText( pText );
        }

        public void setText( String pText )
        {
            DOM.setInnerHTML( getElement(), pText );
        }
    }
}