package com.temp.foundation.client.widget;

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

import java.util.*;

/**
 * This class provides for creating a VerticalPanel "like" object that takes widgets as Pairs.
 * <p/>
 * These Widget Pairs are called the Prime Widget and the Subordinate Widget.  All the Prime Widgets are
 * visible, but the Subordinate Widget attached to the Prime Widget is only visible if visibility is requested.
 * <p/>
 * The showing and hiding of the a Subordinate Widget is animated!
 *
 * @author georgs
 */
public class AccordionVerticalPairPanel extends Composite {
    public static class WidgetPair {
        private Widget prime, mSubordinate;
        private boolean showing;
        private PairPanel pairPanel;

        public WidgetPair( Widget prime, Widget subordinate ) {
            this.prime = prime;
            this.mSubordinate = subordinate;
        }

        public Widget getPrime() {
            return prime;
        }

        public Widget getSubordinate() {
            return mSubordinate;
        }

        public boolean isSubordinateShowing() {
            if ( showing ) {
                showing = checkPrimeAncestry( prime ) && checkSubordinateAncestry( mSubordinate );
            }
            return showing;
        }

        private boolean isShowing() {
            return showing;
        }

        private void setShowing( boolean showing ) {
            this.showing = showing;
        }

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

        private PairPanel getPairPanel() {
            return pairPanel;
        }

        private void setPairPanel( PairPanel pairPanel ) {
            this.pairPanel = pairPanel;
        }
    }

    private VerticalPanel container = new VerticalPanel();
    private List<WidgetPair> members = new ArrayList<WidgetPair>();

    public AccordionVerticalPairPanel() {
        initWidget( container );
    }

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

    public int size() {
        return members.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 primeWidget, Widget subordinateWidget ) {
        return add( new WidgetPair( primeWidget, subordinateWidget ) );
    }

    /**
     * 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 widgetPair ) {
        if ( WidgetPair.hasContent( widgetPair ) ) {
            members.add( widgetPair );
            container.add( new PairPanel( this, widgetPair ) );
            return true;
        }
        return false;
    }

    public int indexOf( WidgetPair widgetPair ) {
        return members.indexOf( widgetPair );
    }

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

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

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

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

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

    public void collapseAll() {
        for ( WidgetPair zMember : members ) {
            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 subordinateWidget the Subordinate Widget to locate
     * @param show              what to do with the Subordinate Widget if located
     *
     * @return true if the Subordinate Widget was located
     */
    public boolean show( Widget subordinateWidget, boolean show ) {
        return showSubordinateWidgetOf( getPairFor( subordinateWidget ), show );
    }

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

    /**
     * Expand (show) or Collapse (!show) the Subordinate Widget of the
     * WidgetPair (if found) according to the pShow value requested.
     *
     * @param widgetPair the Widget Pair to locate
     * @param show       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 widgetPair, boolean show ) {
        if ( members.contains( widgetPair ) ) {
            PairPanel zPairPanel = widgetPair.getPairPanel();
            if ( zPairPanel != null ) {
                if ( show ) {
                    zPairPanel.expand();
                } else {
                    zPairPanel.collapse();
                }
                widgetPair.setShowing( show );
                return true;
            }
        }
        return false;
    }

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

    public boolean isSubordinateWidgetShowingAt( int index )
            throws IndexOutOfBoundsException {
        return isSubordinateWidgetShowing( members.get( index ) );
    }

    public boolean isSubordinateWidgetShowing( WidgetPair widgetPair ) {
        return members.contains( widgetPair ) && widgetPair.isShowing();
    }

    private WidgetPair getPairFor( Widget pSubordinateWidget ) {
        for ( WidgetPair zMember : members ) {
            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 pairPanel ) {
        for ( int i = 0; i < members.size(); i++ ) {
            WidgetPair zMember = members.get( i );
            PairPanel zPairPanel = zMember.getPairPanel();
            if ( pairPanel == zPairPanel ) {
                remove( i );
                return;
            }
        }
    }

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

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

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

    private static class PairPanel extends VerticalPanel {
        private AccordionVerticalPairPanel parent;
        private ClippingPanel clippingPanel;

        private PairPanel( AccordionVerticalPairPanel pParent, WidgetPair widgetPair ) {
            this.parent = pParent;
            add( widgetPair.getPrime() );
            add( this.clippingPanel = new ClippingPanel( this, widgetPair.getSubordinate() ) );
            widgetPair.setPairPanel( this );
        }

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

        public void expand() {
            clippingPanel.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() {
            parent = null; // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
            super.clear();
            if ( clippingPanel != null ) {
                clippingPanel.clear();
                clippingPanel = 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 ( parent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    parent.removePair( this );
                    clear();
                }
            }
            return zRemoved;
        }
    }

    private enum AnimatedVisibility {
        Collapsing( true ), Collapsed( true ), Expanding( false ), Expanded( false );

        private boolean collapsingOrCollapsed;

        AnimatedVisibility( boolean collapsingOrCollapsed ) {
            this.collapsingOrCollapsed = collapsingOrCollapsed;
        }

        public boolean isCollapsingOrCollapsed() {
            return collapsingOrCollapsed;
        }

        public boolean isExpandingOrExpanded() {
            return !collapsingOrCollapsed;
        }
    }

    private static class ClippingPanel extends SimplePanel {
        private PairPanel parent;
        private SubordinatePanel subordinatePanel;
        private AnimatedVisibility visibility = AnimatedVisibility.Collapsed;
        private AnimatedVisibility targetVisibility;
        private int currentHeight = 1;
        private Integer maxHeight;
        private HeightAnimator animator;

        private ClippingPanel( PairPanel parent, Widget subordinateWidget ) {
            this.parent = parent;
            setWidget( subordinatePanel = new SubordinatePanel( this, subordinateWidget ) );
            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() {
            parent = null; // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
            super.clear();
            if ( subordinatePanel != null ) {
                subordinatePanel.clear();
                subordinatePanel = 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 ( parent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    parent.remove( this );
                    clear();
                }
            }
            return zRemoved;
        }

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

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

        /**
         * 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 targetVisibility ) {
            if ( maxHeight == null ) {
                this.targetVisibility = targetVisibility;
                return false;
            }
            this.targetVisibility = null;
            return true;
        }

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

        private void setCurrentHeight( int height ) {
            if ( height < 2 ) {
                visibility = AnimatedVisibility.Collapsed;
                height = 1;
            }
            if ( maxHeight <= height ) {
                visibility = AnimatedVisibility.Expanded;
                height = maxHeight;
            }
            currentHeight = height;
            setHeight( height + "px" );
        }

        private void transition( AnimatedVisibility newVisibility, int targetHeight ) {
            if ( animator != null ) {
                animator.cancel();
                animator = null;
            }
            visibility = newVisibility;
            animator = new HeightAnimator( this, currentHeight, targetHeight );
            animator.start();
        }
    }

    private static class SubordinatePanel extends VerticalPanel {
        private OurSizingDeterminer sizingDeterminer = new OurSizingDeterminer();
        private ClippingPanel parent;

        private SubordinatePanel( ClippingPanel parent, Widget subordinateWidget ) {
            this.parent = parent;
            add( new Spacer().size( "1px" ) );
            add( (null != subordinateWidget) ? subordinateWidget : 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() {
            parent = 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 ( parent != null ) // in case remove is called as part of the clear operation, then don't generate a potential infinite loop!
                {
                    parent.remove( this );
                    clear();
                }
            }
            return zRemoved;
        }

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

        @Override
        protected void onDetach() {
            super.onDetach();
            sizingDeterminer.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 sizingDetermined;
            private int height = 1;

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

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

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

    private static class HeightAnimator extends Animation {
        private ClippingPanel clippingPanel;
        private int fromHeight;
        private int toHeight;
        private int delta;
        private boolean completed = true;

        public HeightAnimator( ClippingPanel clippingPanel, int fromHeight, int toHeight ) {
            this.clippingPanel = clippingPanel;
            this.fromHeight = fromHeight;
            this.toHeight = toHeight;
            delta = toHeight - fromHeight;
        }

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

        @Override
        protected void onUpdate( double progress ) {
            if ( !completed ) {
                clippingPanel.setCurrentHeight( fromHeight + (int) (progress * delta) );
            }
        }

        @Override
        protected void onComplete() {
            completed = true;
            super.onComplete();
            clippingPanel.setCurrentHeight( toHeight );
        }
    }
}