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

import junit.framework.*;

import org.litesoft.commonfoundation.typeutils.*;

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

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

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

    public void test_Contructors_Bad()
    {
        // Bad Strings
        chkCB( "1996a" );
        chkCB( "1996/a" );
        chkCB( "1996/1/a" );
        // Bad Dates
        chkCB( "2000/0" );
        chkCB( "2000/13" );

        // Missing Parts
        chkCB( "1996" );

        // Too Many Parts
        chkCB( "1996/2/1" );
    }

    private void chkCB( String pToYM )
    {
        try
        {
            CalendarYM.fromYM( pToYM );
            fail( "Did not fail : fromYM( \"" + pToYM + "\" )" );
        }
        catch ( IllegalArgumentException expected )
        {
            // Expected
        }
    }

    public void test_rtYM()
    {
        chkRT_YM( "1957/1", "1957/01" );
        chkRT_YM( "1957/01", "1957/01" );
        chkRT_YM( "1957/001", "1957/01" );
        chkRT_YM( "2000/2", "2000/02" );
        chkRT_YM( "2012/012", "2012/12" );
    }

    private void chkRT_YM( String pInputForFrom, String pToOutput )
    {
        CalendarYM sd = CalendarYM.fromYM( pInputForFrom );
        assertEquals( pToOutput, sd.toYM() );
    }

    public void test_rtSQL()
    {
        chkRT_SQL( "1957-1", "1957-01" );
        chkRT_SQL( "1957-01", "1957-01" );
        chkRT_SQL( "1957-001", "1957-01" );
        chkRT_SQL( "2000-2", "2000-02" );
        chkRT_SQL( "2012-012", "2012-12" );
    }

    private void chkRT_SQL( String pInputForFrom, String pToOutput )
    {
        CalendarYM sd = CalendarYM.fromSQLvalue( pInputForFrom );
        assertEquals( pToOutput, sd.toSQLvalue() );
    }

    public void test_fromYMAndToString()
            throws Exception
    {
        chk( DateFormat.DEFAULT_YM_FORMAT, "My", "1957/1", "Jan 1957", 1957, 1 );
        chk( "MMMyy", "My", "1957/1", "Jan57", 1957, 1 );
        chk( "MMMMMM y", "My", "1957 / 1", "January 1957", 1957, 1 );
        chk( "y-MM", "yM", "1957 / 1", "1957-01", 1957, 1 );
    }

    private void chk( String pDateFormat, String pFieldOrder, String pDateToParse, String pDateFormatToString, int pYear, int pMonth )
    {
        chk( new DateFormat( pDateFormat ), pFieldOrder, CalendarYM.fromYM( pDateToParse ), pDateFormatToString, pYear, pMonth );
    }

    public void test_ContructorsAndToString()
            throws Exception
    {
        chk( "MMM yyyy", "My", 2004, 2, "Feb 2004" );
    }

    private void chk( String pDateFormat, String pFieldOrder, int pYear, int pMonth, String pDateFormatToString )
    {
        chk( new DateFormat( pDateFormat ), pFieldOrder, new CalendarYM( pYear, pMonth ), pDateFormatToString, pYear, pMonth );
    }

    private void chk( DateFormat pFormat, String pFieldOrder, CalendarYM pDate, String pDateFormatToString, int pYear, int pMonth )
    {
        String zExpectedStringFormY = Integers.zeroPadIt( 4, pYear );
        String zExpectedStringFormM = Integers.zeroPadIt( 2, pMonth );
        assertEquals( pFieldOrder, pFormat.getFieldOrder() );
        assertEquals( "Year", pYear, pDate.getYear() );
        assertEquals( "Month", pMonth, pDate.getMonth() );
        assertEquals( pDateFormatToString, pFormat.format( pDate ) );
        assertEquals( "toYM", zExpectedStringFormY + "/" + zExpectedStringFormM, pDate.toYM() );
        assertEquals( "fromYM", pDate, CalendarYM.fromYM( pDate.toYM() ) );
        assertEquals( "toSQLvalue", zExpectedStringFormY + "-" + zExpectedStringFormM, pDate.toSQLvalue() );
        assertEquals( "fromSQLvalue", pDate, CalendarYM.fromSQLvalue( pDate.toSQLvalue() ) );
    }

    public void test_addYears()
    {
        chk_addYears( "1957/01", 51, "2008/01" );
        chk_addYears( "2000/01", -1, "1999/01" );
        chk_addYears( "2000/02", 1, "2001/02" );
        chk_addYears( "2000/02", 0, "2000/02" );
        chk_addYears( "2000/02", -1, "1999/02" );
    }

    private void chk_addYears( String pDateYM, int pAdjustBy, String pExpectedYM )
    {
        CalendarYM od = CalendarYM.fromYM( pDateYM );
        CalendarYM nd = od.addYears( pAdjustBy );
        assertEquals( pExpectedYM, nd.toYM() );
        if ( pAdjustBy == 0 )
        {
            assertTrue( od == nd );
            assertTrue( 0 == od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else if ( pAdjustBy > 0 )
        {
            assertTrue( 0 > od.compareTo( nd ) );
            assertFalse( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else // pAdjustBy < 0
        {
            assertTrue( 0 < od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertFalse( od.beforeOrEqual( nd ) );
        }
    }

    public void test_minusYears()
    {
        chk_minusYears( "2008/01", 51, "1957/01" );
        chk_minusYears( "2000/01", -1, "2001/01" );
        chk_minusYears( "2000/02", 1, "1999/02" );
        chk_minusYears( "2000/02", 0, "2000/02" );
        chk_minusYears( "2000/02", -1, "2001/02" );
    }

    private void chk_minusYears( String pDateYM, int pAdjustBy, String pExpectedYM )
    {
        CalendarYM od = CalendarYM.fromYM( pDateYM );
        CalendarYM nd = od.minusYears( pAdjustBy );
        assertEquals( pExpectedYM, nd.toYM() );
        if ( pAdjustBy == 0 )
        {
            assertTrue( od == nd );
            assertTrue( 0 == od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else if ( pAdjustBy < 0 )
        {
            assertTrue( 0 > od.compareTo( nd ) );
            assertFalse( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else // pAdjustBy > 0
        {
            assertTrue( 0 < od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertFalse( od.beforeOrEqual( nd ) );
        }
    }

    public void test_addMonths()
    {
        chk_addMonths( "1957/01", 2, "1957/03" );
        chk_addMonths( "2000/01", 0, "2000/01" );
        chk_addMonths( "2000/01", -1, "1999/12" );
        chk_addMonths( "2000/02", 12, "2001/02" );
        chk_addMonths( "2000/02", -12, "1999/02" );
    }

    private void chk_addMonths( String pDateYM, int pAdjustBy, String pExpectedYM )
    {
        CalendarYM od = CalendarYM.fromYM( pDateYM );
        CalendarYM nd = od.addMonths( pAdjustBy );
        assertEquals( pExpectedYM, nd.toYM() );
        if ( pAdjustBy == 0 )
        {
            assertTrue( od == nd );
            assertTrue( 0 == od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else if ( pAdjustBy > 0 )
        {
            assertTrue( 0 > od.compareTo( nd ) );
            assertFalse( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else // pAdjustBy < 0
        {
            assertTrue( 0 < od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertFalse( od.beforeOrEqual( nd ) );
        }
    }

    public void test_minusMonths()
    {
        chk_minusMonths( "1957/03", 2, "1957/01" );
        chk_minusMonths( "1999/12", -1, "2000/01" );
        chk_minusMonths( "2000/02", 12, "1999/02" );
        chk_minusMonths( "2000/02", 0, "2000/02" );
        chk_minusMonths( "2000/02", -12, "2001/02" );
    }

    private void chk_minusMonths( String pDateYM, int pAdjustBy, String pExpectedYM )
    {
        CalendarYM od = CalendarYM.fromYM( pDateYM );
        CalendarYM nd = od.minusMonths( pAdjustBy );
        assertEquals( pExpectedYM, nd.toYM() );
        if ( pAdjustBy == 0 )
        {
            assertTrue( od == nd );
            assertTrue( 0 == od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else if ( pAdjustBy < 0 )
        {
            assertTrue( 0 > od.compareTo( nd ) );
            assertFalse( od.afterOrEqual( nd ) );
            assertTrue( od.beforeOrEqual( nd ) );
        }
        else // pAdjustBy > 0
        {
            assertTrue( 0 < od.compareTo( nd ) );
            assertTrue( od.afterOrEqual( nd ) );
            assertFalse( od.beforeOrEqual( nd ) );
        }
    }

    public void test_after_before_null()
    {
        CalendarYM sd = new CalendarYM( 2000, 1 );
        try
        {
            sd.afterOrEqual( null );
            fail( "Did Not fail on '" + sd + "': after( null )" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        try
        {
            sd.beforeOrEqual( null );
            fail( "Did Not fail on '" + sd + "': before( null )" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
    }
}