package org.litesoft.core.simpletypes.temporal;

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

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

    private final int mMin;

    protected AbstractTimestampHM( int pYear, int pMonth, int pDay, int pZuluOffsetMins, int pHour, int pMin )
    {
        super( pYear, pMonth, pDay, pZuluOffsetMins, pHour );
        mMin = validateMin( pMin );
    }

    @Override
    public final int getMin()
    {
        return mMin;
    }

    /**
     * Return a T with the Min set to the parameter.
     */
    public final T min( int pMin )
    {
        validateMin( pMin );
        return (mMin == pMin) ? us() : LLsetMin( pMin );
    }

    /**
     * Return T with the parameter pMin added.
     */
    public final T addMins( int pMins )
    {
        return (pMins == 0) ? us() : LLsetMin( mMin + pMins );
    }

    /**
     * Return T with the parameter pMin subtracted.
     */
    public final T minusMins( int pMins )
    {
        return (pMins == 0) ? us() : LLsetMin( mMin - pMins );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseMin( String pStringForm, String... pParts )
    {
        return parseInt( pParts[4], "Min", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueYMDHM( TimestampAccessorHM pAccessor, boolean pAddTail, StringBuilder pSB )
    {
        formatSQLvalueYMDH( pAccessor, false, pSB ).append( ':' );
        formatMin( pAccessor, pSB );
        return tailSQLvalue( pAccessor, pAddTail, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYMDHM( TimestampAccessorHM pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormYMDH( pAccessor, pSB ).append( ':' );
        return formatMin( pAccessor, pSB );
    }

    protected static final StringBuilder formatMin( TimestampAccessorHM pAccessor, StringBuilder pSB )
    {
        pSB.append( Integers.zeroPadIt( 2, pAccessor.getMin() ) );
        return pSB;
    }

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

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

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

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

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

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

    protected static class Mutable extends AbstractTimestampH.Mutable implements TimestampAccessorHM
    {
        protected int mMin;

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

        public final int getMin()
        {
            return mMin;
        }

        public void normalize()
        {
            super.normalize();
            while ( mMin < 0 )
            {
                tooSmallMin();
            }
            while ( 59 < mMin )
            {
                tooLargeMin();
            }
        }

        protected final void decrementMin()
        {
            if ( --mMin < 0 )
            {
                tooSmallMin();
            }
        }

        protected final void incrementMin()
        {
            if ( 59 < ++mMin )
            {
                tooLargeMin();
            }
        }

        private void tooSmallMin()
        {
            decrementHour();
            mMin += 60;
        }

        private void tooLargeMin()
        {
            mMin -= 60;
            incrementHour();
        }

        @Override
        protected final void adjustMinutesTo( int pOffsetMinsAdjustment )
        {
            if ( pOffsetMinsAdjustment != 0 )
            {
                mMin += pOffsetMinsAdjustment;
                normalize();
            }
        }
    }
}