package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.typeutils.*;
import org.litesoft.core.typeutils.gregorian.*;

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

    private /* final */ int mDay;

    protected AbstractCalendarYMD( int pYear, int pMonth, int pDay )
    {
        super( pYear, pMonth );
        mDay = validateDay( getYear(), getMonth(), pDay );
    }

    @Override
    public final int getDay()
    {
        return mDay;
    }

    /**
     * Return a T with the Day set to the parameter.
     */
    public final T day( int pDay )
    {
        validateDay( getYear(), getMonth(), pDay );
        return (mDay == pDay) ? us() : LLsetDay( pDay );
    }

    /**
     * Return T with the parameter pDay added.
     */
    public final T addDays( int pDays )
    {
        return (pDays == 0) ? us() : LLsetDay( mDay + pDays );
    }

    /**
     * Return T with the parameter pDay subtracted.
     */
    public final T minusDays( int pDays )
    {
        return (pDays == 0) ? us() : LLsetDay( mDay - pDays );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseDay(String pStringForm, String... pParts)
    {
        return parseInt( pParts[2], "Day", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueYMD( CalendarAccessorYMD pAccessor, StringBuilder pSB )
    {
        formatSQLvalueYM( pAccessor, pSB ).append( '-' );
        return formatDay( pAccessor, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYMD( CalendarAccessorYMD pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormYM( pAccessor, pSB ).append( '/' );
        return formatDay( pAccessor, pSB );
    }

    protected static final StringBuilder formatDay( CalendarAccessorYMD pAccessor, StringBuilder pSB )
    {
        dd_Chunk.appendTo( pSB, pAccessor );
        return pSB;
    }

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

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

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

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

    /**
     * @param pNewDay != current
     */
    protected final T LLsetDay( int pNewDay )
    {
        M zMutable = createMutable( getYear(), getMonth(), pNewDay );
        zMutable.normalize();
        return createTypeFrom( zMutable );
    }

    protected abstract M createMutable( int pYear, int pMonth, int pNewDay );

    protected static class Mutable extends AbstractCalendarYM.Mutable implements CalendarAccessorYMD
    {
        private int mDay;
        private boolean mDayConstrained;

        public Mutable( int pYear, int pMonth, int pDay, boolean pDayConstrained )
        {
            super( pYear, pMonth );
            mDay = pDay;
            mDayConstrained = pDayConstrained;
        }

        public final int getDay()
        {
            return mDay;
        }

        public void normalize()
        {
            super.normalize();
            while ( mDay < 1 )
            {
                tooSmallDay();
            }
            while ( 28 < mDay )
            {
                if ( !tooLargeDay() )
                {
                    break;
                }
            }
        }

        protected final void decrementDay()
        {
            if ( --mDay < 1 )
            {
                tooSmallDay();
            }
        }

        protected final void incrementDay()
        {
            if ( 28 < ++mDay )
            {
                tooLargeDay();
            }
        }

        private void tooSmallDay()
        {
            decrementMonth();
            mDay += Month.daysIn( getYear(), getMonth() );
        }

        private boolean tooLargeDay()
        {
            int zDaysInMonth = Month.daysIn( getYear(), getMonth() );
            if ( mDay <= zDaysInMonth )
            {
                return false;
            }
            if ( mDayConstrained )
            {
                mDay = zDaysInMonth;
                return false;
            }
            mDay -= zDaysInMonth;
            incrementMonth();
            return true;
        }
    }
}