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

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

/**
 * A Simple Date Range object with variable resolution from the Hour thru the Millisecond.
 */
public final class SimpleDateRange extends CalendarSupport<SimpleDateRange> // TODO: XXX DateFormatControl<SimpleDateRange>
        implements TemporalSimpleType
{
    private static final long serialVersionUID = 1L;

    private CalendarYMD mFromInclusive = null;
    private CalendarYMD mToExclusive = null;

    /**
     * @deprecated - for Serialization
     */
    @SuppressWarnings("deprecation")
    protected SimpleDateRange()
    {
    }

    public SimpleDateRange( String pFormat, CalendarYMD pFromInclusive, CalendarYMD pToExclusive )
    {
        // this( pFormat );
        setFromInclusive( pFromInclusive );
        setToExclusive( pToExclusive );
    }

    public SimpleDateRange copy()
    {
        return new SimpleDateRange( null, // TODO: XXX this.getFormat(),
                                    this.mFromInclusive, this.mToExclusive );
    }

    /**
     * @param pFromInclusive - null means infite past (e.g. beginning of day)
     *
     * @throws IllegalArgumentException if !null and Resolution does NOT match
     */
    public void setFromInclusive( CalendarYMD pFromInclusive )
            throws IllegalArgumentException
    {
        mFromInclusive = checkRes( pFromInclusive );
    }

    /**
     * @return null means infite past (e.g. beginning of day)
     */
    public CalendarYMD getFromInclusive()
    {
        return mFromInclusive;
    }

    /**
     * @param pToExclusive - null means infite past (e.g. beginning of day)
     *
     * @throws IllegalArgumentException if !null and Resolution does NOT match
     */
    public void setToExclusive( CalendarYMD pToExclusive )
            throws IllegalArgumentException
    {
        mToExclusive = checkRes( pToExclusive );
    }

    /**
     * @return null means infite future (e.g. rest of the day)
     */
    public CalendarYMD getToExclusive()
    {
        return mToExclusive;
    }

    private CalendarYMD checkRes( CalendarYMD pToCheck )
            throws IllegalArgumentException
    {
        if ( (pToCheck != null) )
        {
            // TODO: XXX
//            DateRes thisRes = this.getDateRes();
//            DateRes themRes = pToCheck.getDateRes();
//            if ( !thisRes.equals( themRes ) )
//            {
//                throw new IllegalArgumentException( "Expected " + thisRes + ", but got " + themRes );
//            }
        }
        return pToCheck;
    }

    public boolean isValidRangeValid()
    {
        return (mFromInclusive == null) || (mToExclusive == null) || !mToExclusive.afterOrEqual( mFromInclusive );
    }

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

    public boolean equals( SimpleDateRange them )
    {
        return (this == them) || //
               ((them != null) //
                // TODO: XXX && equal( this.getDateRes(), them.getDateRes() ) //
                && equal( this.mFromInclusive, them.mFromInclusive ) //
                && equal( this.mToExclusive, them.mToExclusive ) //
               );
    }

    @Override
    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mFromInclusive ), //
                           calcHashCode( mToExclusive ), //
                           super.hashCode() );
    }

    @Override
    public int compareTo( SimpleDateRange them )
    {
        return compareEm( // TODO: XXX compare( this.getDateRes(), them.getDateRes() ), //
                          compare( this.mFromInclusive, them.mFromInclusive ), //
                          compare( this.mToExclusive, them.mToExclusive ) );
    }

    @Override
    public String toString()
    {
        if ( (mFromInclusive == null) && (mToExclusive == null) )
        {
            return "Whenever";
        }
        if ( mFromInclusive == null )
        {
            return "Whenever-" + mToExclusive;
        }
        if ( mToExclusive == null )
        {
            return mFromInclusive + "-Whenever";
        }
        if ( mToExclusive.afterOrEqual( mFromInclusive ) )
        {
            return mFromInclusive + "!<" + mToExclusive;
        }
        return mFromInclusive + "-" + mToExclusive;
    }
}