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

import java.util.*;

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

/**
 * A Calendar "date" (e.g. Year, Month, & Day) ("Wall" relative).
 * <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 AbstractCalendarYMD<CalendarYMD, AbstractCalendarYMD.Mutable> implements SQLdateable
{
    private static final long serialVersionUID = 1L;

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

    public CalendarYMD( int pYear, int pMonth, int pDay )
    {
        super( pYear, pMonth, pDay );
    }

    public CalendarYMD( CalendarAccessorYMD pAccessor )
    {
        this( pAccessor.getYear(), pAccessor.getMonth(), pAccessor.getDay() );
    }

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

    @Override
    public TemporalResolution getResolution()
    {
        return TemporalResolution.ToDay;
    }

    @Override
    public String toString()
    {
        return YearMonthDayFormatAccessor.get().format( this );
    }

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

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

    public String toYMD()
    {
        return formatSortableDisplayFormYMD( this, new StringBuilder() ).toString();
    }

    public static CalendarYMD fromYMD( String pToYMD )
            throws IllegalArgumentException
    {
        return fromStringForm( pToYMD, "//" );
    }

    @Override
    public final String toSQLvalue()
    {
        return formatSQLvalueYMD( this, new StringBuilder() ).toString();
    }

    public static CalendarYMD fromSQLvalue( String pToSQLvalue )
    {
        return fromStringForm( pToSQLvalue, "--" );
    }

    private static CalendarYMD fromStringForm( String pStringForm, String pSequentialSeperators )
    {
        String[] parts = parseSimple( pStringForm, pSequentialSeperators );
        return (parts == null) ? null : //
               new CalendarYMD( parseYear( pStringForm, parts ), //
                                parseMonth( pStringForm, parts ),
                                parseDay( pStringForm, parts ) );
    }

    @Override
    public UtilDateAdaptor toUtilDateAdaptor()
    {
        return UtilDateAdaptor.currentWall( getYear(), getMonth(), getDay() );
    }

    // vvvvvvvvvvvvvvvvvv Non-common Public methods vvvvvvvvvvvvvvvvv

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

    /**
     * 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 day( 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 day( Month.daysIn( getYear(), getMonth() ) );
    }

    /**
     * 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 ) );
    }

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

    /**
     * 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( CalendarAccessorYMD pThem )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "daysTill", pThem );
        int result = compareEm( compare( this.getYear(), pThem.getYear() ),
                                compare( this.getMonth(), pThem.getMonth() ),
                                compare( this.getDay(), pThem.getDay() ) );
        if ( result == EQUAL )
        {
            return 0;
        }
        return (result == LESSER) ? new DaysDiff( this ).till( pThem ) : -new DaysDiff( pThem ).till( this );
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    @Override
    protected CalendarYMD createTypeFrom( Mutable pMutable )
    {
        return new CalendarYMD( pMutable.getYear(), pMutable.getMonth(), pMutable.getDay() );
    }

    @Override
    protected Mutable createMutable( int pNewYear )
    {
        return new Mutable( pNewYear, getMonth(), getDay(), true );
    }

    @Override
    protected Mutable createMutable( int pYear, int pNewMonth )
    {
        return new Mutable( pYear, pNewMonth, getDay(), true );
    }

    @Override
    protected Mutable createMutable( int pYear, int pMonth, int pNewDay )
    {
        return new Mutable( pYear, pMonth, pNewDay, false );
    }

    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++;
            }
        }
    }
}