// This Source Code is in the Public Domain per: http://unlicense.org
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 );
        }
    }
}