package org.litesoft.GWT.client.widgets;

import java.util.*;

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

public class SizeableTabPanel extends AbstractSizeableComposite implements TabListener,
                                                                           SourcesTabEvents,
                                                                           HasWidgets,
                                                                           IndexedPanel,
                                                                           ISizeableTabPanel
{
    private WidgetCollection mChildren = new WidgetCollection( this );
    private SizeableDeckPanel mDeck = new SizeableDeckPanel();
    private WidgetTabBar mTabBar = new WidgetTabBar();
    private TabListenerCollection mTabListeners;
    private static final String STYLE_TAB_NON_ERROR = "gwt-TabBarItem-NonError";
    private static final String STYLE_TAB_ERROR = "gwt-TabBarItem-Error";
    private boolean mErrorable;

    public SizeableTabPanel()
    {
        this( false );
    }

    public SizeableTabPanel( boolean pErrorable )
    {
        mErrorable = pErrorable;
        SizeableVerticalPanel vp = new SizeableVerticalPanel( true );

        vp.add( mTabBar );
        vp.add( mDeck );

        initWidget( vp );

        style( "LayoutSizeableTabPanel" );
        style( "gwt-TabPanel" );
        mDeck.style( "gwt-TabPanelBottom" );

        mTabBar.addTabListener( this );
    }

    public SizeableTabPanel style( String pStyleName )
    {
        addStyleName( pStyleName );
        return this;
    }

    public void add( Widget w )
    {
        throw new UnsupportedOperationException( "A tabText parameter must be specified with add()." );
    }

    /**
     * Inserts a widget into the tab panel.
     *
     * @param pBeforeIndex the index before which it will be inserted
     * @param pLabelText   the text to be shown on its tab
     * @param pWidget      the widget to be inserted
     */
    public void insertTab( int pBeforeIndex, String pLabelText, Widget pWidget )
    {
        insertTab( pBeforeIndex, pLabelText, false, pWidget );
    }

    /**
     * Inserts a widget into the tab panel.
     *
     * @param pBeforeIndex the index before which it will be inserted
     * @param pLabelText   the text to be shown on its tab
     * @param pAsHTML      <code>true</code> to treat the specified text as HTML
     * @param pWidget      the widget to be inserted
     */
    public void insertTab( int pBeforeIndex, String pLabelText, boolean pAsHTML, Widget pWidget )
    {
        pWidget.removeFromParent();
    	pBeforeIndex = Helper.normalizeBeforeIndex( pBeforeIndex, this );
        mChildren.insert( pWidget, pBeforeIndex );
        mTabBar.insertTab( Helper.augment( pLabelText, mErrorable ), true, pBeforeIndex );
        mDeck.insert( pWidget, pBeforeIndex );
        forceTabSelection( -1, mTabBar.getSelectedTab() );
    }

    public void removeTab( int pIndex )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            remove( pIndex );
        }
    }

    /**
     * Adds a widget to the tab panel.
     *
     * @param pLabelText
     * @param pWidget
     */
    public void addTab( String pLabelText, Widget pWidget )
    {
        insertTab( getWidgetCount(), pLabelText, pWidget );
    }

    /**
     * Adds a widget to the tab panel.
     *
     * @param pLabelText the text to be shown on its tab
     * @param pAsHTML    <code>true</code> to treat the specified text as HTML
     * @param pWidget    the widget to be added
     */
    public void addTab( String pLabelText, boolean pAsHTML, Widget pWidget )
    {
        insertTab( getWidgetCount(), pLabelText, pAsHTML, pWidget );
    }

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

    public int getSelectedTab()
    {
        return mTabBar.getSelectedTab();
    }

    /**
     * Programmatically selects the specified tab.
     *
     * @param pIndex the index of the tab to be selected
     */
    public void selectTab( int pIndex )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            mTabBar.selectTab( pIndex );
        }
    }

    public void addTabListener( TabListener listener )
    {
        if ( mTabListeners == null )
        {
            mTabListeners = new TabListenerCollection();
        }
        //noinspection unchecked
        mTabListeners.add( listener );
    }

    public void clear()
    {
        while ( getWidgetCount() > 0 )
        {
            remove( getWidget( 0 ) );
        }
    }

    public Iterator<Widget> iterator()
    {
        return mChildren.iterator();
    }

    public boolean onBeforeTabSelected( SourcesTabEvents sender, int tabIndex )
    {
        return (mTabListeners == null) || mTabListeners.fireBeforeTabSelected( this, tabIndex );
    }

    public void onTabSelected( SourcesTabEvents sender, int tabIndex )
    {
        mDeck.showWidget( tabIndex );
        if ( mTabListeners != null )
        {
            mTabListeners.fireTabSelected( this, tabIndex );
        }
    }

    public Widget getWidget( int index )
    {
        return mChildren.get( index );
    }

    public int getWidgetCount()
    {
        return mChildren.size();
    }

    public int getWidgetIndex( Widget widget )
    {
        return mChildren.indexOf( widget );
    }

    public boolean remove( int pIndex )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            int prevSelectedTab = mTabBar.getSelectedTab();
            mChildren.remove( pIndex );
            mTabBar.removeTab( pIndex );
            mDeck.remove( pIndex );
            forceTabSelection( pIndex, prevSelectedTab );
            return true;
        }
        return false;
    }

    /**
     * Removes the given widget, and its associated tab.
     *
     * @param widget the widget to be removed
     */
    public boolean remove( Widget widget )
    {
        return remove( getWidgetIndex( widget ) );
    }

    public void removeTabListener( TabListener listener )
    {
        if ( mTabListeners != null )
        {
            mTabListeners.remove( listener );
        }
    }

    private void forceTabSelection( int pRemovedIndex, int pPrevSelectedTab )
    {
        int count = mTabBar.getTabCount();
        if ( (count > 0) && (pRemovedIndex == pPrevSelectedTab) )
        {
            int toSelect = (pPrevSelectedTab < 0) ? //
                           0 : //
                           (pPrevSelectedTab < count) ? //
                           pPrevSelectedTab : //
                           count - 1;
            selectTab( toSelect );
        }
    }

    //****** Implementation Code Block to support delegation to AbsoluteSizeHelper

    public SizeableTabPanel stretchable()
    {
        LLstretchable();
        mDeck.stretchable();
        return this;
    }

    public SizeableTabPanel stretchableVertically()
    {
        LLstretchableVertically();
        mDeck.stretchableVertically();
        return this;
    }

    public SizeableTabPanel stretchableHorizontally()
    {
        LLstretchableHorizontally();
        mDeck.stretchableHorizontally();
        return this;
    }

    public void setWidth( String width )
    {
        super.setWidth( width ); // for stacktrace Debugging
    }

    public void setHeight( String height )
    {
        super.setHeight( height ); // for stacktrace Debugging
    }

    public void setError( int pIndex, boolean pError )
    {
        if ( Helper.indexOK( pIndex, this ) )
        {
            Widget widget = mTabBar.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 );
            }
        }
    }
}