package com.test.uidesign.client;

import java.util.*;

import org.litesoft.GWT.client.widgets.*;

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

public class AccordionVerticalPairPanel extends Composite
{
    public static class WidgetPair
    {
        private Widget mPrime, mSubordinate;
        private boolean mShowing;
        private PairPanel mPairPanel;

        public WidgetPair( Widget pPrime, Widget pSubordinate )
        {
            mPrime = pPrime;
            mSubordinate = pSubordinate;
        }

        public Widget getPrime()
        {
            return mPrime;
        }

        public Widget getSubordinate()
        {
            return mSubordinate;
        }

        public boolean isSubordinateShowing()
        {
            if ( mShowing )
            {
                mShowing = checkPrimeAncestry( mPrime ) && checkSubordinateAncestry( mSubordinate );
            }
            return mShowing;
        }

        private boolean isShowing()
        {
            return mShowing;
        }

        private void setShowing( boolean pShowing )
        {
            mShowing = pShowing;
        }

        private static boolean hasContent( WidgetPair pPair )
        {
            return (pPair != null) && (pPair.mPrime != null);
        }

        private PairPanel getPairPanel()
        {
            return mPairPanel;
        }

        private void setPairPanel( PairPanel pPairPanel )
        {
            mPairPanel = pPairPanel;
        }
    }

    private VerticalPanel mContainer = new VerticalPanel();
    private List<WidgetPair> mMembers = new ArrayList<WidgetPair>();

    public AccordionVerticalPairPanel()
    {
        initWidget( mContainer );
    }

    public boolean isEmpty()
    {
        return mMembers.isEmpty();
    }

    public int size()
    {
        return mMembers.size();
    }

    /**
     * Add the two widgets as a WidgetPair (if pPrimeWidget is not null).
     *
     * @return true if the widgets were actually added.
     */
    public boolean add( Widget pPrimeWidget, Widget pSubordinateWidget )
    {
        return add( new WidgetPair( pPrimeWidget, pSubordinateWidget ) );
    }

    /**
     * Add the WidgetPair (if either of the widgets that make up the pair are not null).
     *
     * @return true if the WidgetPair was actually added.
     */
    public boolean add( WidgetPair pWidgetPair )
    {
        if ( WidgetPair.hasContent( pWidgetPair ) )
        {
            mMembers.add( pWidgetPair );
            mContainer.add( new PairPanel( this, pWidgetPair ) );
            return true;
        }
        return false;
    }

    public int indexOf( WidgetPair pWidgetPair )
    {
        return mMembers.indexOf( pWidgetPair );
    }

    public int indexOfSubordinateWidget( Widget pSubordinateWidget )
    {
        for ( int i = 0; i < mMembers.size(); i++ )
        {
            WidgetPair zMember = mMembers.get( i );
            if ( pSubordinateWidget == zMember.getSubordinate() )
            {
                return i;
            }
        }
        return -1;
    }

    public int indexOfPrimeWidget( Widget pPrimeWidget )
    {
        for ( int i = 0; i < mMembers.size(); i++ )
        {
            WidgetPair zMember = mMembers.get( i );
            if ( pPrimeWidget == zMember.getPrime() )
            {
                return i;
            }
        }
        return -1;
    }

    /**
     * @return true if contents changed (i.e. actually removed)
     */
    public boolean remove( WidgetPair pWidgetPair )
    {
        int zIndex = indexOf( pWidgetPair );
        return (zIndex != -1) && (null != remove( zIndex ));
    }

    /**
     * @return WidgetPair that "was" at pIndex.
     */
    public WidgetPair remove( int pIndex )
            throws IndexOutOfBoundsException
    {
        WidgetPair zRemoved = mMembers.remove( pIndex );
        if ( zRemoved != null )
        {
            PairPanel zPairPanel = zRemoved.getPairPanel();
            if ( zPairPanel != null )
            {
                zPairPanel.clear();
            }
            zRemoved.setShowing( false );
            mContainer.remove( pIndex );
        }
        return zRemoved;
    }

    /**
     * Removes all widgets (both the Prime and the Subordinate).
     */
    public void clear()
    {
        mContainer.clear();
        for ( WidgetPair zMember : mMembers )
        {
            PairPanel zPairPanel = zMember.getPairPanel();
            if ( zPairPanel != null )
            {
                zPairPanel.clear();
            }
            zMember.setShowing( false );
        }
        mMembers.clear();
    }

    public void collapseAll()
    {
        for ( WidgetPair zMember : mMembers )
        {
            PairPanel zPairPanel = zMember.getPairPanel();
            if ( zPairPanel != null )
            {
                zPairPanel.collapse();
            }
            zMember.setShowing( false );
        }
    }

    /**
     * Expand (show) or Collapse (!show) the pSubordinateWidget (if found) according to the pShow value requested.
     *
     * @param pSubordinateWidget the Subordinate Widget to locate
     * @param pShow              what to do with the Subordinate Widget if located
     *
     * @return true if the Subordinate Widget was located
     */
    public boolean show( Widget pSubordinateWidget, boolean pShow )
    {
        return showSubordinateWidgetOf( getPairFor( pSubordinateWidget ), pShow );
    }

    /**
     * Expand (show) or Collapse (!show) the Subordinate Widget (at pIndex) according to the pShow value requested.
     *
     * @param pIndex Index of the the Subordinate Widget
     * @param pShow  what to do with the Subordinate Widget
     */
    public void showSubordinateWidgetAt( int pIndex, boolean pShow )
            throws IndexOutOfBoundsException
    {
        showSubordinateWidgetOf( mMembers.get( pIndex ), pShow );
    }

    /**
     * Expand (show) or Collapse (!show) the Subordinate Widget of the WidgetPair (if found) according to the pShow value requested.
     *
     * @param pWidgetPair the  Widget Pair to locate
     * @param pShow       what to do with the Subordinate Widget of the Widget Pair if located
     *
     * @return true if the Widget Pair was located
     */
    public boolean showSubordinateWidgetOf( WidgetPair pWidgetPair, boolean pShow )
    {
        if ( mMembers.contains( pWidgetPair ) )
        {
            PairPanel zPairPanel = pWidgetPair.getPairPanel();
            if ( zPairPanel != null )
            {
                if ( pShow )
                {
                    zPairPanel.expand();
                }
                else
                {
                    zPairPanel.collapse();
                }
                pWidgetPair.setShowing( pShow );
                return true;
            }
        }
        return false;
    }

    public boolean isShowing( Widget pSubordinateWidget )
    {
        return isSubordinateWidgetShowing( getPairFor( pSubordinateWidget ) );
    }

    public boolean isSubordinateWidgetShowingAt( int pIndex )
            throws IndexOutOfBoundsException
    {
        return isSubordinateWidgetShowing( mMembers.get( pIndex ) );
    }

    public boolean isSubordinateWidgetShowing( WidgetPair pWidgetPair )
    {
        return mMembers.contains( pWidgetPair ) && pWidgetPair.isShowing();
    }

    private WidgetPair getPairFor( Widget pSubordinateWidget )
    {
        for ( WidgetPair zMember : mMembers )
        {
            if ( pSubordinateWidget == zMember.getSubordinate() )
            {
                return zMember;
            }
        }
        return null;
    }

    /**
     * Only called by the PairPanel that should be removed because the PairPanel has lost one of its widgets.
     */
    private void removePair( PairPanel pPairPanel )
    {
        for ( int i = 0; i < mMembers.size(); i++ )
        {
            WidgetPair zMember = mMembers.get( i );
            PairPanel zPairPanel = zMember.getPairPanel();
            if ( pPairPanel == zPairPanel )
            {
                remove( i );
                return;
            }
        }
    }

    private static boolean checkSubordinateAncestry( Widget pWidget )
    {
        return (pWidget == null) || //
               (null != parentClassIs( PairPanel.class, //
                                       parentClassIs( ClippingPanel.class, //
                                                      parentClassIs( SubordinatePanel.class, //
                                                                     pWidget ) ) ));
    }

    private static boolean checkPrimeAncestry( Widget pWidget )
    {
        return (null != parentClassIs( PairPanel.class, pWidget ));
    }

    private static Widget parentClassIs( Class<?> pClass, Widget pWidget )
    {
        if ( pWidget != null )
        {
            if ( null != (pWidget = pWidget.getParent()) )
            {
                if ( pWidget.getClass() == pClass )
                {
                    return pWidget;
                }
            }
        }
        return null;
    }

    private static class PairPanel extends VerticalPanel
    {
        private AccordionVerticalPairPanel mParent;
        private ClippingPanel mClippingPanel;

        private PairPanel( AccordionVerticalPairPanel pParent, WidgetPair pWidgetPair )
        {
            mParent = pParent;
            add( pWidgetPair.getPrime() );
            add( mClippingPanel = new ClippingPanel( this, pWidgetPair.getSubordinate() ) );
            pWidgetPair.setPairPanel( this );
        }

        public void collapse()
        {
            mClippingPanel.collapse();
        }

        public void expand()
        {
            mClippingPanel.expand();
        }

        /**
         * Clear/Release our Widgets (this is called under two circumstances: our Parent is clearing and calling us to clean up, or
         * one of our children has been removed so we are no longer attached to our parent and are cleaning up).
         */
        @Override
        public void clear()
        {
            mParent = null; // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
            super.clear();
            if ( mClippingPanel != null )
            {
                mClippingPanel.clear();
                mClippingPanel = null;
            }
        }

        /**
         * Here we handle the case when either the Prime Widget is removed (by being attached somewhere else) or the Clipping Panel removes itself.
         * <p/>
         * We Automatically remove ourselves from our Parent (AccordionVerticalPairPanel).
         */
        @Override
        public boolean remove( Widget w )
        {
            boolean zRemoved = super.remove( w );
            if ( zRemoved )
            {
                if ( mParent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    mParent.removePair( this );
                    clear();
                }
            }
            return zRemoved;
        }
    }

    private static class ClippingPanel extends SimplePanel
    {
        private PairPanel mParent;
        private SubordinatePanel mSubordinatePanel;
        private AnimatedVisibility mVisibility = AnimatedVisibility.Collapsed;
        private AnimatedVisibility mTargetVisibility;
        private int mCurrentHeight = 1;
        private Integer mMaxHeight;
        private HeightAnimator mAnimator;

        private ClippingPanel( PairPanel pParent, Widget pSubordinateWidget )
        {
            mParent = pParent;
            setWidget( mSubordinatePanel = new SubordinatePanel( this, pSubordinateWidget ) );
            getStyleElement().getStyle().setOverflow( Style.Overflow.HIDDEN );
            setHeight( "1px" );
        }

        /**
         * Clear/Release our Widget (this is called under two circumstances: our Parent is clearing and calling us to clean up, or
         * our child has been removed so we are no longer attached to our parent and are cleaning up).
         */
        @Override
        public void clear()
        {
            mParent = null; // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
            super.clear();
            if ( mSubordinatePanel != null )
            {
                mSubordinatePanel.clear();
                mSubordinatePanel = null;
            }
        }

        /**
         * Here we handle the case when the Subordinate Panel removes itself.
         * <p/>
         * We Automatically remove ourselves from our Parent (PairPanel).
         */
        @Override
        public boolean remove( Widget w )
        {
            boolean zRemoved = super.remove( w );
            if ( zRemoved )
            {
                if ( mParent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    mParent.remove( this );
                    clear();
                }
            }
            return zRemoved;
        }

        public AnimatedVisibility getVisibility()
        {
            return mVisibility;
        }

        public void collapse()
        {
            if ( sizingIsReadyWithNotReadyTarget( AnimatedVisibility.Collapsed ) && mVisibility.isExpandingOrExpanded() )
            {
                transition( AnimatedVisibility.Collapsing, 1 );
            }
        }

        public void expand()
        {
            if ( sizingIsReadyWithNotReadyTarget( AnimatedVisibility.Expanded ) && mVisibility.isCollapsingOrCollapsed() )
            {
                transition( AnimatedVisibility.Expanding, mMaxHeight );
            }
        }

        /**
         * Some browsers implement incremental rendering, which means that when an element is added to the DOM,
         * it can take some time until it is actually rendered and hence actually has a size (of course if any
         * element along the path to the root is display=none, then a size might NEVER arrive).
         */
        private boolean sizingIsReadyWithNotReadyTarget( AnimatedVisibility pTargetVisibility )
        {
            if ( mMaxHeight == null )
            {
                mTargetVisibility = pTargetVisibility;
                return false;
            }
            mTargetVisibility = null;
            return true;
        }

        /**
         * Called to indicate that Sizing is Ready!
         */
        private void setMaxHeight( int pHeight )
        {
            mMaxHeight = pHeight;
            // Now dispatch the last request (if any) that occured before Sizing was Ready!
            if ( AnimatedVisibility.Collapsed == mTargetVisibility )
            {
                collapse();
            }
            if ( AnimatedVisibility.Expanded == mTargetVisibility )
            {
                expand();
            }
        }

        private void setCurrentHeight( int pHeight )
        {
            if ( pHeight < 2 )
            {
                mVisibility = AnimatedVisibility.Collapsed;
                pHeight = 1;
            }
            if ( mMaxHeight <= pHeight )
            {
                mVisibility = AnimatedVisibility.Expanded;
                pHeight = mMaxHeight;
            }
            mCurrentHeight = pHeight;
            setHeight( pHeight + "px" );
        }

        private void transition( AnimatedVisibility pNewVisibility, int pTargetHeight )
        {
            if ( mAnimator != null )
            {
                mAnimator.cancel();
                mAnimator = null;
            }
            mVisibility = pNewVisibility;
            mAnimator = new HeightAnimator( this, mCurrentHeight, pTargetHeight );
            mAnimator.start();
        }
    }

    private static class SubordinatePanel extends VerticalPanel
    {
        private OurSizingDeterminer mSizingDeterminer = new OurSizingDeterminer();
        private ClippingPanel mParent;

        private SubordinatePanel( ClippingPanel pParent, Widget pSubordinateWidget )
        {
            mParent = pParent;
            add( new TransparentImage() );
            add( (null != pSubordinateWidget) ? pSubordinateWidget : new TransparentImage() );
        }

        /**
         * Clear/Release our Widgets (this is called under two circumstances: our Parent is clearing and calling us to clean up, or
         * one of our children has been removed so we are no longer attached to our parent and are cleaning up).
         */
        @Override
        public void clear()
        {
            mParent = null; // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
            super.clear();
        }

        /**
         * Here we handle the case when the Subordinate Widget is removed by being attached somewhere else.
         * <p/>
         * We Automatically remove ourselves from our Parent (ClippingPanel).
         */
        @Override
        public boolean remove( Widget w )
        {
            boolean zRemoved = super.remove( w );
            if ( zRemoved )
            {
                if ( mParent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    mParent.remove( this );
                    clear();
                }
            }
            return zRemoved;
        }

        @Override
        protected void onAttach()
        {
            super.onAttach();
            mSizingDeterminer.start();
        }

        @Override
        protected void onDetach()
        {
            super.onDetach();
            mSizingDeterminer.stop();
        }

        /**
         * Some browsers implement incremental rendering, which means that when an element is added to the DOM,
         * it can take some time until it is actually rendered and hence actually has a size (of course if any
         * element along the path to the root is display=none, then a size might NEVER arrive).
         */
        private class OurSizingDeterminer extends com.google.gwt.user.client.Timer
        {
            private Boolean mSizingDetermined;
            private int mHeight = 1;

            @Override
            public void run()
            {
                int zHeight = getOffsetHeight();
                if ( (1 < zHeight) && (zHeight == mHeight) )
                {
                    mParent.setMaxHeight( zHeight );
                    mSizingDetermined = true;
                    return;
                }
                mHeight = zHeight;
                if ( mSizingDetermined != null )
                {
                    schedule( 50 );
                }
            }

            public void start()
            {
                if ( !Boolean.TRUE.equals( mSizingDetermined ) )
                {
                    mSizingDetermined = false;
                    schedule( 50 );
                }
            }

            public void stop()
            {
                if ( Boolean.FALSE.equals( mSizingDetermined ) )
                {
                    mSizingDetermined = null;
                    cancel();
                }
            }
        }
    }

    private static class HeightAnimator extends Animation
    {
        private ClippingPanel mClippingPanel;
        private int mFromHeight;
        private int mToHeight;
        private int mDelta;
        private boolean mCompleted = true;

        public HeightAnimator( ClippingPanel pClippingPanel, int pFromHeight, int pToHeight )
        {
            mClippingPanel = pClippingPanel;
            mFromHeight = pFromHeight;
            mToHeight = pToHeight;
            mDelta = pToHeight - pFromHeight;
        }

        public void start()
        {
            mCompleted = false;
            run( Math.min( 700, Math.abs( 7 * mDelta ) ) );
        }

        @Override
        protected void onUpdate( double progress )
        {
            if ( !mCompleted )
            {
                mClippingPanel.setCurrentHeight( mFromHeight + (int) (progress * mDelta) );
            }
        }

        @Override
        protected void onComplete()
        {
            mCompleted = true;
            super.onComplete();
            mClippingPanel.setCurrentHeight( mToHeight );
        }
    }
}