package org.litesoft.core.simpletypes.temporal;

import junit.framework.*;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

public abstract class AbstractTemporalTestSupport<T extends AbstractTemporal<T>> extends TestCase
{
    protected AbstractTemporalTestSupport( String name )
    {
        super( name );
    }

    protected enum Direction
    {
        Forward, Backward, Neither
    }

    protected String toY( int pYear )
    {
        return Integers.zeroPadIt( 4, pYear );
    }

    protected String toYM( int pYear, int pMonth )
    {
        return toY( pYear ) + "/" + Integers.zeroPadIt( 2, pMonth );
    }

    protected String toYMD( int pYear, int pMonth, int pDay )
    {
        return toYM( pYear, pMonth ) + "/" + Integers.zeroPadIt( 2, pDay );
    }

    protected String toSQLvalueY( int pYear )
    {
        return Integers.zeroPadIt( 4, pYear );
    }

    protected String toYMDH( int pYear, int pMonth, int pDay, int pHour )
    {
        return toYMD( pYear, pMonth, pDay ) + " " + Integers.zeroPadIt( 2, pHour );
    }

    protected String toSQLvalueYM( int pYear, int pMonth )
    {
        return toSQLvalueY( pYear ) + "-" + Integers.zeroPadIt( 2, pMonth );
    }

    protected String toSQLvalueYMD( int pYear, int pMonth, int pDay )
    {
        return toSQLvalueYM( pYear, pMonth ) + "-" + Integers.zeroPadIt( 2, pDay );
    }

    protected String toSQLvalueYMDH( int pYear, int pMonth, int pDay, int pHour )
    {
// TODO: XXX        UtilDateAdaptor zDateAdaptor = UtilDateAdaptor.wall( pYear, pMonth, pDay, pHour );
//        zDateAdaptor.getUTCtoWallOffsetMinutes()
        return toSQLvalueYMD( pYear, pMonth, pDay ) + "T" + Integers.zeroPadIt( 2, pHour );
    }

    protected Direction add( int pAdjustBy )
    {
        if ( pAdjustBy == 0 )
        {
            return Direction.Neither;
        }
        return (pAdjustBy > 0) ? Direction.Forward : Direction.Backward;
    }

    protected Direction minus( int pAdjustBy )
    {
        if ( pAdjustBy == 0 )
        {
            return Direction.Neither;
        }
        return (pAdjustBy < 0) ? Direction.Forward : Direction.Backward;
    }

    protected void compareCheck( Direction pDirection, T pOd, T pNd )
    {
        AbstractCalendarY zOD = cast( pOd );
        AbstractCalendarY zNd = cast( pNd );
        int zCompare = compareEm( pOd, pNd );
        boolean zOdAfterOrEqualNd = zOD.afterOrEqual( zNd );
        boolean zOdBeforeOrEqualNd = zOD.beforeOrEqual( zNd );
        switch ( pDirection )
        {
            case Forward:
                assertTrue( 0 > zCompare );
                assertFalse( zOdAfterOrEqualNd );
                assertTrue( zOdBeforeOrEqualNd );
                break;
            case Backward:
                assertTrue( 0 < zCompare );
                assertTrue( zOdAfterOrEqualNd );
                assertFalse( zOdBeforeOrEqualNd );
                break;
            default:
            case Neither:
                assertTrue( pOd == pNd );
                assertTrue( 0 == zCompare );
                assertTrue( zOdAfterOrEqualNd );
                assertTrue( zOdBeforeOrEqualNd );
                break;
        }
    }

    protected void chkAfterBeforeNull( T pSd )
    {
        try
        {
            cast( pSd ).afterOrEqual( null );
            fail( "Did Not fail on '" + pSd + "': after( null )" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        try
        {
            cast( pSd ).beforeOrEqual( null );
            fail( "Did Not fail on '" + pSd + "': before( null )" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
    }

    private AbstractCalendarY cast( T pSD )
    {
        return Cast.it( pSD );
    }

    @SuppressWarnings("unchecked")
    private int compareEm( T pOd, T pNd )
    {
        return pOd.compareTo( pNd );
    }
}