package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.typeutils.*;

public abstract class AbstractCalendarYM<T extends AbstractCalendarYM, M extends AbstractCalendarYM.Mutable> extends AbstractCalendarY<T, M>
        implements CalendarAccessorYM
{
    private static final long serialVersionUID = 1L;

    private /* final */ int mMonth;

    protected AbstractCalendarYM( int pYear, int pMonth )
    {
        super( pYear );
        mMonth = validateMonth( getYear(), pMonth );
    }

    @Override
    public final int getMonth()
    {
        return mMonth;
    }

    /**
     * Return a T with the Month set to the parameter, if there are insufficient days in the new month, the date will be set to the last day of the target month.
     */
    public final T month( int pMonth )
    {
        validateMonth( getYear(), pMonth );
        return (mMonth == pMonth) ? us() : LLsetMonth( pMonth );
    }

    /**
     * if after add pMonth there are insufficient days in the new month, the date will be set to the last day of the target month.
     */
    public final T addMonths( int pMonths )
    {
        return (pMonths == 0) ? us() : LLsetMonth( mMonth + pMonths );
    }

    /**
     * if after minus pMonths there are insufficient days in the new month, the date will be set to the last day of the target month.
     */
    public final T minusMonths( int pMonths )
    {
        return (pMonths == 0) ? us() : LLsetMonth( mMonth - pMonths );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseMonth(String pStringForm, String... pParts)
    {
        return parseInt( pParts[1], "Month", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueYM( CalendarAccessorYM pAccessor, StringBuilder pSB )
    {
        formatSQLvalueY( pAccessor, pSB ).append( '-' );
        return formatMonth( pAccessor, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYM( CalendarAccessorYM pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormY( pAccessor, pSB ).append( '/' );
        return formatMonth( pAccessor, pSB );
    }

    protected static final StringBuilder formatMonth( CalendarAccessorYM pAccessor, StringBuilder pSB )
    {
        MM_Chunk.appendMonthTo( pAccessor, pSB );
        return pSB;
    }

    protected static final int validateMonth( int pYear, int pMonth )
            throws IllegalArgumentException
    {
        if ( (pMonth < 1) || (12 < pMonth) )
        {
            throw new IllegalArgumentException( "Invalid Month provided (Year: " + pYear + "): " + pMonth );
        }
        return pMonth;
    }

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

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

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

    /**
     * @param pNewMonth != current
     */
    protected final T LLsetMonth( int pNewMonth )
            throws IllegalArgumentException
    {
        M zMutable = createMutable( getYear(), pNewMonth );
        zMutable.normalize();
        return createTypeFrom( zMutable );
    }

    protected abstract M createMutable( int pYear, int pNewMonth );

    protected abstract M createMutable( int pNewYear );

    protected abstract T createTypeFrom( M pMutable );

    protected static class Mutable extends AbstractCalendarY.Mutable implements CalendarAccessorYM
    {
        private int mMonth;

        public Mutable( int pYear, int pMonth )
        {
            super( pYear );
            mMonth = pMonth;
        }

        public final int getMonth()
        {
            return mMonth;
        }

        public void normalize()
        {
            while ( mMonth > 12 )
            {
                tooLargeMonth();
            }
            while ( mMonth < 1 )
            {
                tooSmallMonth();
            }
        }

        protected final void decrementMonth()
        {
            if ( --mMonth < 1 )
            {
                tooSmallMonth();
            }
        }

        protected final void incrementMonth()
        {
            if ( 12 < ++mMonth )
            {
                tooLargeMonth();
            }
        }

        private void tooSmallMonth()
        {
            decrementYear();
            mMonth += 12;
        }

        private void tooLargeMonth()
        {
            incrementYear();
            mMonth -= 12;
        }
    }
}