package org.litesoft.core.simpletypes.temporal;

import java.util.*;

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

/**
 * A Simple date that acts as a proxy for a java.util.Date (burying the depricated method use) providing
 * varying levels of resolution based on the Format String (which supports formatting similar to SimpledateFormat).
 * <p/>
 * <pre>
 *     y  	Year    - YY (1996 becomes 96),
 *                    otherwise it is the complete Year, eg: 1996, 2001, 10050.
 *     M 	Month   - M generates no leading 0 months as numbers,
 *                    MM produces 2 digit month numbers,
 *                    MMM produces 3 letter month abbreviated form,
 *                    MMMM (4 or more) produces the full form.
 *     d 	Day     - d generates no leading 0 day of month as numbers,
 *                    dd produces 2 digit day of month numbers.
 * </pre>
 */
public final class SimpleDate extends DateFormatControl<SimpleDate> implements YMDaccessor,
                                                                               SQLvalueable
{
    private int mYear, mMonth, mDay;

    /**
     * @deprecated - for Serialization
     */
    protected SimpleDate()
    {
    }

    private SimpleDate( String pFormat )
    {
        super( pFormat );
    }

    public SimpleDate( String pFormat, int pYear )
            throws IllegalArgumentException
    {
        this( pFormat );
        noMonthProvided();
        noDayProvided();
        setYear( pYear );
    }

    public SimpleDate( String pFormat, int pYear, int pMonth )
            throws IllegalArgumentException
    {
        this( pFormat );
        noDayProvided();
        setYearAndMonth( pYear, pMonth );
    }

    public SimpleDate( String pFormat, int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        this( pFormat );
        setDate( pYear, pMonth, pDay );
    }

    public SimpleDate( int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        this( DEFAULT_DATE_FORMAT, pYear, pMonth, pDay );
    }

    public SimpleDate( String pFormat, Date pDate )
            throws IllegalArgumentException
    {
        this( pFormat );
        setDate( pDate );
    }

    public SimpleDate( Date pDate )
            throws IllegalArgumentException
    {
        this( DEFAULT_DATE_FORMAT, pDate );
    }

    public SimpleDate( String pFormat, SimpleDate pDate )
            throws IllegalArgumentException
    {
        this( pFormat );
        setDate( pDate );
    }

    public SimpleDate( String pFormat, UtilDateAdaptor pDate )
            throws IllegalArgumentException
    {
        this( pFormat );
        setDate( pDate );
    }

    public SimpleDate copy()
    {
        return new SimpleDate( getFormat(), this );
    }

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

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

    public int getYear()
    {
        return mYear;
    }

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

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

    public UtilDateAdaptor getUtilDateAdaptor()
    {
        return new UtilDateAdaptor( mYear, mMonth, mDay );
    }

    public Date getDate()
    {
        return getUtilDateAdaptor().getDate();
    }

    public void setDate( UtilDateAdaptor pDate )
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( pDate, getDateRes() );
    }

    public void setDate( Date pDate )
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( new UtilDateAdaptor( pDate, 0 ), DateRes.ToDAY );
    }

    public void setDate( SimpleDate pDate )
            throws IllegalArgumentException
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( pDate, pDate.getDateRes() );
    }

    private void setDateToResolution( YMDaccessor pDate, DateRes pDateRes )
            throws IllegalArgumentException
    {
        int dYear = pDate.getYear();
        int dMonth = mMonth;
        int dDay = mDay;
        switch ( pDateRes.getIndex() )
        {
            case DateRes.DAYindex:
                dDay = pDate.getDay();
                // Fall thru
            case DateRes.MONTHindex:
                dMonth = pDate.getMonth();
                // Fall thru
            default:
                break;
        }
        if ( isValidToDay() )
        {
            setDate( dYear, dMonth, dDay );
        }
        else if ( isValidToMonth() )
        {
            setYearAndMonth( dYear, dMonth );
        }
        else
        {
            setYear( dYear );
        }
    }

    public void setDate( int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        monthProvided( pMonth );
        dayProvided( pDay );
        validate( pYear, pMonth, pDay );
        mYear = pYear;
        mMonth = pMonth;
        mDay = pDay;
    }

    public void setYearAndMonth( int pYear, int pMonth )
            throws IllegalArgumentException
    {
        monthProvided( pMonth );
        validate( pYear, pMonth, mDay );
        mYear = pYear;
        mMonth = pMonth;
    }

    public void setMonthAndDay( int pMonth, int pDay )
            throws IllegalArgumentException
    {
        monthProvided( pMonth );
        dayProvided( pDay );
        validate( mYear, pMonth, pDay );
        mMonth = pMonth;
        mDay = pDay;
    }

    public void setYear( int pYear )
            throws IllegalArgumentException
    {
        validate( pYear, mMonth, mDay );
        mYear = pYear;
    }

    public void setMonth( int pMonth )
            throws IllegalArgumentException
    {
        monthProvided( pMonth );
        validate( mYear, pMonth, mDay );
        mMonth = pMonth;
    }

    public void setDay( int pDay )
            throws IllegalArgumentException
    {
        dayProvided( pDay );
        validate( mYear, mMonth, pDay );
        mDay = pDay;
    }

    /**
     * if after add pYears if was LeapDay and can not be LeapDay will be 1Mar.
     */
    public void addYears( int pYears )
    {
        if ( pYears != 0 )
        {
            LLadjustYears( mYear + pYears, true );
        }
    }

    /**
     * if after minus pYears if was LeapDay and can not be LeapDay will be 28Feb.
     */
    public void minusYears( int pYears )
    {
        if ( pYears != 0 )
        {
            LLadjustYears( mYear - pYears, false );
        }
    }

    private void LLadjustYears( int pNewYear, boolean pAdjustForward )
    {
        mYear = pNewYear;
        LLadjust( pAdjustForward );
    }

    /**
     * if after add pMonth there are insufficent days in the new month, the date will be set to the 1st of the next month.
     */
    public void addMonths( int pMonths )
            throws IllegalArgumentException
    {
        validateMonthAdjustable();
        if ( pMonths != 0 )
        {
            LLadjustMonths( 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
     */
    public void minusMonths( int pMonths )
            throws IllegalArgumentException
    {
        validateMonthAdjustable();
        if ( pMonths != 0 )
        {
            LLadjustMonths( mMonth - pMonths, false );
        }
    }

    private void LLadjustMonths( int pNewMonth, boolean pAdjustForward )
    {
        mMonth = pNewMonth;
        while ( mMonth > 12 )
        {
            mYear++;
            mMonth -= 12;
        }
        while ( mMonth < 1 )
        {
            mYear--;
            mMonth += 12;
        }
        LLadjust( pAdjustForward );
    }

    private void LLadjust( boolean pAdjustForward )
    {
        if ( isValidToDay() ) // if Not, then any year works with any month
        {
            int maxDaysInMonth = daysInMonth( mYear, mMonth );
            if ( maxDaysInMonth < mDay )
            {
                mDay = maxDaysInMonth;
                if ( pAdjustForward )
                {
                    LLaddDays( 1 );
                }
            }
        }
    }

    public void addDays( int pDays )
            throws IllegalArgumentException
    {
        validateDayAdjustable();
        if ( pDays < 0 )
        {
            LLminusDays( -pDays );
        }
        else if ( pDays > 0 )
        {
            LLaddDays( pDays );
        }
    }

    public void minusDays( int pDays )
            throws IllegalArgumentException
    {
        validateDayAdjustable();
        if ( pDays < 0 )
        {
            LLaddDays( -pDays );
        }
        else if ( pDays > 0 )
        {
            LLminusDays( pDays );
        }
    }

    private void LLaddDays( int pDays )
    {
        mDay += pDays;
        for ( int maxDaysInMonth; (maxDaysInMonth = daysInMonth( mYear, mMonth )) < mDay; )
        {
            mDay -= maxDaysInMonth;
            if ( ++mMonth > 12 )
            {
                mMonth = 1;
                mYear++;
            }
        }
    }

    private void LLminusDays( int pDays )
    {
        mDay -= pDays;
        while ( mDay < 1 )
        {
            if ( --mMonth < 1 )
            {
                mMonth = 12;
                mYear--;
            }
            mDay += daysInMonth( mYear, mMonth );
        }
    }

    /**
     * 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( SimpleDate pThem )
            throws IllegalArgumentException
    {
        validateValidToDay( "daysTill", pThem );
        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( SimpleDate 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( SimpleDate pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "after", 1 );
    }

    private boolean LLbeforeOrAfter( SimpleDate 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 );
    }

    /**
     * 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
    {
        undefinedResultIfNull( "daysTill", pThem );
        return daysTill( new SimpleDate( getFormat(), 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
    {
        undefinedResultIfNull( "after", pThem );
        return after( new SimpleDate( getFormat(), 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
    {
        undefinedResultIfNull( "before", pThem );
        return before( new SimpleDate( getFormat(), pThem ) );
    }

    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof SimpleDate) && equals( (SimpleDate) o )) || ((o instanceof Date) && equals( (Date) o ));
    }

    public boolean equals( Date pDate )
    {
        return (pDate != null) && equals( new SimpleDate( getFormat(), pDate ) );
    }

    public boolean equals( SimpleDate them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mYear, them.mYear ) //
                && equal( this.mMonth, them.mMonth ) //
                && equal( this.mDay, them.mDay ) //
               );
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mYear ), //
                           calcHashCode( mMonth ), //
                           calcHashCode( mDay ) );
    }

    public int compareTo( SimpleDate them )
    {
        return compareEm( compare( this.mYear, them.mYear ), //
                          compare( this.mMonth, them.mMonth ), //
                          compare( this.mDay, them.mDay ) );
    }

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

    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        Chunk[] chunks = getToStringChunks( this );
        for ( Chunk chunk : chunks )
        {
            sb.append( chunk );
        }
        return sb.toString();
    }

    public String toYMD()
    {
        return toYMD( this );
    }

    public static String toYMD( SimpleDate pFromYMD )
    {
        if ( pFromYMD == null )
        {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        sb.append( pFromYMD.getYear() );
        if ( pFromYMD.isValidToMonth() )
        {
            sb.append( '/' ).append( new MM_Chunk( pFromYMD ) );
            if ( pFromYMD.isValidToDay() )
            {
                sb.append( '/' ).append( new dd_Chunk( pFromYMD ) );
            }
        }
        return sb.toString();
    }

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

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

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

        public int till( YMDaccessor 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 += isLeapYear( mYear ) ? 366 : 365;
                }
            }
            while ( mMonth < pThem.getMonth() )
            {
                advanceTo1stOfNextMonth();
            }
            return mDiff + (pThem.getDay() - mDay);
        }

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

    protected void validateMonthAdjustable()
            throws IllegalArgumentException
    {
        if ( !isValidToMonth() )
        {
            throw doesNotContain( DateRes.ToMONTH, ", but Month adjustment attempted" );
        }
    }

    protected void validateDayAdjustable()
            throws IllegalArgumentException
    {
        if ( !isValidToDay() )
        {
            throw doesNotContain( DateRes.ToDAY, ", but Day adjustment attempted" );
        }
    }

    private void validateValidToDay( String pWhat, SimpleDate pThem )
            throws IllegalArgumentException
    {
        if ( !isValidToDay() )
        {
            throw doesNotContain( DateRes.ToDAY, ", but " + pWhat + " attempted" );
        }
        undefinedResultIfNull( pWhat, pThem );
        if ( !pThem.isValidToDay() )
        {
            throw new IllegalArgumentException( "Parameter to " + pWhat + " does NOT have Day resolution" );
        }
    }

    public Object toSQLvalue()
    {
        return new java.sql.Date( getDate().getTime() );
    }
}