package org.litesoft.core.simpletypes.temporal;

import java.util.*;

import org.litesoft.core.typeutils.*;

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

    private /* final */ int mYear;

    protected AbstractCalendarY( int pYear )
    {
        mYear = pYear;
    }

    @Override
    public final int getYear()
    {
        return mYear;
    }

    /**
     * Return a T with the Year set to the parameter, if it was a LeapDay and can not be a LeapDay it will be 28Feb.
     */
    public final T year( int pYear )
    {
        return (mYear == pYear) ? us() : LLsetYear( pYear );
    }

    /**
     * if after add pYears AND it was a LeapDay and can not be a LeapDay it will be 28Feb.
     */
    public final T addYears( int pYears )
    {
        return (pYears == 0) ? us() : LLsetYear( mYear + pYears );
    }

    /**
     * if after minus pYears AND it was a LeapDay and can not be a LeapDay it will be 28Feb.
     */
    public final T minusYears( int pYears )
    {
        return (pYears == 0) ? us() : LLsetYear( mYear - pYears );
    }

    /**
     * True if this is 'before' or Equal to them.
     * <p/>
     * Note: Uses the lesser resolution of them and this.
     *
     * @param them !null
     *
     * @throws IllegalArgumentException if them is null
     */
    public final boolean beforeOrEqual( CalendarAccessorY them )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "before", them );
        return (this == them) || (GREATER != LL_compareNonNullLoose( them ).result());
    }

    /**
     * True if this is 'after' or Equal to them.
     * <p/>
     * Note: Uses the lesser resolution of them and this.
     *
     * @param them !null
     *
     * @throws IllegalArgumentException if them is null
     */
    public final boolean afterOrEqual( CalendarAccessorY them )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "after", them );
        return (this == them) || (LESSER != LL_compareNonNullLoose( them ).result());
    }

    public Date toUtilDate()
    {
        return toUtilDateAdaptor().getWallDate();
    }

    abstract public UtilDateAdaptor toUtilDateAdaptor();

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseYear(String pStringForm, String... pParts)
    {
        return parseInt( pParts[0], "Year", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueY( CalendarAccessorY pAccessor, StringBuilder pSB )
    {
        return formatYear( pAccessor, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormY( CalendarAccessorY pAccessor, StringBuilder pSB )
    {
        return formatYear( pAccessor, pSB );
    }

    protected static final StringBuilder formatYear( CalendarAccessorY pAccessor, StringBuilder pSB )
    {
        yyyy_Chunk.appendYearTo( pAccessor, pSB );
        return pSB;
    }

    @Override
    protected int LL_hashCode()
    {
        return mYear;
    }

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

    @Override
    protected Compare LL_compareNonNullLoose( Object them )
    {
        if ( them instanceof CalendarAccessorY )
        {
            return Compare.first( this.getYear(), ((CalendarAccessorY) them).getYear() );
        }
        throw incompatible( them );
    }

    /**
     * @param pNewYear != current
     */
    protected final T LLsetYear( int pNewYear )
    {
        M zMutable = createMutable( pNewYear );
        zMutable.normalize();
        return createTypeFrom( zMutable );
    }

    protected abstract M createMutable( int pNewYear );

    protected abstract T createTypeFrom( M pMutable );

    protected static class Mutable implements CalendarAccessorY
    {
        private int mYear;

        public Mutable( int pYear )
        {
            mYear = pYear;
        }

        public final int getYear()
        {
            return mYear;
        }

        public void normalize()
        {
        }

        protected final void decrementYear()
        {
            mYear--;
        }

        protected final void incrementYear()
        {
            mYear++;
        }
    }
}