// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.simpletypes.temporal;

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.temporal.nonpublic.*;
import org.litesoft.commonfoundation.typeutils.gregorian.*;

/**
 * A Date resolution from the Year thru the Day.
 */
public final class DateRes extends AbstractRes
{
    private static final long serialVersionUID = 1L;

    // Formatting Indicators
    public static final char INDICATOR_YEAR = 'y';
    public static final char INDICATOR_MONTH = 'M';
    public static final char INDICATOR_DAY = 'd';

    private static final int YEARindex = 0;
    private static final int MONTHindex = 1;
    private static final int DAYindex = 2;

    public static DateRes ToYEAR = new DateRes( "ToYEAR", "Year", YEARindex, INDICATOR_YEAR );
    public static DateRes ToMONTH = new DateRes( "ToMONTH", "Month", MONTHindex, INDICATOR_MONTH );
    public static DateRes ToDAY = new DateRes( "ToDAY", "Day", DAYindex, INDICATOR_DAY );

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected DateRes()
    {
    }

    private DateRes( String pName, String pFriendlyName, int pIndex, char pIndicator )
    {
        super( pName, pFriendlyName, pIndex, pIndicator );
    }

    public DateFormat getDateFormat()
    {
        switch ( getIndex() )
        {
            default:
            case DAYindex:
                return YearMonthDayFormatAccessor.get();
            case MONTHindex:
                return YearMonthFormatAccessor.get();
            case YEARindex:
                return YearFormatAccessor.get();
        }
    }

    private static AbstractRes[] OPTIONS = new AbstractRes[]{ToYEAR, ToMONTH, ToDAY,};

    public static DateRes fromIndex( int pIndex )
    {
        return (DateRes) LLfromIndex( OPTIONS, pIndex );
    }

    public static DateRes rehydrate( String pDesiccated )
            throws IllegalArgumentException
    {
        return (DateRes) LLrehydrate( "DateRes", OPTIONS, pDesiccated );
    }

    public boolean isValidToMonth()
    {
        return MONTHindex <= getIndex();
    }

    public boolean isValidToDay()
    {
        return DAYindex <= getIndex();
    }

    public int validateMonth( Object pCaller, int pYear, int pMonth )
            throws IllegalArgumentException
    {
        validateToMonth( pCaller );
        if ( (pMonth < 1) || (12 < pMonth) )
        {
            throw new IllegalArgumentException( "Invalid Month provided (Year: " + pYear + "): " + pMonth );
        }
        return pMonth;
    }

    public int validateDay( Object pCaller, int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        validateToDay( pCaller );
        if ( (pDay < 1) || (Month.daysIn( pYear, validateMonth( pCaller, pYear, pMonth ) ) < pDay) )
        {
            throw new IllegalArgumentException( "Invalid Day provided (Year: " + pYear + ", Month: " + pMonth + "): " + pDay );
        }
        return pDay;
    }

    public void validateToMonth( Object pCaller )
            throws IllegalArgumentException
    {
        if ( !isValidToMonth() )
        {
            throw doesNotContain( pCaller, DateRes.ToMONTH );
        }
    }

    public void validateToDay( Object pCaller )
    {
        if ( !isValidToDay() )
        {
            throw doesNotContain( pCaller, DateRes.ToDAY );
        }
    }

    private IllegalArgumentException doesNotContain( Object pCaller, DateRes pDateRes )
    {
        return new IllegalArgumentException( Objects.justClassNameOf( pCaller ) + "'s resolution is only to the '" + this.getFriendlyName() +
                                             "', but " + pDateRes.getFriendlyName() + " access or manipulation was attempted" );
    }
}