package org.litesoft.core.simpletypes.temporal;

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

public abstract class AbstractTimestampHMSM<T extends AbstractTimestampHMSM, M extends AbstractTimestampHMSM.Mutable> extends AbstractTimestampHMS<T, M>
        implements TimestampAccessorHMSM
{
    private static final long serialVersionUID = 1L;

    private final int mMilliSec;

    protected AbstractTimestampHMSM( int pYear, int pMonth, int pDay, int pZuluOffsetMins, int pHour, int pMin, int pSec, int pMilliSec )
    {
        super( pYear, pMonth, pDay, pZuluOffsetMins, pHour, pMin, pSec );
        mMilliSec = validateMilliSec( pMilliSec );
    }

    @Override
    public final int getMilliSec()
    {
        return mMilliSec;
    }

    /**
     * Return a T with the MilliSec set to the parameter.
     */
    public final T milliSec( int pMilliSec )
    {
        validateMilliSec( pMilliSec );
        return (mMilliSec == pMilliSec) ? us() : LLsetMilliSec( pMilliSec );
    }

    /**
     * Return T with the parameter pMilliSec added.
     */
    public final T addMilliSecs( int pMilliSecs )
    {
        return (pMilliSecs == 0) ? us() : LLsetMilliSec( mMilliSec + pMilliSecs );
    }

    /**
     * Return T with the parameter pMilliSec subtracted.
     */
    public final T minusMilliSecs( int pMilliSecs )
    {
        return (pMilliSecs == 0) ? us() : LLsetMilliSec( mMilliSec - pMilliSecs );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseMilliSec( String pStringForm, String... pParts )
    {
        String zFraction = pParts[6];
        return (int) (1000 * fractional( zFraction, parseInt( zFraction, "MilliSec", pStringForm ) ));
    }

    protected static final StringBuilder formatSQLvalueYMDHMSM( TimestampAccessorHMSM pAccessor, boolean pAddTail, StringBuilder pSB )
    {
        formatSQLvalueYMDHM( pAccessor, false, pSB ).append( ':' );
        formatMilliSec( pAccessor, pSB );
        return tailSQLvalue( pAccessor, pAddTail, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYMDHMSM( TimestampAccessorHMSM pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormYMDHM( pAccessor, pSB ).append( ':' );
        return formatMilliSec( pAccessor, pSB );
    }

    protected static final StringBuilder formatMilliSec( TimestampAccessorHMSM pAccessor, StringBuilder pSB )
    {
        pSB.append( Integers.zeroPadIt( 3, pAccessor.getMilliSec() ) );
        return pSB;
    }

    protected static final int validateMilliSec( int pMilliSec )
            throws IllegalArgumentException
    {
        if ( (pMilliSec < 0) || (999 < pMilliSec) )
        {
            throw new IllegalArgumentException( "Invalid MilliSec provided: " + pMilliSec );
        }
        return pMilliSec;
    }

    protected int LL_hashCode()
    {
        return hashCodeEm( super.hashCode(), mMilliSec );
    }

    /**
     * T is non-null and of the same class, so should check everything!
     */
    protected boolean LL_equalsNonNullStrict( T them )
    {
        return super.LL_equalsNonNullStrict( them ) && this.getMilliSec() == them.getMilliSec();
    }

    protected Compare LL_compareNonNullLoose( Object them )
    {
        Compare zCompare = super.LL_compareNonNullLoose( them );
        if ( (zCompare.result() == EQUAL) && (them instanceof TimestampAccessorHMSM) )
        {
            zCompare = zCompare.then( this.getMilliSec(), ((TimestampAccessorHMSM) them).getMilliSec() );
        }
        return zCompare;
    }

    /**
     * @param pNewMonth != current
     */
    protected final T LLsetMilliSec( int pNewMilliSec )
    {
        M zMutable = createMutable( getYear(), getMonth(), getDay(), getHour(), getMin(), getSec(), pNewMilliSec );
        zMutable.normalize();
        return createTypeFrom( zMutable );
    }

    protected abstract M createMutable( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec, int pNewMilliSec );

    protected static class Mutable extends AbstractTimestampHMS.Mutable implements TimestampAccessorHMSM
    {
        protected int mMilliSec;

        public Mutable( int pYear, int pMonth, int pDay, boolean pDayConstrained, int pZuluOffsetMins, int pHour, int pMin, int pSec, int pMilliSec )
        {
            super( pYear, pMonth, pDay, pDayConstrained, pZuluOffsetMins, pHour, pMin, pSec );
            mMilliSec = pMilliSec;
        }

        public final int getMilliSec()
        {
            return mMilliSec;
        }

        public void normalize()
        {
            super.normalize();
            while ( mMilliSec < 0 )
            {
                tooSmallMilliSec();
            }
            while ( 999 < mMilliSec )
            {
                tooLargeMilliSec();
            }
        }

        protected final void decrementMilliSec()
        {
            if ( --mMilliSec < 0 )
            {
                tooSmallMilliSec();
            }
        }

        protected final void incrementMilliSec()
        {
            if ( 999 < ++mMilliSec )
            {
                tooLargeMilliSec();
            }
        }

        private void tooSmallMilliSec()
        {
            decrementMin();
            mMilliSec += 1000;
        }

        private void tooLargeMilliSec()
        {
            mMilliSec -= 1000;
            incrementMin();
        }
    }
}