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

import org.litesoft.commonfoundation.base.*;

import junit.framework.*;

public class NewerByTest extends TestCase
{
    public static TestSuite suite()
    {
        return new TestSuite( NewerByTest.class );
    }

    public NewerByTest( String name )
    {
        super( name );
    }

    public static void main( String[] args )
    {
        junit.textui.TestRunner.run( suite() );
    }

    public void test_nulls()
    {
        Long zMillis = System.currentTimeMillis();
        rt_nulls( null, null );
        rt_nulls( null, zMillis );
        rt_nulls( zMillis, null );
    }

    private void rt_nulls( Long pFromTimeMillis, Long pToTimeMillis )
    {
        checkRT( pFromTimeMillis, pToTimeMillis, false, "???" );
    }

    public void test_Same()
    {
        rt_Same( Long.MIN_VALUE );
        rt_Same( -System.currentTimeMillis() );
        rt_Same( -1 );
        rt_Same( 0 );
        rt_Same( 1 );
        rt_Same( System.currentTimeMillis() );
        rt_Same( Long.MAX_VALUE );
    }

    private void rt_Same( long pTimeMillis )
    {
        checkRT( pTimeMillis, pTimeMillis, false, "No Difference" );
    }

    public void test_TooBig()
    {
        rt_MoreThanYear( Long.MIN_VALUE, Long.MAX_VALUE );
        rt_MoreThanYear( Long.MAX_VALUE, Long.MIN_VALUE );
    }

    public void test_MoreThanYear()
    {
        assertEquals( NewerBy.MILLISECS_IN_YEAR, (long) (365.242 * NewerBy.MILLISECS_IN_DAY) );
        long zMoreThanYear = NewerBy.MILLISECS_IN_YEAR + 1;

        rt_MoreThanYear( 0L, Long.MAX_VALUE );
        rt_MoreThanYear( Long.MAX_VALUE - zMoreThanYear, Long.MAX_VALUE );

        rt_MoreThanYear( Long.MIN_VALUE, 0L );
        rt_MoreThanYear( Long.MIN_VALUE, Long.MIN_VALUE + zMoreThanYear );

        rtSet_MoreThanYear( zMoreThanYear );
    }

    private void rtSet_MoreThanYear( long pTimeMillis )
    {
        rt_MoreThanYear( 0L, pTimeMillis );
        rt_MoreThanYear( -pTimeMillis, 0L );

        Long zMillis = System.currentTimeMillis();
        rt_MoreThanYear( zMillis, zMillis + pTimeMillis );
        rt_MoreThanYear( -zMillis, -(zMillis + pTimeMillis) );
    }

    private void rt_MoreThanYear( long pFromTimeMillis, long pToTimeMillis )
    {
        checkWithSuffix( pFromTimeMillis, pToTimeMillis, "more than a year" );
    }

    public void test_Months()
    {
        assertEquals( NewerBy.MILLISECS_IN_SHORT_MONTH, 28 * NewerBy.MILLISECS_IN_DAY );
        assertEquals( NewerBy.MILLISECS_IN_LONG_MONTH, 31 * NewerBy.MILLISECS_IN_DAY );
        assertEquals( NewerBy.MILLISECS_IN_AVERAGE_MONTH, NewerBy.MILLISECS_IN_YEAR / 12 );

        rtSet( (long) (2.6 * NewerBy.MILLISECS_IN_AVERAGE_MONTH), "about 3 months" );
        rtSet( NewerBy.MILLISECS_IN_TWO_AVERAGE_MONTHS, "about 2 months" );
        rtSet( NewerBy.MILLISECS_IN_LONG_MONTH + 1, "more than a month" );
        rtSet( NewerBy.MILLISECS_IN_SHORT_MONTH + 1, "about a month" );
    }

    public void test_Days()
    {
        assertEquals( NewerBy.MILLISECS_IN_DAY, 24 * NewerBy.MILLISECS_IN_HOUR );
        assertEquals( NewerBy.MILLISECS_IN_SHORT_MONTH, 28 * NewerBy.MILLISECS_IN_DAY );
        rtSuperSet( 28, "day", NewerBy.MILLISECS_IN_DAY );
    }

    public void test_Hours()
    {
        assertEquals( NewerBy.MILLISECS_IN_HOUR, 60 * NewerBy.MILLISECS_IN_MIN );
        rtSuperSet( 24, "hour", NewerBy.MILLISECS_IN_HOUR );
    }

    public void test_Minutes()
    {
        assertEquals( NewerBy.MILLISECS_IN_MIN, 60 * NewerBy.MILLISECS_IN_SEC );
        rtSuperSet( 60, "minute", NewerBy.MILLISECS_IN_MIN );
    }

    public void test_Seconds()
    {
        assertEquals( NewerBy.MILLISECS_IN_SEC, 1000 );
        rtSuperSet( 60, "second", NewerBy.MILLISECS_IN_SEC );
    }

    public void test_MilliSecs()
    {
        int pFrom = 1000;
        int zDelta = (pFrom - 3) / 5;
        for ( int i = 0; i < 4; i++ )
        {
            rtMilliSec( pFrom );
            pFrom -= zDelta;
        }
        rtMilliSec( 3 );
        rtMilliSec( 2 );
        rtMilliSec( 1 );
    }

    private void rtMilliSec( long pTimeMillis )
    {
        rtSet( pTimeMillis, pTimeMillis + "ms" );
    }

    private void rtSuperSet( int pFrom, String pWhat, long pMillisecsIn )
    {
        int zDelta = (pFrom - 3) / 5;
        for ( int i = 0; i < 4; i++ )
        {
            rtSet( pFrom * pMillisecsIn, "about " + pFrom + " " + pWhat + "s" );
            pFrom -= zDelta;
        }
        rtSet( 3 * pMillisecsIn, "about 3 " + pWhat + "s" );
        rtSet( (long) (2.6 * pMillisecsIn), "about 3 " + pWhat + "s" );
        rtSet( 2 * pMillisecsIn, "about 2 " + pWhat + "s" );
        rtSet( (long) (1.9 * pMillisecsIn), "more than a " + pWhat );
        rtSet( pMillisecsIn + 1, "more than a " + pWhat );
    }

    private void rtSet( long pTimeMillis, String pMessageSuffix )
    {
        checkWithSuffix( 0L, pTimeMillis, pMessageSuffix );
        checkWithSuffix( -pTimeMillis, 0L, pMessageSuffix );

        Long zMillis = System.currentTimeMillis();
        checkWithSuffix( zMillis, zMillis + pTimeMillis, pMessageSuffix );
        checkWithSuffix( -zMillis, -(zMillis + pTimeMillis), pMessageSuffix );
    }

    private void checkWithSuffix( long pFromTimeMillis, long pToTimeMillis, String pMessageSuffix )
    {
        boolean zNewer = (pToTimeMillis > pFromTimeMillis);
        checkRT( pFromTimeMillis, pToTimeMillis, zNewer, (zNewer ? "Newer" : "Older") + " by " + pMessageSuffix );
    }

    private void checkRT( Long pFromTimeMillis, Long pToTimeMillis, boolean pNewer, String pExpectedToString )
    {
        NewerBy zNewerBy = new NewerBy( pFromTimeMillis, pToTimeMillis );
        checkLongs( pFromTimeMillis, zNewerBy.getFromTimeMillis() );
        checkLongs( pToTimeMillis, zNewerBy.getToTimeMillis() );
        if ( pNewer )
        {
            assertTrue( zNewerBy.isNewer() );
        }
        else
        {
            assertFalse( zNewerBy.isNewer() );
        }
        assertEquals( pExpectedToString, zNewerBy.toString() );
    }

    private void checkLongs( Long pExpected, Long pActual )
    {
        if ( pExpected == null )
        {
            assertNull( pActual );
        }
        else
        {
            assertEquals( pExpected, pActual );
        }
    }
}