package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.nonpublic.*;

/**
 * A Simple Timespan, which consists of a number of days, Hours, Mins, Secs, & MilliSecs.
 */
public final class SimpleTimespan extends CalendarSupport<SimpleTimespan> implements SimpleType
{
    public static final String DEFAULT_TS_FORMAT = "ddd HH:mm:ss.SSS"; // Note this is representational - IT IS NOT USED!

    private int mDays, mHours, mMins, mSecs, mMilliSecs;

    /**
     * @deprecated - for Serialization
     */
    protected SimpleTimespan()
    {
    }

    public SimpleTimespan( int pDays, int pHours, int pMins, int pSecs, int pMilliSecs )
            throws IllegalArgumentException
    {
        setDays( pDays );
        setHours( pHours );
        setMins( pMins );
        setSecs( pSecs );
        setMilliSecs( pMilliSecs );
    }

    public SimpleTimespan( int pDays, int pHours, int pMins, int pSecs )
            throws IllegalArgumentException
    {
        this( pDays, pHours, pMins, pSecs, 0 );
    }

    public SimpleTimespan( int pDays, int pHours, int pMins )
            throws IllegalArgumentException
    {
        this( pDays, pHours, pMins, 0 );
    }

    public SimpleTimespan( int pDays, int pHours )
            throws IllegalArgumentException
    {
        this( pDays, pHours, 0 );
    }

    public SimpleTimespan( int pDays )
            throws IllegalArgumentException
    {
        this( pDays, 0 );
    }

    public SimpleTimespan copy()
    {
        return new SimpleTimespan( getDays(), getHours(), getMins(), getSecs(), getMilliSecs() );
    }

    public int getDays()
    {
        return mDays;
    }

    public int getHours()
    {
        return mHours;
    }

    public int getMins()
    {
        return mMins;
    }

    public int getSecs()
    {
        return mSecs;
    }

    public int getMilliSecs()
    {
        return mMilliSecs;
    }

    public void setDays( int pDays )
            throws IllegalArgumentException
    {
        if ( pDays < 0 )
        {
            throw new IllegalArgumentException( "Negative Spans not supported" );
        }
        mDays = pDays;
    }

    public void setHours( int pHours )
    {
        mHours = validate( "Hour", pHours, 23 );
    }

    public void setMins( int pMins )
    {
        mMins = validate( "Min", pMins, 59 );
    }

    public void setSecs( int pSecs )
    {
        mSecs = validate( "Sec", pSecs, 59 );
    }

    public void setMilliSecs( int pMilliSecs )
    {
        mMilliSecs = validate( "MilliSec", pMilliSecs, 999 );
    }

    /**
     * Adjust the Days.  Note: Negative Durations are Not Supported and will give unreliable results.
     */
    public void addDays( int pDays )
    {
        if ( pDays != 0 )
        {
            mDays += pDays;
            normalize();
        }
    }

    /**
     * Adjust the Hours.  Note: Negative Durations are Not Supported and will give unreliable results.
     */
    public void addHours( int pHours )
    {
        if ( pHours != 0 )
        {
            mHours += pHours;
            normalize();
        }
    }

    /**
     * Adjust the Minutes.  Note: Negative Durations are Not Supported and will give unreliable results.
     */
    public void addMins( int pMins )
            throws IllegalArgumentException
    {
        if ( pMins != 0 )
        {
            mMins += pMins;
            normalize();
        }
    }

    /**
     * Adjust the Seconds.  Note: Negative Durations are Not Supported and will give unreliable results.
     */
    public void addSecs( int pSecs )
            throws IllegalArgumentException
    {
        if ( pSecs != 0 )
        {
            mSecs += pSecs;
            normalize();
        }
    }

    /**
     * Adjust the MilliSeconds.  Note: Negative Durations are Not Supported and will give unreliable results.
     */
    public void addMilliSecs( int pMilliSecs )
            throws IllegalArgumentException
    {
        if ( pMilliSecs != 0 )
        {
            mMilliSecs += pMilliSecs;
            normalize();
        }
    }

    private void normalize()
    {
        while ( mMilliSecs >= 1000 )
        {
            mSecs++;
            mMilliSecs -= 1000;
        }
        while ( mMilliSecs < 0 )
        {
            mSecs--;
            mMilliSecs += 1000;
        }
        while ( mSecs >= 60 )
        {
            mMins++;
            mSecs -= 60;
        }
        while ( mSecs < 0 )
        {
            mMins--;
            mSecs += 60;
        }
        while ( mMins >= 60 )
        {
            mHours++;
            mMins -= 60;
        }
        while ( mMins < 0 )
        {
            mHours--;
            mMins += 60;
        }
        while ( mHours >= 24 )
        {
            mDays++;
            mHours -= 24;
        }
        while ( mHours < 0 )
        {
            mDays--;
            mHours += 24;
        }
    }

    /**
     * True if this is 'lessthan' pThem.
     * <p/>
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean lessthan( SimpleTimespan pThem )
            throws IllegalArgumentException
    {
        return LLltORgt( pThem, "lessthan", -1 );
    }

    /**
     * True if this is 'greaterthan' pThem.
     * <p/>
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean greaterthan( SimpleTimespan pThem )
            throws IllegalArgumentException
    {
        return LLltORgt( pThem, "greaterthan", 1 );
    }

    private boolean LLltORgt( SimpleTimespan pThem, String pWhat, int pCompareRetValue )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( pWhat, pThem );
        return pCompareRetValue == compareTo( pThem );
    }

    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof SimpleTimespan) && equals( (SimpleTimespan) o ));
    }

    public boolean equals( SimpleTimespan them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mDays, them.mDays ) //
                && equal( this.mHours, them.mHours ) //
                && equal( this.mMins, them.mMins ) //
                && equal( this.mSecs, them.mSecs ) //
                && equal( this.mMilliSecs, them.mMilliSecs ) //
               );
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mDays ), //
                           calcHashCode( mHours ), //
                           calcHashCode( mMins ), //
                           calcHashCode( mSecs ), //
                           calcHashCode( mMilliSecs ) );
    }

    public int compareTo( SimpleTimespan them )
    {
        return compareEm( compare( this.mDays, them.mDays ), //
                          compare( this.mHours, them.mHours ), //
                          compare( this.mMins, them.mMins ), //
                          compare( this.mSecs, them.mSecs ), //
                          compare( this.mMilliSecs, them.mMilliSecs ) );
    }

    public static String toString( SimpleTimespan pFromString )
    {
        return (pFromString != null) ? pFromString.toString() : null;
    }

    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append( mDays );
        if ( mMilliSecs != 0 )
        {
            sb.append( ' ' ).append( new SimpleTime( mHours, mMins, mSecs, mMilliSecs ) );
        }
        else if ( mSecs != 0 )
        {
            sb.append( ' ' ).append( new SimpleTime( mHours, mMins, mSecs ) );
        }
        else if ( mMins != 0 )
        {
            sb.append( ' ' ).append( new SimpleTime( mHours, mMins ) );
        }
        else if ( mHours != 0 )
        {
            sb.append( ' ' ).append( new SimpleTime( mHours ) );
        }
        return sb.toString();
    }

    public static SimpleTimespan fromString( String pToString )
            throws IllegalArgumentException
    {
        if ( pToString == null )
        {
            return null;
        }
        // yyyy-MM-dd HH:mm:ss.SSS
        String[] parts = SimpleParser.parse( pToString, " ::.", 1 );
        int zDays = parseInt( parts[0], "Days", pToString );
        switch ( parts.length )
        {
            case 2:
                return new SimpleTimespan( zDays, //
                                           parseInt( parts[1], "Hours", pToString ) );
            case 3:
                return new SimpleTimespan( zDays, //
                                           parseInt( parts[1], "Hours", pToString ), //
                                           parseInt( parts[2], "Mins", pToString ) );
            case 4:
                return new SimpleTimespan( zDays, //
                                           parseInt( parts[1], "Hours", pToString ), //
                                           parseInt( parts[2], "Mins", pToString ), //
                                           parseInt( parts[3], "Secs", pToString ) );
            case 5:
                return new SimpleTimespan( zDays, //
                                           parseInt( parts[1], "Hours", pToString ), //
                                           parseInt( parts[2], "Mins", pToString ), //
                                           parseInt( parts[3], "Secs", pToString ), //
                                           parseInt( parts[4], "MilliSecs", pToString ) );
            default:
                throw new IllegalStateException( "parts.length = " + parts.length );
        }
    }
}