package com.temp.foundation.client.widget;

import org.litesoft.externalization.shared.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.ui.*;
import com.temp.common.shared.utils.*;

import java.util.*;

public class WizardProgressIndicator<T extends Enum<T>> extends Composite {
    public static final String WIZARD_PROGRESS_STEP = "WizardProgressStep";
    public static final String WIZARD_PROGRESS_TEXT = "WizardProgressText";
    public static final String WIZARD_PROGRESS_CLICKABLE = "WizardProgressClickable";

    private static final int POST_TEXT_SPACE = 15;
    private static final String STR_POST_TEXT_SPACE = POST_TEXT_SPACE + "px";

    private static final String LadderUrlLine = "images/wizardSteps/Ladder-Line.png";
    private static final String LadderUrlLineEnd = "images/wizardSteps/Ladder-LineEnd.png";
    private static final String LadderUrlPagePrev = "images/wizardSteps/Ladder-PagePrev.png";
    private static final String LadderUrlPageCurrent = "images/wizardSteps/Ladder-PageCurrent.png";
    private static final String LadderUrlPageNext = "images/wizardSteps/Ladder-PageNext.png";
    public static final String SUFFIX_PREV = "Prev";
    public static final String SUFFIX_CURRENT = "Current";
    public static final String SUFFIX_NEXT = "Next";

    public interface PrevClicked<E extends Enum<E>> {
        void prevClicked( E step );
    }

    private final E13nResolver mResolver;
    private final ClickHandler[] mClickHandlers;
    private final ImageElement[] mLineImages;
    private final Widget[] mPageTextWidget;
    private final Element mStyleElement;
    private final OurSizer mSizer = new OurSizer();
    private PrevClicked<T> mPrevClicked;

    public WizardProgressIndicator( String pContext, T pCurrentStep, T[] pSteps ) {
        pContext = StringUtils.noEmpty( pContext );
        E13nResolver zResolver = Global.get( E13nResolver.class );
        mResolver = (pContext == null) ? zResolver : new ContextualE13nResolver( zResolver, pContext );

        int zIndexOfCurrent = validateParams( pCurrentStep, pSteps ); // 0 based
        mClickHandlers = createClickHandlers( zIndexOfCurrent, pSteps );
        mPageTextWidget = createPageTextWidgets( zIndexOfCurrent, pSteps );
        SimplePanel zStyleWrapper = new SimplePanel();
        mStyleElement = zStyleWrapper.getElement();

        Image[] zLineImages = createLineImages( pSteps.length );
        Image[] zPagePositionImages = createPagePositionImages( zIndexOfCurrent, pSteps.length );
        Label[] zStepNumbers = createStepNumberLabels( zIndexOfCurrent, pSteps.length );

        mLineImages = extractElements( zLineImages );

        initWidget( createStyleSandwich( zStyleWrapper, createGrid( zPagePositionImages, zLineImages, zStepNumbers ) ) );
    }

    public WizardProgressIndicator<T> setPrevClickedCallback( PrevClicked<T> pPrevClicked ) {
        mPrevClicked = pPrevClicked;
        return this;
    }

    @Override
    protected Element getStyleElement() {
        return mStyleElement;
    }

    @Override
    protected void onAttach() {
        super.onAttach();
        mSizer.run();
    }

    private Widget createGrid( Image[] pPagePositionImages, Image[] pLineImages, Label[] pStepNumbers ) {
        Grid grid = new Grid( 2, pPagePositionImages.length + mLineImages.length + 1 );
        grid.setCellPadding( 0 );
        grid.setCellSpacing( 0 );
        int zColumn = 0;
        for ( int i = 0; i < pPagePositionImages.length; i++ ) {
            Label zStepNumber = pStepNumbers[i];
            grid.setWidget( 0, zColumn, pPagePositionImages[i] );
            grid.setWidget( 1, zColumn, zStepNumber );
            zColumn++;
            grid.setWidget( 0, zColumn, pLineImages[i] );
            grid.setWidget( 1, zColumn, mPageTextWidget[i] );
            zColumn++;
            centerInTD( zStepNumber );
        }
        grid.setWidget( 0, zColumn, new Image( LadderUrlLineEnd ) );
        grid.setWidget( 1, zColumn, new Spacer().size( "1px" ) );
        return grid;
    }

    private void centerInTD( Widget pWidget ) {
        pWidget.getElement().getParentElement().setAttribute( "Align", "Center" );
    }

    private Widget[] createPageTextWidgets( int pIndexOfCurrent, T[] pSteps ) {
        Widget[] widgets = new Widget[pSteps.length];
        for ( int i = 0; i < pSteps.length; i++ ) {
            widgets[i] = createPageTextWidget( i, pIndexOfCurrent, pSteps[i] );
        }
        return widgets;
    }

    private Widget createPageTextWidget( int pIndex, int pIndexOfCurrent, T pStep ) {
        HorizontalPanel panel = new HorizontalPanel();
        panel.add( createStepLabel( pIndex, pIndexOfCurrent, resolve( pStep.name() ), WIZARD_PROGRESS_TEXT ) );
        panel.add( new Spacer().height( "1px" ).width( STR_POST_TEXT_SPACE ) );
        return panel;
    }

    private ClickHandler[] createClickHandlers( int pCountOfPrevs, T[] pSteps ) {
        ClickHandler[] zHandlers = new ClickHandler[pCountOfPrevs];
        for ( int i = 0; i < pCountOfPrevs; i++ ) {
            zHandlers[i] = new OurClickHandler( pSteps[i] );
        }
        return zHandlers;
    }

    private Widget createStyleSandwich( SimplePanel pStyleWrapper, Widget pContent ) {
        HorizontalPanel zConstrainingTable = new HorizontalPanel();
        zConstrainingTable.add( pStyleWrapper );
        pStyleWrapper.setWidget( pContent );
        return zConstrainingTable;
    }

    private Image[] createPagePositionImages( int pIndexOfCurrent, int pLength ) {
        Image[] images = new Image[pLength];
        for ( int i = 0; i < images.length; i++ ) {
            Image image;
            if ( i < pIndexOfCurrent ) {
                image = new Image( LadderUrlPagePrev );
                image.addClickHandler( mClickHandlers[i] );
                image.addStyleName( WIZARD_PROGRESS_CLICKABLE );
            } else if ( i == pIndexOfCurrent ) {
                image = new Image( LadderUrlPageCurrent );
            } else {
                image = new Image( LadderUrlPageNext );
            }
            images[i] = image;
        }
        return images;
    }

    private Image[] createLineImages( int pLength ) {
        Image[] images = new Image[pLength];
        for ( int i = 0; i < images.length; i++ ) {
            images[i] = new Image( LadderUrlLine );
        }
        return images;
    }

    private ImageElement[] extractElements( Image[] pImages ) {
        ImageElement[] imageElements = new ImageElement[pImages.length];
        for ( int i = 0; i < pImages.length; i++ ) {
            imageElements[i] = ImageElement.as( pImages[i].getElement() );
        }
        return imageElements;
    }

    private Label[] createStepNumberLabels( int pIndexOfCurrent, int pLength ) {
        Label[] labels = new Label[pLength];
        for ( int i = 0; i < labels.length; i++ ) {
            labels[i] = createStepLabel( i, pIndexOfCurrent, Integer.toString( i + 1 ), WIZARD_PROGRESS_STEP );
        }
        return labels;
    }

    private Label createStepLabel( int pIndex, int pIndexOfCurrent, String pText, String pStyleName ) {
        Label label = new Label( pText );
        label.addStyleName( pStyleName );
        if ( pIndex < pIndexOfCurrent ) {
            label.addClickHandler( mClickHandlers[pIndex] );
            label.addStyleName( WIZARD_PROGRESS_CLICKABLE );
            label.addStyleName( pStyleName + SUFFIX_PREV );
        } else if ( pIndex == pIndexOfCurrent ) {
            label.addStyleName( pStyleName + SUFFIX_CURRENT );
        } else {
            label.addStyleName( pStyleName + SUFFIX_NEXT );
        }
        return label;
    }

    /**
     * Validate the parameters and return the index of pStep
     *
     * @param pStep  !null and must be one of pSteps
     * @param pSteps !null, No Nulls, and must be at least two entries
     *
     * @return index of pStep in pSteps
     */
    private int validateParams( T pStep, T[] pSteps ) {
        Assert.notNull( "Step", pStep );
        Assert.notNull( "Steps", pSteps );
        int zAt = -1;
        for ( int i = 0; i < pSteps.length; i++ ) {
            T zStep = pSteps[i];
            if ( zStep == null ) {
                throw Assert.nullValue( "Steps[" + i + "]" );
            }
            if ( zStep == pStep ) {
                zAt = i;
            }
        }
        if ( zAt == -1 ) {
            throw new IllegalArgumentException( "Step '" + pStep + "' not one of: " + Arrays.asList( pSteps ) );
        }
        return zAt;
    }

    private class OurClickHandler implements ClickHandler {
        private T mStep;

        private OurClickHandler( T pStep ) {
            mStep = pStep;
        }

        @Override
        public void onClick( ClickEvent event ) {
            if ( mPrevClicked != null ) {
                mPrevClicked.prevClicked( mStep );
            }
        }
    }

    private class OurSizer extends Timer {

        private int mDelay = 0;
        private Integer mDesiredWidth;
        private boolean mSized;

        @Override
        public void run() {
            if ( mSized || !isAttached() ) {
                return; // Already Sized OR Lost Attachment
            }
            if ( mDesiredWidth == null ) {
                mDesiredWidth = determineMaxWidth( mPageTextWidget );
                // System.out.println("DesiredWidth: " + mDesiredWidth);
            }
            if ( mDesiredWidth != null ) {
                mSized = applyWidth( mDesiredWidth, mLineImages );
                // System.out.println("Sized: " + mSized);
            }
            if ( !mSized ) {
                mDelay = Math.min( mDelay + 50, 250 );
                schedule( mDelay );
            }
        }

        private Integer determineMaxWidth( Widget[] pWidgets ) {
            int zMax = 0;
            for ( Widget widget : pWidgets ) {
                int width = widget.getOffsetWidth();
                if ( width < POST_TEXT_SPACE ) {
                    return null;
                }
                zMax = Math.max( zMax, width );
            }
            return zMax;
        }

        private boolean applyWidth( int pWidth, ImageElement[] pImages ) {
            for ( ImageElement imageElement : pImages ) {
                int height = imageElement.getHeight();
                if ( height < 1 ) {
                    return false;
                }
                imageElement.setHeight( height );
                imageElement.setWidth( pWidth );
            }
            return true;
        }
    }

    private String resolve( String pKey ) {
        String value = mResolver.resolve( pKey );
        return (value != null) ? value : "[" + pKey + "]";
    }
}