// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.typeutils;

@SuppressWarnings({"unchecked"})
public class Compare
{
    private int mResult;

    protected Compare( int pResult )
    {
        mResult = pResult;
    }

    /**
     * Compares pA object with the pB object for order.  Nulls rise!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is less than, equal to, or greater than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int nullsOK( Comparable pThis, Comparable pThem )
    {
        return firstNullsOK( pThis, pThem ).result();
    }

    /**
     * Compares pA object with the pB object for Ascending Order.  Nulls rise!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is less than, equal to, or greater than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int ascending( Comparable pThis, Comparable pThem )
    {
        return firstNullsOK( pThis, pThem ).result();
    }

    /**
     * Compares pA object with the pB object for Descending Order.  Nulls sink!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is greater than, equal to, or less than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int descending( Comparable pThis, Comparable pThem )
    {
        return ascending( pThem, pThis ); // Note param flipped order!
    }

    public static boolean firstLessThanSecond( Comparable pFirst, Comparable pSecond )
    {
        //noinspection unchecked
        return pFirst.compareTo( pSecond ) < 0;
    }

    public static boolean firstGreaterThanSecond( Comparable pFirst, Comparable pSecond )
    {
        //noinspection unchecked
        return pFirst.compareTo( pSecond ) > 0;
    }

    public final int result()
    {
        return mResult;
    }

    private static final Compare NEGATIVE = new Compare( -1 );
    private static final Compare POSITIVE = new Compare( 1 );
    private static final Compare ZERO = new Compare( 0 )
    {
        private Compare vector( int pCompareTo )
        {
            return (pCompareTo == 0) ? this : (pCompareTo < 0) ? NEGATIVE : POSITIVE;
        }

        @Override
        public Compare then( Comparable pA, Comparable pB )
        {
            if ( pA == pB ) // same or both null
            {
                return this;
            }
            // noinspection unchecked
            return vector( (pA != null) ? pA.compareTo( pB ) : -(pB.compareTo( pA )) );
        }

        @Override
        public Compare thenNullsOK( Comparable pA, Comparable pB )
        {
            if ( pA == pB ) // same or both null
            {
                return this;
            }
            return (pA == null) ? NEGATIVE : (pB == null) ? POSITIVE : vector( pA.compareTo( pB ) );
        }

        @Override
        public Compare then( boolean pA, boolean pB )
        {
            return (pA == pB) ? this : then( (pA ? 1 : 0), (pB ? 1 : 0) );
        }

        @Override
        public Compare then( int pA, int pB )
        {
            return vector( pA - pB );
        }
    };

    public static Compare first( Comparable pA, Comparable pB )
    {
        return ZERO.then( pA, pB );
    }

    public Compare then( Comparable pA, Comparable pB )
    {
        return this;
    }

    /**
     * Nulls Rise
     */
    public static Compare firstNullsOK( Comparable pA, Comparable pB )
    {
        return ZERO.thenNullsOK( pA, pB );
    }

    /**
     * Nulls Rise
     */
    public Compare thenNullsOK( Comparable pA, Comparable pB )
    {
        return this;
    }

    public static Compare first( boolean pA, boolean pB )
    {
        return ZERO.then( pA, pB );
    }

    public Compare then( boolean pA, boolean pB )
    {
        return this;
    }

    public static Compare first( int pA, int pB )
    {
        return ZERO.then( pA, pB );
    }

    public Compare then( int pA, int pB )
    {
        return this;
    }
}