// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.widgets.nonpublic;

import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;

import java.util.*;

import static org.litesoft.core.simpletypes.nonpublic.EqualSupport.*;

public class InjectionPointSelectorController<T extends Synopsisable> {
    public interface View<U extends Synopsisable> {
        public void injectBetween( U pLowerBound, U pUpperBound );

        public void show( DrillDownSet pDrillDownSet );

        public void notEnoughVisibleEntries();
    }

    public static abstract class ViewEntry<U extends Synopsisable> {
        private String mText;

        protected ViewEntry( String pText ) {
            mText = Strings.assertNotNullNotEmpty( "Text", pText );
        }

        public U getUpperReference() {
            return null;
        }

        public U getLowerReference() {
            return null;
        }

        /**
         * If Selectable, then is NOT a reference, but one of: Between, There, Top, or Bottom
         */
        public boolean isSelectable() {
            return false;
        }

        public boolean isBetween() {
            return false;
        }

        public boolean isSelected() {
            return false;
        }

        public final String getText() {
            return mText;
        }

        @Override
        public boolean equals( Object o ) {
            if ( this == o ) {
                return true;
            }
            if ( (o == null) || !this.getClass().getName().equals( o.getClass().getName() ) ) {
                return false;
            }
            ViewEntry them = (ViewEntry) o;
            return Objects.areEqual( this.getText(), them.getText() ) && //
                   Objects.areEqual( this.getUpperReference(), them.getUpperReference() ) && //
                   Objects.areEqual( this.getLowerReference(), them.getLowerReference() );
        }

        @Override
        public int hashCode() {
            return hashCodeEm( calcHashCode( getText() ), //
                               calcHashCode( getUpperReference() ), //
                               calcHashCode( getLowerReference() ) );
        }
    }

    public static class ViewSet {
        private List<ViewEntry> mEntries;

        public ViewSet( List<ViewEntry> pEntries ) {
            mEntries = pEntries;
        }

        public ViewSet( ViewEntry... pEntries ) {
            mEntries = Arrays.asList( pEntries );
        }

        public ViewEntry[] getEntries() {
            return mEntries.toArray( new ViewEntry[mEntries.size()] );
        }

        @Override
        public String toString() {
            return mEntries.toString();
        }

        @Override
        public boolean equals( Object o ) {
            if ( this == o ) {
                return true;
            }
            if ( (o == null) || !this.getClass().getName().equals( o.getClass().getName() ) ) {
                return false;
            }
            ViewSet them = (ViewSet) o;
            return Objects.areEqual( this.mEntries, them.mEntries );
        }

        @Override
        public int hashCode() {
            return calcHashCode( mEntries );
        }
    }

    public static class DrillDownSet {
        private ViewSet mHomeSet;
        private boolean mSomethingBetweenHomeAndPreviousSets;
        private ViewSet mPreviousSet;
        private ViewSet mCurrentSet;

        public DrillDownSet( ViewSet pHomeSet, boolean pSomethingBetweenHomeAndPreviousSets, ViewSet pPreviousSet, ViewSet pCurrentSet ) {
            mHomeSet = pHomeSet;
            mSomethingBetweenHomeAndPreviousSets = pSomethingBetweenHomeAndPreviousSets;
            mPreviousSet = pPreviousSet;
            mCurrentSet = pCurrentSet;
        }

        public ViewSet getHomeSet() {
            return mHomeSet;
        }

        public boolean isSomethingBetweenHomeAndPreviousSets() {
            return mSomethingBetweenHomeAndPreviousSets;
        }

        public ViewSet getPreviousSet() {
            return mPreviousSet;
        }

        public ViewSet getCurrentSet() {
            return mCurrentSet;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder( "DrillDownSet:" );
            add( sb, "Home", mHomeSet );
            if ( mSomethingBetweenHomeAndPreviousSets ) {
                sb.append( "\n   ..." );
            }
            add( sb, "Prev", mPreviousSet );
            add( sb, "Curr", mCurrentSet );
            return sb.toString();
        }

        private void add( StringBuilder pSb, String pWhat, ViewSet pSet ) {
            if ( pSet != null ) {
                pSb.append( '\n' ).append( pWhat ).append( ": " ).append( pSet );
            }
        }

        @Override
        public boolean equals( Object o ) {
            if ( this == o ) {
                return true;
            }
            if ( (o == null) || !this.getClass().getName().equals( o.getClass().getName() ) ) {
                return false;
            }
            DrillDownSet them = (DrillDownSet) o;
            return (this.mSomethingBetweenHomeAndPreviousSets == them.mSomethingBetweenHomeAndPreviousSets) && //
                   Objects.areEqual( this.mHomeSet, them.mHomeSet ) && //
                   Objects.areEqual( this.mPreviousSet, them.mPreviousSet ) && //
                   Objects.areEqual( this.mCurrentSet, them.mCurrentSet );
        }

        @Override
        public int hashCode() {
            return hashCodeEm( calcHashCode( mHomeSet ), //
                               calcHashCode( mPreviousSet ), //
                               calcHashCode( mCurrentSet ) );
        }
    }

    static abstract class SelectionPointEntry<U extends Synopsisable> extends ViewEntry<U> {
        private boolean mSelected;
        private U mUpperReference;
        private U mLowerReference;

        protected SelectionPointEntry( boolean pSelected, String pText, U pUpperReference, U pLowerReference ) {
            super( pText );
            mSelected = pSelected;
            mUpperReference = pUpperReference;
            mLowerReference = pLowerReference;
        }

        @Override
        public U getUpperReference() {
            return mUpperReference;
        }

        @Override
        public U getLowerReference() {
            return mLowerReference;
        }

        @Override
        public boolean isSelectable() {
            return true;
        }

        @Override
        public boolean isSelected() {
            return mSelected;
        }

        @Override
        public String toString() {
            return Strings.replace( getText(), '\n', "\\n" ) + ":" + addXtra();
        }

        protected String addXtra() {
            return "";
        }
    }

    @SuppressWarnings("EqualsAndHashcode")
    static class Between<U extends Synopsisable> extends SelectionPointEntry<U> {
        private Between( boolean pSelected, U pUpperReference, U pLowerReference ) {
            super( pSelected, "Between", pUpperReference, pLowerReference );
        }

        public static <V extends Synopsisable> Between<V> create( boolean pSelected, V pUpperReference, V pLowerReference ) {
            return new Between<V>( pSelected, pUpperReference, pLowerReference );
        }

        public Between<U> copyAsSelected() {
            return isSelected() ? this : create( true, getUpperReference(), getLowerReference() );
        }

        @Override
        public boolean isBetween() {
            return true;
        }

        protected String addXtra() {
            return (isSelected() ? "(?Y)" : "(?N)");
        }

        @Override
        @SuppressWarnings({"EqualsWhichDoesntCheckParameterClass"})
        public boolean equals( Object o ) {
            return super.equals( o ) && (this.isSelected() == ((Between) o).isSelected());
        }
    }

    static class There<U extends Synopsisable> extends SelectionPointEntry<U> {
        private There( U pUpperReference, U pLowerReference ) {
            super( false, "There", pUpperReference, pLowerReference );
        }

        public static <V extends Synopsisable> There<V> create( V pUpperReference, V pLowerReference ) {
            return new There<V>( pUpperReference, pLowerReference );
        }
    }

    static class Top<U extends Synopsisable> extends SelectionPointEntry<U> {
        private Top( U pLowerReference ) {
            super( false, "Top\n(There)", null, pLowerReference );
        }

        public static <V extends Synopsisable> Top<V> create( V pLowerReference ) {
            return new Top<V>( pLowerReference );
        }
    }

    static class Bottom<U extends Synopsisable> extends SelectionPointEntry<U> {
        private Bottom( U pUpperReference ) {
            super( false, "Bottom\n(There)", pUpperReference, null );
        }

        public static <V extends Synopsisable> Bottom<V> create( V pUpperReference ) {
            return new Bottom<V>( pUpperReference );
        }
    }

    static class Reference<U extends Synopsisable> extends ViewEntry<U> {
        private Reference( int pLines, U pReference ) {
            super( pReference.getSynopsis( pLines ) );
        }

        public static <V extends Synopsisable> Reference<V> create( int pLines, V pReference ) {
            return new Reference<V>( pLines, pReference );
        }

        @Override
        public String toString() {
            return "Ref: " + Strings.replace( getText(), '\n', "\\n" );
        }
    }

    private int mSynopsisLines;
    private List<T> mInjectIns;
    private View<T> mView;
    private int mCurrentEntriesVisible = -1;
    private List<Between<T>> mSelectedBetweens = new ArrayList<Between<T>>();

    public InjectionPointSelectorController( int pSynopsisLines, List<T> pInjectIns, View<T> pView ) {
        mSynopsisLines = pSynopsisLines;
        mInjectIns = pInjectIns;
        mView = pView;
    }

    public InjectionPointSelectorController( int pSynopsisLines, View<T> pView, T... pInjectIns ) {
        this( pSynopsisLines, Arrays.asList( pInjectIns ), pView );
    }

    public void updateForEntriesVisible( int pCount ) {
        if ( mCurrentEntriesVisible != pCount ) {
            DrillDownSet zDrillDownSet = updateDrillDownSetWhenEntriesVisibleChanges( pCount, mSelectedBetweens );
            if ( zDrillDownSet == null ) {
                mView.notEnoughVisibleEntries();
                return;
            }
            mCurrentEntriesVisible = pCount;
            mView.show( zDrillDownSet );
        }
    }

    public void homeSelected() {
        DrillDownSet zDrillDownSet = updateDrillDownSetWhenEntriesVisibleChanges( mCurrentEntriesVisible, mSelectedBetweens );
        mView.show( zDrillDownSet );
    }

    public void previousSelected() {
        mSelectedBetweens.remove( mSelectedBetweens.size() - 1 );
        DrillDownSet zDrillDownSet = updateDrillDownSetWhenSelectedBetweensChange( mCurrentEntriesVisible, mSelectedBetweens );
        mView.show( zDrillDownSet );
    }

    public void viewSelected( ViewEntry<T> pEntry ) {
        Objects.assertNotNull( "Entry", pEntry );
        if ( pEntry.isBetween() ) {
            mSelectedBetweens.add( ((Between<T>) pEntry).copyAsSelected() );
            DrillDownSet zDrillDownSet = updateDrillDownSetWhenSelectedBetweensChange( mCurrentEntriesVisible, mSelectedBetweens );
            mView.show( zDrillDownSet );
            return;
        }
        if ( pEntry.isSelectable() ) {
            mView.injectBetween( pEntry.getLowerReference(), pEntry.getUpperReference() );
            return;
        }
        throw new IllegalArgumentException( "Can not 'viewSelected' for type '" + Objects.justSimpleName( pEntry ) + "': " + pEntry );
    }

    /**
     * Update the pLastDrillDownSet based on the new pCount (maximum Entries per ViewSet) (public for Testing)
     *
     * @return null means that pCount was too small!
     */
    public DrillDownSet updateDrillDownSetWhenEntriesVisibleChanges( int pCount, List<Between<T>> pSelectedBetweens ) {
        if ( -1 == (pCount = checkIfNotEnoughVisibleEntries( makeOdd( pCount ) )) ) {
            return null;
        }
        pSelectedBetweens.clear();

        List<ViewSet> zViewSets = buildViewSets( pCount, pSelectedBetweens );
        return new DrillDownSet( null, false, null, zViewSets.get( 0 ) );
    }

    /**
     * Update the pLastDrillDownSet based on the new pCount (maximum Entries per ViewSet) (public for Testing)
     *
     * @return null means that pCount was too small!
     */
    public DrillDownSet updateDrillDownSetWhenSelectedBetweensChange( int pCount, List<Between<T>> pSelectedBetweens ) {
        List<ViewSet> zViewSets = buildViewSets( makeOdd( pCount ), pSelectedBetweens );
        switch ( zViewSets.size() ) {
            case 1:
                return new DrillDownSet( null, false, null, zViewSets.get( 0 ) );
            case 2:
                return new DrillDownSet( zViewSets.get( 0 ), false, null, zViewSets.get( 1 ) );
            case 3:
                return new DrillDownSet( zViewSets.get( 0 ), false, zViewSets.get( 1 ), zViewSets.get( 2 ) );
            default:
                return new DrillDownSet( zViewSets.get( 0 ), true, zViewSets.get( zViewSets.size() - 2 ), zViewSets.get( zViewSets.size() - 1 ) );
        }
    }

    private int checkIfNotEnoughVisibleEntries( int pCount ) {
        return ((pCount >= 5) || // 5 is enough for anything (more is better)
                ((pCount == 3) && (mInjectIns.size() == 1))) ? // Special Case of just 1 InjectIn?
               pCount : // pCount is OK
               -1; // indicate pCount too small
    }

    private int makeOdd( int pCount ) {
        return ((pCount & 1) == 0) ? // Is Even?
               pCount - 1 : // Even, make Odd!
               pCount; // Already Odd
    }

    private Between<T> getCurrentSelectedBetween( List<Between<T>> pSelectedBetweens, int pCurrentIndex ) {
        return (pCurrentIndex < pSelectedBetweens.size()) ? pSelectedBetweens.get( pCurrentIndex ) : null;
    }

    private boolean isSelected( Between<T> pSelectedBetween, T pLast, T pCurr ) {
        return (pSelectedBetween != null) && (pLast == pSelectedBetween.getUpperReference()) && (pCurr == pSelectedBetween.getLowerReference());
    }

    private List<ViewSet> buildViewSets( int pCount, List<Between<T>> pSelectedBetweens ) {
        List<ViewSet> zViewSets = new ArrayList<ViewSet>();

        buildHomeViewSet( zViewSets, pCount, pSelectedBetweens );

        return zViewSets;
    }

    private void buildHomeViewSet( List<ViewSet> pViewSets, int pCount, List<Between<T>> pSelectedBetweens ) {
        Between<T> zSelectedBetween = getCurrentSelectedBetween( pSelectedBetweens, 0 );

        int zInjectInsToAdd = mInjectIns.size() - 1;
        int zAvailableBetweenBuckets = Math.min( zInjectInsToAdd, (pCount - 3) / 2 );

        //        System.out.println( "buildHomeViewSett( " + zSelectedBetween + " ): " + //
        //                            pCount + " ( " + mInjectIns.size() + " ) " + zInjectInsToAdd + " | " + zAvailableBetweenBuckets );

        ArrayList<ViewEntry> zEntries = new ArrayList<ViewEntry>( pCount );
        pViewSets.add( new ViewSet( zEntries ) );

        int zCurrNdx = 0;
        int zThru = mInjectIns.size() - 1;
        T zCurrT = mInjectIns.get( zCurrNdx );
        zEntries.add( Top.create( zCurrT ) );

        while ( zCurrNdx < zThru ) {
            zEntries.add( Reference.create( mSynopsisLines, zCurrT ) );
            int zLastNdx = zCurrNdx;
            T zLastT = zCurrT;
            int zHowMany = zInjectInsToAdd / zAvailableBetweenBuckets;
            // System.out.print( "   zInjectInsToAdd / zAvailableBetweenBuckets ==> " + zInjectInsToAdd + " / " + zAvailableBetweenBuckets + " = " + zHowMany );
            zInjectInsToAdd -= zHowMany;
            zCurrNdx += zHowMany;
            zCurrT = mInjectIns.get( zCurrNdx );
            if ( zHowMany == 1 ) {
                // System.out.println( "   Add There 1" );
                zEntries.add( There.create( zLastT, zCurrT ) );
            } else {
                // System.out.println( "   Add Between " + zHowMany );
                if ( isSelected( zSelectedBetween, zLastT, zCurrT ) ) {
                    zEntries.add( zSelectedBetween );
                    buildSubsequentViewSet( pViewSets, pCount, zLastNdx, zCurrNdx, pSelectedBetweens, 1 );
                } else {
                    zEntries.add( Between.create( false, zLastT, zCurrT ) );
                }
            }
            zAvailableBetweenBuckets--;
        }
        zEntries.add( Reference.create( mSynopsisLines, zCurrT ) );
        zEntries.add( Bottom.create( zCurrT ) );
    }

    private void buildSubsequentViewSet( List<ViewSet> pViewSets, int pCount, int zUpperNdx, int zLowerNdx, List<Between<T>> pSelectedBetweens,
                                         int pCurrentIndex ) {
        Between<T> zSelectedBetween = getCurrentSelectedBetween( pSelectedBetweens, pCurrentIndex );

        int zInjectInsToAdd = zLowerNdx - zUpperNdx;
        int zAvailableBetweenBuckets = Math.min( zInjectInsToAdd, pCount / 2 );

        //        System.out.println( "  buildSubsequentViewSet( " + pCurrentIndex + " => " + zSelectedBetween + " ): " + //
        //                            pCount + " ( " + zUpperNdx + ", " + zLowerNdx + " ) " + zInjectInsToAdd + " | " + zAvailableBetweenBuckets );

        ArrayList<ViewEntry> zEntries = new ArrayList<ViewEntry>( pCount );
        pViewSets.add( new ViewSet( zEntries ) );

        int zCurrNdx = zUpperNdx;
        int zThru = zLowerNdx;
        T zCurrT = mInjectIns.get( zCurrNdx );

        while ( zCurrNdx < zThru ) {
            zEntries.add( Reference.create( mSynopsisLines, zCurrT ) );
            int zLastNdx = zCurrNdx;
            T zLastT = zCurrT;
            int zHowMany = zInjectInsToAdd / zAvailableBetweenBuckets;
            // System.out.print( "    zInjectInsToAdd / zAvailableBetweenBuckets ==> " + zInjectInsToAdd + " / " + zAvailableBetweenBuckets + " = " + zHowMany );
            zInjectInsToAdd -= zHowMany;
            zCurrNdx += zHowMany;
            zCurrT = mInjectIns.get( zCurrNdx );
            if ( zHowMany == 1 ) {
                // System.out.println( "   Add There 1" );
                zEntries.add( There.create( zLastT, zCurrT ) );
            } else {
                // System.out.println( "   Add Between " + zHowMany );
                if ( isSelected( zSelectedBetween, zLastT, zCurrT ) ) {
                    zEntries.add( zSelectedBetween );
                    buildSubsequentViewSet( pViewSets, pCount, zLastNdx, zCurrNdx, pSelectedBetweens, pCurrentIndex + 1 );
                } else {
                    zEntries.add( Between.create( false, zLastT, zCurrT ) );
                }
            }
            zAvailableBetweenBuckets--;
        }
        zEntries.add( Reference.create( mSynopsisLines, zCurrT ) );
    }
}