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

import java.util.*;

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

/**
 * A Simple date that acts as a proxy for a java.util.Date (burying the deprecated method use) providing
 * varying levels of resolution based on the DateRes.
 * <p/>
 * Note: This class supports Gregorian dates only and has no concept of time or TimeZones.  As such when working with
 * Java Util Date(s) (or it's descendants) the local (or "Wall") date is all that is considered!
 */
public final class CalendarYMD extends CalendarSupport<CalendarYMD> implements CalendarAccessorYMD,
                                                                             TemporalSimpleType,
                                                                             CalendarConstants,
                                                                             SQLdateable
{
    private static final long serialVersionUID = 2L;

    private final DateRes mDateRes;
    private final int mYear, mMonth, mDay;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected CalendarYMD()
    {
        this( null, 0, 0, 0 );
    }

    public static CalendarYMD today()
    {
        return new CalendarYMD( new Date() );
    }

    private CalendarYMD( DateRes pDateRes, int pYear, int pMonth, int pDay )
    {
        mDateRes = pDateRes;
        mYear = pYear;
        mMonth = pMonth;
        mDay = pDay;
        if ( isValidToDay() || (pDay != 0) )
        {
            mDateRes.validateDay( this, mYear, mMonth, mDay );
        }
        else if ( isValidToMonth() || (pMonth != 0) )
        {
            mDateRes.validateMonth( this, mYear, mMonth );
        }
        // Any Year is OK
    }

    public CalendarYMD( int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        this( DateRes.ToDAY, pYear, pMonth, pDay );
    }

    public CalendarYMD( int pYear, int pMonth )
            throws IllegalArgumentException
    {
        this( DateRes.ToMONTH, pYear, pMonth, 0 );
    }

    public CalendarYMD( int pYear )
            throws IllegalArgumentException
    {
        this( DateRes.ToYEAR, pYear, 0, 0 );
    }

    public CalendarYMD( DateRes pDateRes, CalendarAccessorYMD pAccessor )
            throws IllegalArgumentException
    {
        this( pDateRes,
              pAccessor.getYear(),
              pDateRes.isValidToMonth() ? pAccessor.getMonth() : 0,
              pDateRes.isValidToDay() ? pAccessor.getDay() : 0 );
    }

    public CalendarYMD( CalendarAccessorYMD pAccessor )
            throws IllegalArgumentException
    {
        this( DateRes.ToDAY, pAccessor );
    }

    public CalendarYMD( DateRes pDateRes, Date pDate )
            throws IllegalArgumentException
    {
        this( pDateRes, new UtilDateAdaptor( pDate ) );
    }

    public CalendarYMD( Date pDate )
            throws IllegalArgumentException
    {
        this( new UtilDateAdaptor( pDate ) );
    }

    public DateRes getDateRes()
    {
        return mDateRes;
    }

    /**
     * Return a CalendarYMD (based on this) with the updated Resolution (reduction supported)
     *
     * @param pDateRes !null
     *
     * @throws IllegalArgumentException if <code>pDateRes</code> is null, or the Resolution is attempting to be increased
     */
    public CalendarYMD changeResolution( DateRes pDateRes )
            throws IllegalArgumentException
    {
        Objects.assertNotNull( "DateRes", pDateRes );
        if ( mDateRes.equals( pDateRes ) )
        {
            return this;
        }
        if ( mDateRes.getIndex() < pDateRes.getIndex() )
        {
            throw new IllegalArgumentException( "May not add Resolution" );
        }
        return new CalendarYMD( pDateRes, toUtilDateAdaptor() );
    }

    /**
     * Return a CalendarYMD with the day set to the 1st day of the current month, this will always set the 'Day' field to 1.
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Day.
     */
    public CalendarYMD forceFirstOfMonth()
            throws IllegalArgumentException
    {
        return minusDays( mDay - 1 );
    }

    /**
     * Return a CalendarYMD with the day set to the last day of the current month (either 28, 29, 30, or 31).
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Day.
     */
    public CalendarYMD forceEndOfMonth()
            throws IllegalArgumentException
    {
        return addDays( Month.daysIn( getYear(), getMonth() ) - mDay );
    }

    /**
     * Return a CalendarYMD who's <code>getWeekDay()</code> will be <code>pWeekday</code>, where the resulting date will <b>NOT</b> be in the Future relative to
     * <code>this</code>.
     *
     * @param pWeekDay !null
     */
    public CalendarYMD notFuture( WeekDay pWeekDay )
    {
        return minusDays( getWeekDay().deltaTillBackward( pWeekDay ) );
    }

    /**
     * Return a CalendarYMD with the Year set to the parameter, this is accomplished by utilizing addYears or minusYears as is appropriate (with their day
     * adjusting logic).
     */
    public CalendarYMD year( int pYear )
    {
        return (mYear == pYear) ? this : (pYear > mYear) ? addYears( pYear - mYear ) : minusYears( mYear - pYear );
    }

    /**
     * if after add pYears if was LeapDay and can not be LeapDay will be 1Mar.
     */
    public CalendarYMD addYears( int pYears )
    {
        return LLsetYear( mYear + pYears, true );
    }

    /**
     * if after minus pYears if was LeapDay and can not be LeapDay will be 28Feb.
     */
    public CalendarYMD minusYears( int pYears )
    {
        return LLsetYear( mYear - pYears, false );
    }

    /**
     * Return a CalendarYMD with the Month set to the parameter, this is accomplished by utilizing addMonths or minusMonths as is appropriate (with their day
     * adjusting logic).
     *
     * @throws IllegalArgumentException if month is not between 1 & 12 inclusive, OR if the Resolution does not extend to Month.
     */
    public CalendarYMD month( int pMonth )
            throws IllegalArgumentException
    {
        mDateRes.validateMonth( this, mYear, pMonth );
        return (mMonth == pMonth) ? this : (pMonth > mMonth) ? addMonths( pMonth - mMonth ) : minusMonths( mMonth - pMonth );
    }

    /**
     * if after add pMonth there are insufficent days in the new month, the date will be set to the 1st of the next month.
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Month.
     */
    public CalendarYMD addMonths( int pMonths )
            throws IllegalArgumentException
    {
        return LLsetMonth( mMonth + pMonths, true );
    }

    /**
     * if after minus pMonth there are insufficent days in the new month, the date will be set to the last day of the target month
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Month.
     */
    public CalendarYMD minusMonths( int pMonths )
            throws IllegalArgumentException
    {
        return LLsetMonth( mMonth - pMonths, false );
    }

    /**
     * Return a CalendarYMD with the 'Day' field set to the parameter.
     *
     * @param pDay Must be between 1 and the max days in the <code>this</code>'s month
     *
     * @throws IllegalArgumentException if the <code>pDay</code> is invalid, OR the Resolution does not extend to Day.
     */
    public CalendarYMD day( int pDay )
            throws IllegalArgumentException
    {
        return new CalendarYMD( mDateRes, mYear, mMonth, mDateRes.validateDay( this, mYear, mMonth, pDay ) );
    }

    /**
     * Return a CalendarYMD adjusted forward by the <code>pDays</code> indicated.
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Day.
     */
    public CalendarYMD addDays( int pDays )
            throws IllegalArgumentException
    {
        return LLsetDay( mDay + pDays );
    }

    /**
     * Return a CalendarYMD adjusted backward by the <code>pDays</code> indicated.
     *
     * @throws IllegalArgumentException if the Resolution does not extend to Day.
     */
    public CalendarYMD minusDays( int pDays )
            throws IllegalArgumentException
    {
        return LLsetDay( mDay - pDays );
    }

    public boolean isValidToMonth()
    {
        return mDateRes.isValidToMonth();
    }

    public boolean isValidToDay()
    {
        return mDateRes.isValidToDay();
    }

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

    /**
     * @return 0 if not ValidToMonth, otherwise 1-12
     */
    @Override
    public int getMonth()
    {
        return mMonth;
    }

    /**
     * @return 0 if not ValidToDay, otherwise 1-31
     */
    @Override
    public int getDay()
    {
        return mDay;
    }

    public WeekDay getWeekDay()
    {
        validateToDay();
        return WeekDay.valueOf( UtilDateAdaptor.dayOfWeek( toUtilDateAdaptor().getWallDate() ) );
    }

    /**
     * Number of days from this to pThem (could be negative).
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null or the resolution of either this' or pThem is not to the Day
     */
    public int daysTill( CalendarYMD pThem )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "daysTill", pThem ).validateToDay();
        validateToDay();
        int zThisMinusThem = compareTo( pThem );
        if ( zThisMinusThem == 0 )
        {
            return 0;
        }
        if ( zThisMinusThem > 0 )
        {
            return -new DaysDiff( pThem ).till( this );
        }
        return new DaysDiff( this ).till( pThem );
    }

    /**
     * True if this is 'before' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean before( CalendarYMD pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "before", -1 );
    }

    /**
     * True if this is 'after' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean after( CalendarYMD pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "after", 1 );
    }

    /**
     * Number of days from this to pThem (could be negative).
     * <p/>
     * Note: Treats pThem as if its resolution is to the Day.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null or this' resolution is not to the Day
     */
    public int daysTill( Date pThem )
            throws IllegalArgumentException
    {
        return daysTill( new CalendarYMD( mDateRes, new UtilDateAdaptor( undefinedResultIfNull( "daysTill", pThem ) ) ) );
    }

    /**
     * True if this is 'after' pThem.
     * <p/>
     * Note: Treats pThem as if its resolution is the same as this' resolution.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean after( Date pThem )
            throws IllegalArgumentException
    {
        return after( new CalendarYMD( mDateRes, new UtilDateAdaptor( undefinedResultIfNull( "after", pThem ) ) ) );
    }

    /**
     * True if this is 'before' pThem.
     * <p/>
     * Note: Treats pThem as if its resolution is the same as this' resolution.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean before( Date pThem )
            throws IllegalArgumentException
    {
        return before( new CalendarYMD( mDateRes, new UtilDateAdaptor( undefinedResultIfNull( "before", pThem ) ) ) );
    }

    @Override
    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof CalendarYMD) && equals( (CalendarYMD) o ));
    }

    public boolean equals( CalendarYMD them )
    {
        // DateRes does not need to be explicitly checked as the Month and Day are appropriately effected by DateRes!
        return (this == them) || //
               ((them != null) //
                && equal( this.mYear, them.mYear ) //
                && equal( this.mMonth, them.mMonth ) //
                && equal( this.mDay, them.mDay ) //
               );
    }

    @Override
    public int hashCode()
    {
        // DateRes does not need to be explicitly checked as the Month and Day are appropriately effected by DateRes!
        return hashCodeEm( calcHashCode( mYear ), //
                           calcHashCode( mMonth ), //
                           calcHashCode( mDay ) );
    }

    @Override
    public int compareTo( CalendarYMD them )
    {
        // DateRes does not need to be explicitly checked as the Month and Day are appropriately effected by DateRes!
        return compareEm( compare( this.mYear, them.mYear ), //
                          compare( this.mMonth, them.mMonth ), //
                          compare( this.mDay, them.mDay ) );
    }

    public UtilDateAdaptor toUtilDateAdaptor()
    {
        if ( isValidToDay() )
        {
            return new UtilDateAdaptor( mYear, mMonth, mDay );
        }
        if ( isValidToMonth() )
        {
            return new UtilDateAdaptor( mYear, mMonth, 1 );
        }
        return new UtilDateAdaptor( mYear, 1, 1 );
    }

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

    @Override
    public String toString()
    {
        return mDateRes.getDateFormat().format( this );
    }

    public static String toString( CalendarYMD pDate )
    {
        return (pDate != null) ? pDate.toString() : null;
    }

    public static String toYMD( CalendarYMD pFromYMD )
    {
        return (pFromYMD != null) ? pFromYMD.toYMD() : null;
    }

    public static CalendarYMD fromYMD( String pToYMD )
            throws IllegalArgumentException
    {
        if ( pToYMD == null )
        {
            return null;
        }
        String[] parts = SimpleParser.parse( pToYMD, "//", 1 );
        switch ( parts.length )
        {
            case 1:
                return new CalendarYMD( parseInt( parts[0], "Year", pToYMD ) );
            case 2:
                return new CalendarYMD( parseInt( parts[0], "Year", pToYMD ), //
                                       parseInt( parts[1], "Month", pToYMD ) );
            case 3:
                return new CalendarYMD( parseInt( parts[0], "Year", pToYMD ), //
                                       parseInt( parts[1], "Month", pToYMD ),
                                       parseInt( parts[2], "Day", pToYMD ) );
            default:
                throw new IllegalStateException( "parts.length = " + parts.length );
        }
    }

    public String toYMD()
    {
        StringBuilder sb = new StringBuilder();
        yyyy_Chunk.appendTo( sb, this );
        if ( isValidToMonth() )
        {
            sb.append( '/' );
            MM_Chunk.appendTo( sb, this );
            if ( isValidToDay() )
            {
                sb.append( '/' );
                dd_Chunk.appendTo( sb, this );
            }
        }
        return sb.toString();
    }

    @Override
    public String toSQLvalue()
    {
        return toYMD();
    }

    public static CalendarYMD fromSQLvalue( String pToSQLvalue )
            throws IllegalArgumentException
    {
        return fromYMD( pToSQLvalue );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    private void validateToDay()
    {
        mDateRes.validateToDay( this );
    }

    private CalendarYMD LLsetYear( int pNewYear, boolean pAdjustForward )
    {
        return (mYear == pNewYear) ? this : new Mutable( this ).setYear( pNewYear, pAdjustForward ).toSimpleDate();
    }

    private CalendarYMD LLsetMonth( int pNewMonth, boolean pAdjustForward )
            throws IllegalArgumentException
    {
        mDateRes.validateToMonth( this );
        return (mMonth == pNewMonth) ? this : new Mutable( this ).setMonth( pNewMonth, pAdjustForward ).toSimpleDate();
    }

    private CalendarYMD LLsetDay( int pDay )
            throws IllegalArgumentException
    {
        mDateRes.validateToDay( this );
        return (mDay == pDay) ? this : new Mutable( this ).setDay( pDay ).toSimpleDate();
    }

    private boolean LLbeforeOrAfter( CalendarYMD pThem, String pWhat, int pCompareRetValue )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( pWhat, pThem );
        if ( (this.mYear == pThem.mYear) && this.isValidToMonth() && pThem.isValidToMonth() )
        {
            if ( (this.mMonth == pThem.mMonth) && this.isValidToDay() && pThem.isValidToDay() )
            {
                return pCompareRetValue == compare( this.mDay, pThem.mDay );
            }
            return pCompareRetValue == compare( this.mMonth, pThem.mMonth );
        }
        return pCompareRetValue == compare( this.mYear, pThem.mYear );
    }

    private static class DaysDiff
    {
        private int mYear, mMonth, mDay, mDiff = 0;

        public DaysDiff( CalendarAccessorYMD pYMDaccessor )
        {
            mYear = pYMDaccessor.getYear();
            mMonth = pYMDaccessor.getMonth();
            mDay = pYMDaccessor.getDay();
        }

        public int till( CalendarAccessorYMD pThem ) // !null and is in our future
        {
            if ( mYear != pThem.getYear() )
            {
                // advance to 1st of the year
                do
                {
                    advanceTo1stOfNextMonth();
                }
                while ( mMonth != 1 );

                for (; mYear < pThem.getYear(); mYear++ )
                {
                    mDiff += Year.isLeap( mYear ) ? 366 : 365;
                }
            }
            while ( mMonth < pThem.getMonth() )
            {
                advanceTo1stOfNextMonth();
            }
            return mDiff + (pThem.getDay() - mDay);
        }

        private void advanceTo1stOfNextMonth()
        {
            int zDaysInMonth = Month.daysIn( mYear, mMonth );
            mDiff += zDaysInMonth - (mDay - 1);
            mDay = 1;
            if ( ++mMonth > 12 )
            {
                mMonth = 1;
                mYear++;
            }
        }
    }

    private static class Mutable implements CalendarAccessorYMD
    {
        private final DateRes mDateRes;
        private int mYear, mMonth, mDay;

        private Mutable( DateRes pDateRes, int pYear, int pMonth, int pDay )
        {
            mDateRes = pDateRes;
            mYear = pYear;
            mMonth = pMonth;
            mDay = pDay;
            normalizeMonthOfYear();
            normalizeDayOfMonth();
        }

        private Mutable( CalendarYMD pDate )
        {
            this( pDate.mDateRes, pDate.getYear(), pDate.getMonth(), pDate.getDay() );
        }

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

        public Mutable setYear( int pYear )
        {
            return setYear( pYear, (pYear > mYear) );
        }

        public Mutable setYear( int pYear, boolean pAdjustForward )
        {
            mYear = pYear;
            return adjustDayOfMonthForMonthOrYearChange( pAdjustForward );
        }

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

        public Mutable setMonth( int pMonth )
        {
            return setMonth( pMonth, (pMonth > mMonth) );
        }

        public Mutable setMonth( int pMonth, boolean pAdjustForward )
        {
            mMonth = pMonth;
            return adjustDayOfMonthForMonthOrYearChange( pAdjustForward );
        }

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

        public Mutable setDay( int pDay )
        {
            mDay = pDay;
            return normalizeDayOfMonth();
        }

        private Mutable normalizeMonthOfYear()
        {
            if ( mDateRes.isValidToMonth() )
            {
                while ( mMonth > 12 )
                {
                    mYear++;
                    mMonth -= 12;
                }
                while ( mMonth < 1 )
                {
                    mYear--;
                    mMonth += 12;
                }
            }
            return this;
        }

        private Mutable normalizeDayOfMonth()
        {
            if ( mDateRes.isValidToDay() )
            {
                while ( mDay < 1 )
                {
                    if ( --mMonth < 1 )
                    {
                        mMonth = 12;
                        mYear--;
                    }
                    mDay += Month.daysIn( mYear, mMonth );
                }
                while ( 28 < mDay )
                {
                    int zDaysInMonth = Month.daysIn( mYear, mMonth );
                    if ( mDay <= zDaysInMonth )
                    {
                        break;
                    }
                    mDay -= zDaysInMonth;
                    if ( 12 < ++mMonth )
                    {
                        mMonth = 1;
                        mYear++;
                    }
                }
            }
            return this;
        }

        private Mutable adjustDayOfMonthForMonthOrYearChange( boolean pAdjustForward )
        {
            normalizeMonthOfYear();
            if ( mDateRes.isValidToDay() ) // if Not, then any year works with any month
            {
                int maxDaysInMonth = Month.daysIn( mYear, mMonth );
                if ( maxDaysInMonth < mDay )
                {
                    mDay = maxDaysInMonth;
                    if ( pAdjustForward )
                    {
                        return addDays( 1 );
                    }
                }
            }
            return this;
        }

        public Mutable addDays( int pDays )
        {
            mDay += pDays;
            for ( int maxDaysInMonth; (maxDaysInMonth = Month.daysIn( mYear, mMonth )) < mDay; )
            {
                mDay -= maxDaysInMonth;
                if ( ++mMonth > 12 )
                {
                    mMonth = 1;
                    mYear++;
                }
            }
            return this;
        }

        public Mutable minusDays( int pDays )
        {
            mDay -= pDays;
            while ( mDay < 1 )
            {
                if ( --mMonth < 1 )
                {
                    mMonth = 12;
                    mYear--;
                }
                mDay += Month.daysIn( mYear, mMonth );
            }
            return this;
        }

        public CalendarYMD toSimpleDate()
        {
            return new CalendarYMD( mDateRes, this );
        }
    }
}