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

import java.util.*;

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

/**
 * A Simple Time object with variable resolution from the Hour thru the Millisecond.
 */
public final class SimpleTime extends AbstractWithTimeRes<SimpleTime> implements // TODO: ??? CalendarSupport.Chunk,
                                                                                 TimeWithResolutionAccessor,
                                                                                 TemporalSimpleType,
                                                                                 SQLtimeable
{
    private static final long serialVersionUID = 1L;

    private int mHour, mMin, mSec, mMilliSec;

    /**
     * @deprecated - for Serialization
     */
    @SuppressWarnings("deprecation")
    protected SimpleTime()
    {
    }

    private SimpleTime( TimeRes pResolution )
    {
        super( pResolution );
    }

    public SimpleTime( int pHour )
            throws IllegalArgumentException
    {
        this( TimeRes.ToHOUR );
        setHour( pHour );
    }

    public SimpleTime( int pHour, int pMin )
            throws IllegalArgumentException
    {
        this( TimeRes.ToMIN );
        setHour( pHour );
        setMin( pMin );
    }

    public SimpleTime( int pHour, int pMin, int pSec )
            throws IllegalArgumentException
    {
        this( TimeRes.ToSEC );
        setHour( pHour );
        setMin( pMin );
        setSec( pSec );
    }

    public SimpleTime( int pHour, int pMin, int pSec, int pMilliSec )
            throws IllegalArgumentException
    {
        this( TimeRes.ToMSEC );
        setHour( pHour );
        setMin( pMin );
        setSec( pSec );
        setMilliSec( pMilliSec );
    }

    public SimpleTime( TimeWithResolutionAccessor pThem ) // Copy Constructor
            throws IllegalArgumentException
    {
        super( (pThem != null) ? pThem.getTimeRes() : null );
        if ( pThem == null )
        {
            throw new IllegalArgumentException( "Time, 'them', may not be null" );
        }
        this.mHour = pThem.getHour();
        this.mMin = pThem.getMin();
        this.mSec = pThem.getSec();
        this.mMilliSec = pThem.getMilliSec();
    }

    public SimpleTime copy()
    {
        return new SimpleTime( this );
    }

    public SimpleTime copyWithUpdatedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        int zCompareResult = chkCopyWithUpdatedResolution( pResolution );
        if ( zCompareResult == 0 )
        {
            return copy();
        }
        StandIn standIn = new StandIn( this );
        if ( CompareSupport.lessThan( zCompareResult ) )
        {
            standIn.greaterResolution( pResolution.getIndex() ); // We had less resolution - Suspicious results!
        }
        else
        {
            standIn.lesserResolution( pResolution.getIndex() ); // We had more resolution!
        }
        return standIn.toSimpleTime();
    }

    /**
     * Delete this method...
     */
    public SimpleTime copyWithExpandedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        if ( chkCopyWithExpandedResolution( pResolution ) )
        {
            return copy();
        }
        StandIn standIn = new StandIn( this );
        standIn.greaterResolution( pResolution.getIndex() );
        return standIn.toSimpleTime();
    }

    /**
     * Delete this method...
     */
    public SimpleTime copyWithReducedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        if ( chkCopyWithReducedResolution( pResolution ) )
        {
            return copy();
        }
        StandIn standIn = new StandIn( this );
        standIn.lesserResolution( pResolution.getIndex() );
        return standIn.toSimpleTime();
    }

    private static SimpleTime timeComponents( int pResolutionIndex, Date pDate )
            throws IllegalArgumentException
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date is Required" );
        }
        return new StandIn( pResolutionIndex, pDate ).toSimpleTime();
    }

    public static SimpleTime timeComponents( TimeRes pResolution, Date pDate )
            throws IllegalArgumentException
    {
        return timeComponents( (pResolution == null) ? TimeRes.MSECindex : pResolution.getIndex(), pDate );
    }

    public static SimpleTime timeComponents( Date pDate )
            throws IllegalArgumentException
    {
        return timeComponents( TimeRes.MSECindex, pDate );
    }

    public static SimpleTime timeComponents( UtilDateAdaptor pDate )
            throws IllegalArgumentException
    {
        return new StandIn( pDate ).toSimpleTime();
    }

    @Override
    public int getHour()
    {
        return mHour;
    }

    /**
     * @return 0 if not ValidToMin
     */
    @Override
    public int getMin()
    {
        return mMin;
    }

    /**
     * @return 0 if not ValidToSec
     */
    @Override
    public int getSec()
    {
        return mSec;
    }

    /**
     * @return 0 if not ValidToMilliSec
     */
    @Override
    public int getMilliSec()
    {
        return mMilliSec;
    }

    public UtilDateAdaptor getUtilDateAdaptor()
    {
        return UtilDateAdaptor.currentWall( 1970, 1, 1, getHour(), getMin(), getSec(), getMilliSec() );
    }

    public void setTime( SimpleTime pTime )
            throws IllegalArgumentException
    {
        if ( pTime == null )
        {
            throw new IllegalArgumentException( "Time was null" );
        }
        setHour( pTime.getHour() );
        if ( this.isValidToMin() && pTime.isValidToMin() )
        {
            setMin( pTime.getMin() );
            if ( this.isValidToSec() && pTime.isValidToSec() )
            {
                setSec( pTime.getSec() );
                if ( this.isValidToMilliSec() && pTime.isValidToMilliSec() )
                {
                    setMilliSec( pTime.getMilliSec() );
                }
            }
        }
    }

    public void setHour( int pHour )
            throws IllegalArgumentException
    {
        mHour = validate( TimeRes.HOURindex, "Hour", pHour, 23 );
    }

    public void setMin( int pMin )
            throws IllegalArgumentException
    {
        mMin = validate( TimeRes.MINindex, "Min", pMin, 59 );
    }

    public void setSec( int pSec )
            throws IllegalArgumentException
    {
        mSec = validate( TimeRes.SECindex, "Sec", pSec, 59 );
    }

    public void setMilliSec( int pMilliSec )
    {
        mMilliSec = validate( TimeRes.MSECindex, "MilliSec", pMilliSec, 999 );
    }

    /**
     * Adjust the Hours and return the number of days needing to be adjusted.
     */
    public int addHours( int pHours )
    {
        if ( pHours == 0 )
        {
            return 0;
        }
        mHour += pHours;
        return normalize();
    }

    /**
     * Adjust the Minutes and return the number of days needing to be adjusted.
     */
    public int addMins( int pMins )
            throws IllegalArgumentException
    {
        validateMinAdjustable();
        if ( pMins == 0 )
        {
            return 0;
        }
        mMin += pMins;
        return normalize();
    }

    /**
     * Adjust the Seconds and return the number of days needing to be adjusted.
     */
    public int addSecs( int pSecs )
            throws IllegalArgumentException
    {
        validateSecAdjustable();
        if ( pSecs == 0 )
        {
            return 0;
        }
        mSec += pSecs;
        return normalize();
    }

    /**
     * Adjust the MilliSeconds and return the number of days needing to be adjusted.
     */
    public int addMilliSecs( int pMilliSecs )
            throws IllegalArgumentException
    {
        validateMilliSecAdjustable();
        if ( pMilliSecs == 0 )
        {
            return 0;
        }
        mMilliSec += pMilliSecs;
        return normalize();
    }

    private int normalize()
    {
        while ( mMilliSec >= 1000 )
        {
            mSec++;
            mMilliSec -= 1000;
        }
        while ( mMilliSec < 0 )
        {
            mSec--;
            mMilliSec += 1000;
        }
        while ( mSec >= 60 )
        {
            mMin++;
            mSec -= 60;
        }
        while ( mSec < 0 )
        {
            mMin--;
            mSec += 60;
        }
        while ( mMin >= 60 )
        {
            mHour++;
            mMin -= 60;
        }
        while ( mMin < 0 )
        {
            mHour--;
            mMin += 60;
        }
        int days = 0;
        while ( mHour >= 24 )
        {
            days++;
            mHour -= 24;
        }
        while ( mHour < 0 )
        {
            days--;
            mHour += 24;
        }
        return days;
    }

    /**
     * True if this is 'before' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean before( SimpleTime pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "before", -1 );
    }

    /**
     * True if this is 'after' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean after( SimpleTime pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "after", 1 );
    }

    private boolean LLbeforeOrAfter( SimpleTime pThem, String pWhat, int pCompareRetValue )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( pWhat, pThem );
        if ( (this.mHour == pThem.mHour) && this.isValidToMin() && pThem.isValidToMin() )
        {
            if ( (this.mMin == pThem.mMin) && this.isValidToSec() && pThem.isValidToSec() )
            {
                if ( (this.mSec == pThem.mSec) && this.isValidToMilliSec() && pThem.isValidToMilliSec() )
                {
                    return pCompareRetValue == compare( this.mMilliSec, pThem.mMilliSec );
                }
                return pCompareRetValue == compare( this.mSec, pThem.mSec );
            }
            return pCompareRetValue == compare( this.mMin, pThem.mMin );
        }
        return pCompareRetValue == compare( this.mHour, pThem.mHour );
    }

    /**
     * Determine the Number of Hours, Mins, Secs, & MilliSecs between this and pThem.
     * <p/>
     * The Maximum resolution of the result is the minimum resolution of this and pThem.  However, the actual
     * resolution is dependant on the result.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public SimpleTimespan difference( SimpleTime pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "difference", -1 ) ? // this < pThem ?
               new Difference( this ).till( pThem ) : //
               new Difference( pThem ).till( this );
    }

    /**
     * Adjust by the Timespan and return the number of days needing to be adjusted.
     */
    public int add( SimpleTimespan pTimespan )
    {
        if ( pTimespan == null )
        {
            return 0;
        }
        switch ( getResolutionIndex() )
        {
            case TimeRes.MSECindex:
                mMilliSec += pTimespan.getMilliSecs();
                // Fall Thru
            case TimeRes.SECindex:
                mSec += pTimespan.getSecs();
                // Fall Thru
            case TimeRes.MINindex:
                mMin += pTimespan.getMins();
                // Fall Thru
            case TimeRes.HOURindex:
                mHour += pTimespan.getHours();
                // Fall Thru
            default:
                break;
        }
        return normalize() + pTimespan.getDays();
    }

    /**
     * Adjust by the Timespan and return the number of days needing to be adjusted.
     */
    public int subtract( SimpleTimespan pTimespan )
    {
        if ( pTimespan == null )
        {
            return 0;
        }
        switch ( getResolutionIndex() )
        {
            case TimeRes.MSECindex:
                mMilliSec -= pTimespan.getMilliSecs();
                // Fall Thru
            case TimeRes.SECindex:
                mSec -= pTimespan.getSecs();
                // Fall Thru
            case TimeRes.MINindex:
                mMin -= pTimespan.getMins();
                // Fall Thru
            case TimeRes.HOURindex:
                mHour -= pTimespan.getHours();
                // Fall Thru
            default:
                break;
        }
        return normalize() - pTimespan.getDays();
    }

    public long getSqlTimeOffset()
    {
        UtilDateAdaptor adaptor = UtilDateAdaptor.currentWall( 1970, 1, 1, getHour(), getMin(), getSec() );
        return adaptor.getWallDate().getTime();
    }

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

    public boolean equals( SimpleTime them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mHour, them.mHour ) //
                && equal( this.mMin, them.mMin ) //
                && equal( this.mSec, them.mSec ) //
                && equal( this.mMilliSec, them.mMilliSec ) //
               );
    }

    @Override
    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mHour ), //
                           calcHashCode( mMin ), //
                           calcHashCode( mSec ), //
                           calcHashCode( mMilliSec ) );
    }

    @Override
    public int compareTo( SimpleTime them )
    {
        return compareEm( compare( this.mHour, them.mHour ), //
                          compare( this.mMin, them.mMin ), //
                          compare( this.mSec, them.mSec ), //
                          compare( this.mMilliSec, them.mMilliSec ) );
    }

    private String minLength( int pMinLength, int pValue )
    {
        return minLength( pMinLength, Integer.toString( pValue ) );
    }

    @Override
    public java.sql.Time toSQLvalue()
    {
        return new java.sql.Time( getSqlTimeOffset() );
    }

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

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append( minLength( 2, mHour ) );
        if ( isValidToMin() )
        {
            sb.append( ':' ).append( minLength( 2, mMin ) );
            if ( isValidToSec() )
            {
                sb.append( ':' ).append( minLength( 2, mSec ) );
                if ( isValidToMilliSec() )
                {
                    sb.append( '.' ).append( minLength( 3, mMilliSec ) );
                }
            }
        }
        return sb.toString();
    }

    public static SimpleTime fromString( String pToString )
            throws IllegalArgumentException
    {
        if ( pToString == null )
        {
            return null;
        }
        String[] parts = SimpleParser.parse( pToString, "::.", 1 );
        switch ( parts.length )
        {
            case 1:
                return new SimpleTime( parseInt( parts[0], "Hour", pToString ) );
            case 2:
                return new SimpleTime( parseInt( parts[0], "Hour", pToString ), //
                                       parseInt( parts[1], "Min", pToString ) );
            case 3:
                return new SimpleTime( parseInt( parts[0], "Hour", pToString ), //
                                       parseInt( parts[1], "Min", pToString ), //
                                       parseInt( parts[2], "Sec", pToString ) );
            case 4:
                return new SimpleTime( parseInt( parts[0], "Hour", pToString ), //
                                       parseInt( parts[1], "Min", pToString ), //
                                       parseInt( parts[2], "Sec", pToString ), //
                                       parseInt( parts[3], "MilliSec", pToString ) );
            default:
                throw new IllegalStateException( "parts.length = " + parts.length );
        }
    }

    private static class StandIn
    {
        public StandIn()
        {
        }

        public int mHour, mMin, mSec, mMilliSec, mResolutionIndex = TimeRes.MSECindex;

        public StandIn( SimpleTime pTime )
        {
            mHour = pTime.getHour();
            mMin = pTime.getMin();
            mSec = pTime.getSec();
            mMilliSec = pTime.getMilliSec();
            mResolutionIndex = pTime.getResolutionIndex();
        }

        public StandIn( int pResolutionIndex, Date pDate )
        {
            inject( pResolutionIndex, new UtilDateAdaptor( pDate, TemporalResolution.values()[pResolutionIndex + 3] ) );
        }

        public StandIn( UtilDateAdaptor pAdaptor )
        {
            inject( pAdaptor.getTimeRes().getIndex(), pAdaptor );
        }

        public void inject( int pResolutionIndex, UtilDateAdaptor pAdaptor )
        {
            mResolutionIndex = pResolutionIndex;
            mHour = pAdaptor.getHour();
            mMin = pAdaptor.getMin();
            mSec = pAdaptor.getSec();
            mMilliSec = pAdaptor.getMilliSec();
        }

        public void greaterResolution( int pResolutionIndex )
        {
            if ( pResolutionIndex > mResolutionIndex )
            {
                clearBeyondResolution( mResolutionIndex );
                mResolutionIndex = pResolutionIndex;
            }
        }

        public void lesserResolution( int pResolutionIndex )
        {
            if ( pResolutionIndex < mResolutionIndex )
            {
                clearBeyondResolution( mResolutionIndex = pResolutionIndex );
            }
        }

        private void clearBeyondResolution( int pResolutionIndex )
        {
            switch ( pResolutionIndex )
            {
                case TimeRes.HOURindex:
                    mMin = 0;
                    // Fall Thru
                case TimeRes.MINindex:
                    mSec = 0;
                    // Fall Thru
                case TimeRes.SECindex:
                    mMilliSec = 0;
                    // Fall Thru
                case TimeRes.MSECindex:
                    // Fall Thru
                default:
                    break;
            }
        }

        public void lesserResolution( StandIn pThem )
        {
            this.lesserResolution( pThem.mResolutionIndex );
            pThem.lesserResolution( this.mResolutionIndex );
        }

        public SimpleTime toSimpleTime()
        {
            switch ( mResolutionIndex )
            {
                default:
                case TimeRes.HOURindex:
                    return new SimpleTime( mHour );
                case TimeRes.MINindex:
                    return new SimpleTime( mHour, mMin );
                case TimeRes.SECindex:
                    return new SimpleTime( mHour, mMin, mSec );
                case TimeRes.MSECindex:
                    return new SimpleTime( mHour, mMin, mSec, mMilliSec );
            }
        }

        public SimpleTimespan toSimpleTimespan()
        {
            return new SimpleTimespan( 0, mHour, mMin, mSec, mMilliSec );
        }

        public void incHour()
        {
            if ( ++mHour >= 24 )
            {
                mHour -= 24;
            }
        }

        public void incMin()
        {
            if ( ++mMin >= 60 )
            {
                mMin -= 60;
                incHour();
            }
        }

        public void incSec()
        {
            if ( ++mSec >= 60 )
            {
                mSec -= 60;
                incMin();
            }
        }

        public void incMilliSec()
        {
            if ( ++mMilliSec >= 1000 )
            {
                mMilliSec -= 1000;
                incSec();
            }
        }
    }

    private static class Difference
    {
        private StandIn mFrom, mDelta = new StandIn();

        public Difference( SimpleTime pFrom )
        {
            mDelta.lesserResolution( mFrom = new StandIn( pFrom ) );
        }

        public SimpleTimespan till( SimpleTime pThem ) // !null and is in our future
        {
            StandIn to = new StandIn( pThem );
            mDelta.lesserResolution( to );
            mFrom.lesserResolution( to.mResolutionIndex );

            if ( mFrom.mHour != to.mHour )
            {
                advanceMilliSecsTo( 0 );
                advanceSecsTo( 0 );
                advanceMinsTo( 0 );
                for (; mFrom.mHour != to.mHour; mFrom.incHour() )
                {
                    mDelta.incHour();
                }
            }
            if ( mFrom.mMin != to.mMin )
            {
                advanceMilliSecsTo( 0 );
                advanceSecsTo( 0 );
                advanceMinsTo( to.mMin );
            }
            if ( mFrom.mSec != to.mSec )
            {
                advanceMilliSecsTo( 0 );
                advanceSecsTo( to.mSec );
            }
            advanceMilliSecsTo( to.mMilliSec );

            return mDelta.toSimpleTimespan();
        }

        private void advanceMinsTo( int pTarget )
        {
            for (; mFrom.mMin != pTarget; mFrom.incMin() )
            {
                mDelta.incMin();
            }
        }

        private void advanceSecsTo( int pTarget )
        {
            for (; mFrom.mSec != pTarget; mFrom.incSec() )
            {
                mDelta.incSec();
            }
        }

        private void advanceMilliSecsTo( int pTarget )
        {
            for (; mFrom.mMilliSec != pTarget; mFrom.incMilliSec() )
            {
                mDelta.incMilliSec();
            }
        }
    }
}