package org.litesoft.prioritizer.client.ui.views.stories;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.view.*;
import org.litesoft.GWT.client.widgets.Button;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.datatables.*;
import org.litesoft.GWT.forms.client.*;
import org.litesoft.bo.views.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.core.util.*;
import org.litesoft.prioritizer.client.boviews.*;
import org.litesoft.prioritizer.client.support.*;
import org.litesoft.uispecification.*;

import com.google.gwt.core.client.*;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

public abstract class AbstractPrioritizeScreenView extends ScreenView implements StoryViewNames,
                                                                                 SimpleDataProviderCallBack,
                                                                                 DataAvailableCallBack<StoryView> {
    protected final String mWhat;
    protected final StoryViewDataProvider mDP = StoryViewDataProvider.getInstance();
    protected final ListTableModel<StoryView> mTableModel = new ListTableModel<StoryView>();
    protected final CheckBoxSelectRegularTable<StoryView> mTable;
    protected final MoveControlPanel mMoveControlPanel;
    private Set<StoryView> mSavedSelectedValues = null;

    private Integer mTopRowOffset = null;

    @Override
    protected UriFragmentIdParams createRefreshParams() {
        return ReprioritizeFactory.encodeParams( mTopRowOffset );
    }

    public AbstractPrioritizeScreenView( String pSection, ViewDef pViewDef, String pWhat, boolean pAddUpDown, BoTableDefinition<StoryView> pTableDef,
                                         Integer pTopRowOffset ) {
        super( title( pSection, pViewDef ) );

        mTopRowOffset = pTopRowOffset;

        mWhat = pWhat;

        addRight( Button.named( "Refresh" ).blue().text().add( new ClickHandler() {
            @Override
            public void onClick( ClickEvent event ) {
                fetchRows();
            }
        } ).create() );
        addStandardTitleBar();

        addSectionTitle( mWhat );

        mMoveControlPanel = new MoveControlPanel( pAddUpDown );
        mTable = new CheckBoxSelectRegularTable<StoryView>( mTableModel, pTableDef, mMoveControlPanel );

        SizeableHorizontalPanel zPanel = new SizeableHorizontalPanel().stretchable();
        zPanel.add( mTable );
        zPanel.add( mMoveControlPanel );
        add( zPanel );
    }

    @Override
    protected void justLoaded() {
        super.justLoaded();
        fetchRows();
    }

    abstract protected void fetchRows();

    protected FetchRowsDataProviderCallBack<StoryView> createFetchRowsCallBack() {
        return new FetchRowsDataProviderCallBack<StoryView>() {
            @Override
            public void tooMany( long pCount ) {
                systemError( "System Error: Should not happen", //
                             "Found " + pCount + " " + mWhat + ".", //
                             "This is more than the application is willing to display." );
            }

            @Override
            public void error( String pError ) {
                systemError( "Requesting " + mWhat + " - Errored", //
                             "", //
                             "Error: " + pError );
            }

            @Override
            public void success( ImmutableArrayList<StoryView> pRows ) {
                if ( pRows.isEmpty() ) {
                    backToHome( "Nothing to " + mWhat );
                    return;
                }
                mTableModel.clear();
                mTableModel.addAll( pRows );
                Collections.sort( mTableModel );
                mTable.loadData();
                mTable.deselectAll();
                mMoveControlPanel.handleButtons( reselectAll() );
            }

            private Set<StoryView> reselectAll() {
                boolean zFound = false;
                if ( mSavedSelectedValues != null ) {
                    for ( StoryView zValue : mSavedSelectedValues ) {
                        if ( mTable.selectRow( zValue ) ) {
                            zFound = true;
                        }
                    }
                    mSavedSelectedValues = null;
                }
                return zFound ? mTable.getSelectedValues() : null;
            }
        };
    }

    @Override
    public void error( String pError ) {
        if ( Currently.isNotNullOrEmpty( pError ) ) {
            systemError( "Requested Prioritizing - Errored", //
                         "", //
                         "Error: " + pError );
        } else {
            fetchRows();
        }
    }

    @Override
    public Widget getBottomBar() {
        return null;
    }

    protected static class TableDef extends BoTableDefinition<StoryView> implements StoryViewNames,
                                                                                    DataTableStyle {
        public TableDef() {
            StoryViewMetaData zMD = StoryViewMetaData.getInstance();

            addColumn( zMD.getBoAttribute( aName ) ); // .initialWidth( FontSizer.get( TABLE_TEXT ).EMsPlus( 20, CELL_PADDING ) );
            addColumn( zMD.getBoAttribute( aDescriptionThreeLines ), "Description" ); // .initialWidth( FontSizer.get( TABLE_TEXT ).EMsPlus( 40, CELL_PADDING ) );
        }
    }

    private class MoveControlPanel extends VerticalPanel implements SelectionHandler<StoryView> {
        private final Button mBetweenButton, mUpButton, mDownButton;
        private final List<GroupMover> mGroupMovers = new ArrayList<GroupMover>();

        private MoveControlPanel( boolean pAddUpDown ) {
            mBetweenButton = Button.named( "Between" ).blue().text( "To There" ).add( new ClickHandler() {
                @Override
                public void onClick( ClickEvent event ) {
                    reprioritizeBetween();
                }
            } ).create().disable();
            mUpButton = Button.named( "Up" ).blue().text().add( new ClickHandler() {
                @Override
                public void onClick( ClickEvent event ) {
                    reprioritizeUp();
                }
            } ).create().disable();
            mDownButton = Button.named( "Down" ).blue().text().add( new ClickHandler() {
                @Override
                public void onClick( ClickEvent event ) {
                    reprioritizeDown();
                }
            } ).create().disable();

            setHorizontalAlignment( VerticalPanel.ALIGN_CENTER );
            add( new Label( "Move..." ) );
            add( new Spacer( 20 ) );
            add( mBetweenButton );
            add( new Spacer( 20 ) );
            PriorityGroup[] zGroups = PriorityGroup.values();
            for ( int i = zGroups.length; --i >= 0; ) {
                PriorityGroup zGroup = zGroups[i];
                if ( PriorityGroup.Initial != zGroup ) {
                    GroupMover zMover = new GroupMover( zGroup );
                    mGroupMovers.add( zMover );
                    add( zMover.getButton() );
                }
            }
            add( new Spacer( 20 ) );
            if ( pAddUpDown ) {
                add( mUpButton );
                add( mDownButton );
            }
        }

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

        private void sameSizeButtons() {
            if ( isAttached() ) {
                Integer zMaxWidth = getMaxControlButtonWidth();
                if ( zMaxWidth != null ) {
                    setControlButtonSameWidth( zMaxWidth );
                    return;
                }
            }
            Scheduler.get().scheduleDeferred( new Command() {
                @Override
                public void execute() {
                    sameSizeButtons();
                }
            } );
        }

        private Integer getMaxControlButtonWidth() {
            int zMaxWidth = mBetweenButton.getOffsetWidth();
            for ( Widget zWidget : getChildren() ) {
                if ( zWidget instanceof Button ) {
                    zMaxWidth = Math.max( zMaxWidth, zWidget.getOffsetWidth() );
                }
            }
            return (zMaxWidth > 30) ? zMaxWidth : null;
        }

        private void setControlButtonSameWidth( int pWidth ) {
            String zWidth = "" + pWidth;
            for ( Widget zWidget : getChildren() ) {
                if ( zWidget instanceof Button ) {
                    zWidget.setWidth( zWidth );
                }
            }
        }

        @Override
        public void onSelection( SelectionEvent<StoryView> event ) {
            handleButtons( mTable.getSelectedValues() );
        }

        private void handleButtons( Set<StoryView> pSelectedValues ) {
            boolean zAnySelected = (pSelectedValues != null) && !pSelectedValues.isEmpty();
            mBetweenButton.setEnabled( zAnySelected && betweenable( pSelectedValues ) );
            mUpButton.setEnabled( zAnySelected && upable( pSelectedValues ) );
            mDownButton.setEnabled( zAnySelected && downable( pSelectedValues ) );
            for ( GroupMover zMover : mGroupMovers ) {
                zMover.setEnable( zAnySelected, pSelectedValues );
            }
        }
    }

    private class GroupMover implements ClickHandler {
        private PriorityGroup mGroup;
        private Button mButton;

        private GroupMover( PriorityGroup pGroup ) {
            mGroup = pGroup;
            mButton = Button.named( mGroup.name() ).blue().text().add( this ).create().disable();
        }

        public Button getButton() {
            return mButton;
        }

        @Override
        public void onClick( ClickEvent event ) {
            reprioritizeToGroup( mGroup );
        }

        public void setEnable( boolean pAnySelected, Set<StoryView> pSelectedValues ) {
            mButton.setEnabled( pAnySelected && applicable( pSelectedValues ) );
        }

        private boolean applicable( Set<StoryView> pSelectedValues ) {
            for ( StoryView zStoryView : pSelectedValues ) {
                if ( mGroup != PriorityGroup.from( zStoryView.getPriority() ) ) {
                    return true;
                }
            }
            return false;
        }
    }

    abstract protected boolean betweenable( Set<StoryView> pSelectedValues );

    protected boolean upable( Set<StoryView> pSelectedValues ) {
        return !isAtEdge( pSelectedValues, 0 );
    }

    protected boolean downable( Set<StoryView> pSelectedValues ) {
        return !isAtEdge( pSelectedValues, mTableModel.size() - 1 );
    }

    protected boolean isAtEdge( Set<StoryView> pSelectedValues, int pEdge ) {
        for ( StoryView zStoryView : pSelectedValues ) {
            if ( mTableModel.indexOf( zStoryView ) == pEdge ) {
                return true;
            }
        }
        return false;
    }

    private void reprioritizeUp() {
        int zMin = mTableModel.size();
        for ( StoryView zStoryView : mTable.getSelectedValues() ) {
            zMin = Math.min( zMin, mTableModel.indexOf( zStoryView ) );
        }
        if ( zMin != mTableModel.size() ) {
            reprioritizeBetween( mSavedSelectedValues = mTable.getSelectedValues(), getStoryView( zMin - 1 ), getStoryView( zMin - 2 ) );
        }
    }

    private void reprioritizeDown() {
        int zMax = -1;
        for ( StoryView zStoryView : mTable.getSelectedValues() ) {
            zMax = Math.max( zMax, mTableModel.indexOf( zStoryView ) );
        }
        if ( zMax != -1 ) {
            reprioritizeBetween( mSavedSelectedValues = mTable.getSelectedValues(), getStoryView( zMax + 2 ), getStoryView( zMax + 1 ) );
        }
    }

    private void reprioritizeBetween( StoryView pLowerBound, StoryView pUpperBound ) {
        reprioritizeBetween( mTable.getSelectedValues(), pLowerBound, pUpperBound );
    }

    private void reprioritizeBetween( Set<StoryView> pSelectedValues, StoryView pLowerBound, StoryView pUpperBound ) {
        mDP.reprioritizeBetween( pLowerBound, pUpperBound, pSelectedValues, this );
    }

    private void reprioritizeToGroup( PriorityGroup pGroup ) {
        mDP.reprioritizeToGroup( pGroup, mTable.getSelectedValues(), this );
    }

    private StoryView getStoryView( int pIndex ) {
        return ((0 <= pIndex) && (pIndex < mTableModel.size())) ? mTableModel.get( pIndex ) : null;
    }

    abstract protected void fetchTargetBetweenRows( final DataAvailableCallBack<StoryView> pCallBack );

    private void reprioritizeBetween() {
        fetchTargetBetweenRows( this );
    }

    @Override
    public void dataAvailable( List<StoryView> pData ) // called when we can proceed with the InjectionPointSelector
    {
        if ( pData.isEmpty() ) {
            error( "There are Nothing but " + PriorityGroup.Initial + " priority Stories" );
            return;
        }
        Set<StoryView> zSelectedRows = mTable.getSelectedValues();
        List<StoryView> zNonSelectedRows = new ArrayList<StoryView>( pData.size() );
        for ( StoryView zStoryView : pData ) {
            if ( !zSelectedRows.contains( zStoryView ) ) {
                zNonSelectedRows.add( zStoryView );
            }
        }
        if ( zNonSelectedRows.isEmpty() ) {
            error( "At least one Story must not be selected" );
            return;
        }
        new InjectionPointSelectionDialog<StoryView>( "Select 'There' to Move Selected Rows", 4, zNonSelectedRows,
                                                      new InjectionPointSelector.Callback<StoryView>() {
                                                          @Override
                                                          public void injectBetween( StoryView pLowerBound, StoryView pUpperBound ) {
                                                              reprioritizeBetween( pLowerBound, pUpperBound );
                                                          }
                                                      } ).show();
    }
}