package org.litesoft.prioritizer.client.support;

public enum PriorityGroup
{
    Initial( 0 ),
    Low( 2000, 0, false ),
    MediumLow( 4000, 2000 ),
    Medium( 6000, 4000 ),
    MediumHigh( 8000, 6000 ),
    High( 9990, 8000 ),
    Critical( 10000, 9990 );

    public static final float TOP_EXCLUSIVE_VALUE = 10000f;
    public static final float BOTTOM_INCLUSIVE_VALUE = 0f;

    private float mRangeTop;
    private boolean mTopInclusive;
    private float mRangeBottom;
    private boolean mBottomInclusive;

    public PriorityGroup higherGroup()
    {
        return (Critical == this) ? this : values()[ordinal() + 1];
    }

    public static PriorityGroup from( Float pValue )
    {
        if ( (pValue == null) || (pValue < BOTTOM_INCLUSIVE_VALUE) )
        {
            return Initial;
        }
        for ( PriorityGroup zValue : values() )
        {
            if ( zValue.isInRange( pValue ) )
            {
                return zValue;
            }
        }
        return Critical;
    }

    PriorityGroup( float pRangeTop, boolean pTopInclusive, float pRangeBottom, boolean pBottomInclusive )
    {
        mRangeTop = pRangeTop;
        mTopInclusive = pTopInclusive;
        mRangeBottom = pRangeBottom;
        mBottomInclusive = pBottomInclusive;
    }

    PriorityGroup( float pRangeTop, float pRangeBottom, boolean pBottomInclusive )
    {
        this( pRangeTop, false, pRangeBottom, pBottomInclusive );
    }

    PriorityGroup( float pRangeTop, float pRangeBottom )
    {
        this( pRangeTop, pRangeBottom, true );
    }

    PriorityGroup( float pRangeValue )
    {
        this( pRangeValue, true, pRangeValue, true );
    }

    public float getRangeTop()
    {
        return mRangeTop;
    }

    public boolean isTopInclusive()
    {
        return mTopInclusive;
    }

    public float getRangeBottom()
    {
        return mRangeBottom;
    }

    public boolean isBottomInclusive()
    {
        return mBottomInclusive;
    }

    public float getMidRange()
    {
        return (getRangeTop() + getRangeBottom()) / 2;
    }

    public boolean isInRange( float pValue )
    {
        return isNotTooSmall( pValue ) && isNotTooLarge( pValue );
    }

    public Range getRangeAssumingExclusive()
    {
        return new Range( getRangeBottom(), getRangeTop() );
    }

    public static PriorityGroup deNull( PriorityGroup pGroup, PriorityGroup pDefault )
    {
        return (pGroup != null) ? pGroup : pDefault;
    }

    /**
     * @param pValues - are !null & are NOT to be decending in value between any two sequential pairs
     */
    public static float[] rePrioritizeBetween( Float pBottomExclusive, Float pTopExclusive, Float... pValues )
    {
        return new Range( pBottomExclusive, pTopExclusive ).update().rePrioritizeBetween( pValues );
    }

    private boolean isNotTooLarge( float pValue )
    {
        return mTopInclusive ? (pValue <= mRangeTop) : (pValue < mRangeTop);
    }

    private boolean isNotTooSmall( float pValue )
    {
        return mBottomInclusive ? (mRangeBottom <= pValue) : (mRangeBottom < pValue);
    }

    public static class Range
    {
        private float mBottomExclusive, mTopExclusive;

        public Range( Float pBottomExclusive, Float pTopExclusive )
        {
            mBottomExclusive = normalize( pBottomExclusive, BOTTOM_INCLUSIVE_VALUE );
            mTopExclusive = normalize( pTopExclusive, TOP_EXCLUSIVE_VALUE );

            if ( mTopExclusive <= mBottomExclusive )
            {
                throw new IllegalArgumentException( "Bottom (" + mBottomExclusive + ") must be less than Top (" + mTopExclusive + ")" );
            }
        }

        private static float normalize( Float pValue, float pDefault )
        {
            return (pValue != null) && (BOTTOM_INCLUSIVE_VALUE <= pValue) && (pValue < TOP_EXCLUSIVE_VALUE) ? pValue : pDefault;
        }

        public float getTopExclusive()
        {
            return mTopExclusive;
        }

        public float getBottomExclusive()
        {
            return mBottomExclusive;
        }

        public Range update()
        {
            PriorityGroup zGroup = from( mBottomExclusive );
            if ( mBottomExclusive == zGroup.getRangeTop() )
            {
                zGroup = zGroup.higherGroup();
                mBottomExclusive = zGroup.getRangeBottom();
            }
            if ( zGroup != from( mTopExclusive ) )
            {
                mTopExclusive = zGroup.getRangeTop();
            }
            return this;
        }

        /**
         * @param pValues - are !null & are NOT to be decending in value between any two sequential pairs
         */
        public float[] rePrioritizeBetween( Float... pValues )
        {
            int zValuesLength = (pValues == null) ? 0 : pValues.length;
            float[] rvs = new float[zValuesLength];
            float zDelta = (mTopExclusive - mBottomExclusive) / (zValuesLength + 1);
            float zRunningValue = mTopExclusive;
            for ( int i = 0; i < zValuesLength; i++ )
            {
                rvs[i] = zRunningValue -= zDelta;
            }
            return rvs;
        }
    }
}