package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.typeutils.*;

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

    protected AbstractTimestampHMS( int pOriginalZuluOffsetMins, long pUTC )
    {
        super( pOriginalZuluOffsetMins, pUTC );
    }

    protected AbstractTimestampHMS( int pOriginalZuluOffsetMins, UtilDateAdaptor pDateAdaptor )
    {
        super( pOriginalZuluOffsetMins, pDateAdaptor );
    }

    protected AbstractTimestampHMS( UtilDateAdaptor pDateAdaptor )
    {
        super( pDateAdaptor );
    }

    @Override
    public final int getSec()
    {
        return getWall().getSec();
    }

    /**
     * Return a T with the Sec set to the parameter.
     */
    public final T sec( int pSec )
    {
        validateSec( pSec );
        return (getSec() == pSec) ? us() : LLsetSec( pSec );
    }

    /**
     * Return T with the parameter pSec added.
     */
    public final T addSecs( int pSecs )
    {
        return (pSecs == 0) ? us() : LLsetSec( getSec() + pSecs );
    }

    /**
     * Return T with the parameter pSec subtracted.
     */
    public final T minusSecs( int pSecs )
    {
        return (pSecs == 0) ? us() : LLsetSec( getSec() - pSecs );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseSec( String pStringForm, String... pParts )
    {
        return parseInt( pParts[5], "Sec", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueYMDHMS( TimestampAccessorHMS pAccessor, boolean pAddTail, StringBuilder pSB )
    {
        formatSQLvalueYMDHM( pAccessor, false, pSB ).append( ':' );
        formatSec( pAccessor, pSB );
        return tailSQLvalue( pAccessor, pAddTail, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYMDHMS( TimestampAccessorHMS pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormYMDHM( pAccessor, pSB ).append( ':' );
        return formatSec( pAccessor, pSB );
    }

    protected static final StringBuilder formatSec( TimestampAccessorHMS pAccessor, StringBuilder pSB )
    {
        pSB.append( Integers.zeroPadIt( 2, pAccessor.getSec() ) );
        return pSB;
    }

    protected static final int validateSec( int pSec )
            throws IllegalArgumentException
    {
        if ( (pSec < 0) || (59 < pSec) )
        {
            throw new IllegalArgumentException( "Invalid Sec provided: " + pSec );
        }
        return pSec;
    }

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

    /**
     * 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.getSec() == them.getSec();
    }

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

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

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

    protected static class Mutable extends AbstractTimestampHM.Mutable
    {
        protected int mSec;

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

        public final int getSec()
        {
            return mSec;
        }

        public void normalize()
        {
            super.normalize();
            while ( mSec < 0 )
            {
                tooSmallSec();
            }
            while ( 59 < mSec )
            {
                tooLargeSec();
            }
        }

        protected final void decrementSec()
        {
            if ( --mSec < 0 )
            {
                tooSmallSec();
            }
        }

        protected final void incrementSec()
        {
            if ( 59 < ++mSec )
            {
                tooLargeSec();
            }
        }

        private void tooSmallSec()
        {
            decrementMin();
            mSec += 60;
        }

        private void tooLargeSec()
        {
            mSec -= 60;
            incrementMin();
        }
    }
}