package org.litesoft.GWT.client.widgets;

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

public class SizeableSelectorPanel extends SizeableHorizontalSplitPairPanel implements ISizeableTabPanel
{
    private SizeableVerticalPanel mSelectorPanel = new SizeableVerticalPanel( true ).stretchable();
    private SizeableSpacer mSelectorRest = new SizeableSpacer().width( 80 ).stretchable();
    protected SizeableDeckPanel mDeckPanel = new SizeableDeckPanel().stretchable();
    private static final String STYLE_TAB_SELECTED = "litesoft-VerticalTab-Selected";
    private static final String STYLE_TAB_UNSELECTED = "litesoft-VerticalTab-Unselected";
    private static final String STYLE_TAB_ERROR = "litesoft-VerticalTab-Error";
    private static final String STYLE_TAB_NON_ERROR = "litesoft-VerticalTab-NonError";
    private boolean mErrorable;

    public SizeableSelectorPanel()
    {
        this( false );
    }

    public SizeableSelectorPanel( boolean pErrorable )
    {
        mErrorable = pErrorable;
        stretchable();
        addStyleName( "litesoft-SizeableSelectorPanel" );

        mSelectorPanel.addStyleName( "litesoft-SelectorPanel" );
        mSelectorRest.addStyleName( "litesoft-VerticalTabRest" );
        mDeckPanel.addStyleName( "litesoft-DeckPanel" );

        mSelectorPanel.add( mSelectorRest );
        add( mSelectorPanel );
        add( mDeckPanel );
    }

    public void insertTab( int pBeforeIndex, String pLabelText, final Widget pWidget )
    {
        insertTab( pBeforeIndex, pLabelText, false, pWidget );
    }

    public void insertTab( int pBeforeIndex, String pLabelText, boolean pAsHTML, final Widget pWidget )
    {
        VerticalTabLabel tabLabel = new VerticalTabLabel( pLabelText, mErrorable );

        boolean zFirstTab = (mDeckPanel.getWidgetCount() == 0);

        tabLabel.addStyleName( zFirstTab ? STYLE_TAB_SELECTED : STYLE_TAB_UNSELECTED );

        tabLabel.addStyleName( STYLE_TAB_NON_ERROR );

        tabLabel.addClickListener( new ClickListener()
        {
            public void onClick( Widget sender )
            {
                selectTab( mDeckPanel.getWidgetIndex( pWidget ) );
            }
        } );

        LLinsertTab( pBeforeIndex, tabLabel, pWidget );
    }

    public void removeTab( int pIndex )
    {
        System.out.println( "Selector removeTab: " + pIndex );
        if ( Helper.indexOK( pIndex, this ) )
        {
            int zSelectedTab = getSelectedTab();
            if ( (getTabCount() > 1) && (zSelectedTab == pIndex) )
            {
                selectTab( (pIndex == 0) ? 1 : pIndex - 1 );
            }
            if ( !mSelectorPanel.remove( pIndex ) )
            {
                System.out.println( "*** Unable to remove Selector: " + pIndex );
            }
            if ( !mDeckPanel.remove( pIndex ) )
            {
                System.out.println( "*** Unable to remove Deck: " + pIndex );
            }
            mSelectorPanel.getHeightHelper().contentChangedResizeToParent();
        }
    }

    public void addTab( String pLabelText, Widget pWidget )
    {
        insertTab( getTabCount(), pLabelText, pWidget );
    }

    public void addTab( String pLabelText, boolean pAsHTML, Widget pWidget )
    {
        insertTab( getTabCount(), pLabelText, pAsHTML, pWidget );
    }

    public int getTabCount()
    {
        return mDeckPanel.getWidgetCount();
    }

    public int getSelectedTab()
    {
        return mDeckPanel.getVisibleWidget();
    }

    public void selectTab( int pIndex )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            Widget widget = mSelectorPanel.getWidget( getSelectedTab() );
            widget.removeStyleName( STYLE_TAB_SELECTED );
            widget.addStyleName( STYLE_TAB_UNSELECTED );
            mDeckPanel.showWidget( pIndex );
            widget = mSelectorPanel.getWidget( pIndex );
            widget.removeStyleName( STYLE_TAB_UNSELECTED );
            widget.addStyleName( STYLE_TAB_SELECTED );
        }
    }

    public void setError( int pIndex, boolean pError )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            Widget widget = mSelectorPanel.getWidget( pIndex );
            if ( pError )
            {
                widget.removeStyleName( STYLE_TAB_NON_ERROR );
                widget.addStyleName( STYLE_TAB_ERROR );
            }
            else
            {
                widget.removeStyleName( STYLE_TAB_ERROR );
                widget.addStyleName( STYLE_TAB_NON_ERROR );
            }
        }
    }

    public void setTabText( int pIndex, String pLabelText )
    {
        setTabText( pIndex, pLabelText, false );
    }

    public void setTabText( int pIndex, String pLabelText, boolean pAsHTML )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            VerticalTabLabel tabLabel = (VerticalTabLabel) mSelectorPanel.getWidget( pIndex );
            tabLabel.setText( pLabelText, pAsHTML );
            tabLabel.setWidth( "" + mSelectorRest.getOffsetWidth() );
        }
    }

    public int indexOfTabBodyWith( Widget pWidget )
    {
        return mDeckPanel.getWidgetIndex( pWidget );
    }

    public void moveTab( int pFromIndex, int pToBeforeIndex )
    {
        if ( Helper.indexOK( pFromIndex, this ) )
        {
            pToBeforeIndex = Helper.normalizeBeforeIndex( pToBeforeIndex, this );
            if ( pToBeforeIndex != pFromIndex )
            {
                VerticalTabLabel zLabel = (VerticalTabLabel) mSelectorPanel.getWidget( pFromIndex );
                Widget zBody = mDeckPanel.getWidget( pFromIndex );
                boolean zCurrentlySelected = (pFromIndex == mDeckPanel.getVisibleWidget());
                mSelectorPanel.insert( zLabel, pToBeforeIndex );
                mDeckPanel.insert( zBody, pToBeforeIndex );
                if ( zCurrentlySelected )
                {
                    mDeckPanel.showWidget( mDeckPanel.getWidgetIndex( zBody ) );
                }
            }
        }
    }

    private void LLinsertTab( int pBeforeIndex, VerticalTabLabel pTabLabel, Widget pWidget )
    {
        boolean zCurrentlySelected = false;
        int zExistingBodyIndex = mDeckPanel.getWidgetIndex( pWidget );

        if ( zExistingBodyIndex != -1 ) // Body Existing
        {
            zCurrentlySelected = (zExistingBodyIndex == mDeckPanel.getVisibleWidget());
            mSelectorPanel.remove( zExistingBodyIndex );
            mDeckPanel.remove( zExistingBodyIndex );
        }

        pBeforeIndex = Helper.normalizeBeforeIndex( pBeforeIndex, this );

        mSelectorPanel.insert( pTabLabel, pBeforeIndex );
        mDeckPanel.insert( pWidget, pBeforeIndex );

        mSelectorPanel.getHeightHelper().contentChangedResizeToParent();
        pTabLabel.setWidth( "" + mSelectorRest.getOffsetWidth() );

        if ( zCurrentlySelected )
        {
            selectTab( mDeckPanel.getWidgetIndex( pWidget ) );
        }
    }

    private static class VerticalTabLabel extends SizeableLabel
    {
        private boolean mErrorable;

        public VerticalTabLabel( String pLabelText, boolean pErrorable )
        {
            super( Helper.augment( pLabelText, pErrorable ), true );
            LLstretchableHorizontally();
            mErrorable = pErrorable;
            addStyleName( "litesoft-VerticalTab" );
        }

        public void setText( String pLabelText, boolean pAsHTML )
        {
            super.setText( Helper.augment( pLabelText, mErrorable ), true );
        }
    }
}