// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.core.util;

import org.litesoft.commonfoundation.base.*;

public class SortableBuilder {
    public static final String INITIAL_VALUE = "m";

    private static final char SORT_BETWEEN_LOWEST = 'a';
    private static final char SORT_BETWEEN_HIGHEST = 'z';

    /**
     * For creating the new Insert to Front Value.
     *
     * @param pCurrentFirst !null & !""
     *
     * @return the new First Value unless the pCurrentFirst is all 'SORT_BETWEEN_LOWEST's then the pCurrentFirst + "m"
     */
    public static String newFirstBefore( String pCurrentFirst ) {
        return createBetween( ConstantCharSource.LOWEST, //
                              new StringCharSource( "CurrentFirst", pCurrentFirst, SORT_BETWEEN_HIGHEST ) );
    }

    /**
     * For creating the new Insert Between Value.
     *
     * @param pCurrentBefore !null & !"" & must be <= pCurrentAfter
     * @param pCurrentAfter  !null & !"" & must be >= pCurrentBefore
     *
     * @return the Between value or if they are the same then pCurrentBefore
     */
    public static String newBetween( String pCurrentBefore, String pCurrentAfter ) {
        StringCharSource low = new StringCharSource( "CurrentBefore", pCurrentBefore, SORT_BETWEEN_LOWEST );
        StringCharSource high = new StringCharSource( "CurrentAfter", pCurrentAfter, SORT_BETWEEN_HIGHEST );

        if ( pCurrentBefore.equals( pCurrentAfter ) ) {
            return pCurrentBefore;
        }
        if ( Compare.firstGreaterThanSecond( pCurrentBefore, pCurrentAfter ) ) {
            throw new IllegalArgumentException( "Out of order: " + pCurrentBefore + " , " + pCurrentAfter );
        }
        return createBetween( low, high );
    }

    /**
     * For creating the new Append to End value.
     *
     * @param pCurrentLast !null & !""
     *
     * @return the new Last Value
     */
    public static String newLastAfter( String pCurrentLast ) {
        return createBetween( new StringCharSource( "CurrentLast", pCurrentLast, SORT_BETWEEN_LOWEST ), //
                              ConstantCharSource.HIGHEST );
    }

    private static String createBetween( CharSource pLow, CharSource pHigh ) {
        StringBuilder between = new StringBuilder();

        char low = pLow.nextChar();
        char high = pHigh.nextChar();
        while ( low == high ) {
            between.append( low );
            low = pLow.nextChar();
            high = pHigh.nextChar();
        }
        if ( high - low == 1 ) {
            do {
                between.append( low );
                low = pLow.nextChar();
                high = SORT_BETWEEN_HIGHEST;
            }
            while ( low == high );
        }
        char c = (char) (((high - low) / 2) + low);
        between.append( c );
        return between.toString();
    }

    private interface CharSource {
        char nextChar();
    }

    private static class StringCharSource implements CharSource {
        private String mString;
        private char mBeyoundEnd;
        private int mIndex = 0;

        public StringCharSource( String pWhat, String pString, char pBeyoundEnd ) {
            mString = Confirm.significant( pWhat, pString );
            mBeyoundEnd = pBeyoundEnd;
        }

        @Override
        public char nextChar() {
            return (mIndex < mString.length()) ? mString.charAt( mIndex++ ) : mBeyoundEnd;
        }
    }

    private static class ConstantCharSource implements CharSource {
        public static final CharSource LOWEST = new ConstantCharSource( SORT_BETWEEN_LOWEST );
        public static final CharSource HIGHEST = new ConstantCharSource( SORT_BETWEEN_HIGHEST );

        private char mChar;

        private ConstantCharSource( char pChar ) {
            mChar = pChar;
        }

        @Override
        public char nextChar() {
            return mChar;
        }
    }
}