// 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.*;
import org.litesoft.core.typeutils.*;

/**
 * A Simple Date Range object that assumes that both dates are Inclusive
 */
public final class CalendarYMDRange extends CalendarSupport<CalendarYMDRange>
        implements TemporalSimpleType
{
    private static final long serialVersionUID = 1L;

    private CalendarYMD mFromInclusive = null;
    private CalendarYMD mThruInclusive = null;

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

    /**
     * @param pFromInclusive - null means infinite past
     * @param pThruInclusive - null means infinite future
     */
    public CalendarYMDRange( CalendarYMD pFromInclusive, CalendarYMD pThruInclusive )
    {
        mFromInclusive = pFromInclusive;
        mThruInclusive = pThruInclusive;
        if ( (mFromInclusive != null) && (mThruInclusive != null) && !mFromInclusive.beforeOrEqual( mThruInclusive ) )
        {
            throw new IllegalArgumentException( "The From Date '" + mFromInclusive + "' is After the Thru Date '" + mThruInclusive + "'" );
        }
    }

    /**
     * @return null means infinite past
     */
    public CalendarYMD getFromInclusive()
    {
        return mFromInclusive;
    }

    /**
     * @return null means infinite future
     */
    public CalendarYMD getThruInclusive()
    {
        return mThruInclusive;
    }

    public boolean isFromOpen()
    {
        return mFromInclusive == null;
    }

    public boolean isThruOpen()
    {
        return mThruInclusive == null;
    }

    public boolean isAllTime()
    {
        return (isFromOpen()) && (isThruOpen());
    }

    /**
     * @param pDate !null
     *
     * @return true if <code>pDate</code> falls within <code>this</code> range
     *
     * @throws IllegalArgumentException if <code>pDate</code> is null
     */
    public boolean contains( CalendarYMD pDate )
            throws IllegalArgumentException
    {
        Objects.assertNotNull( "Date", pDate );
        if ( isAllTime() )
        {
            return true;
        }
        if ( isFromOpen() )
        {
            return pDate.beforeOrEqual( mThruInclusive );
        }
        if ( isThruOpen() )
        {
            return mFromInclusive.beforeOrEqual( pDate );
        }
        return mFromInclusive.beforeOrEqual( pDate ) && pDate.beforeOrEqual( mThruInclusive );
    }

    /**
     * @param them !null
     *
     * @return true if any portion of <code>this</code> are shared with any portion of <code>them</code>.
     *
     * @throws IllegalArgumentException if <code>them</code> is null
     */
    public boolean sharesDates( CalendarYMDRange them )
            throws IllegalArgumentException
    {
        Objects.assertNotNull( "them", them );
        if ( this.isAllTime() || them.isAllTime() || (this.isFromOpen() && them.isFromOpen()) || (this.isThruOpen() && them.isThruOpen()) )
        {
            return true;
        }
        if ( this.isFromOpen() ) // !them.isFromOpen()
        {
            return them.getFromInclusive().beforeOrEqual( this.getThruInclusive() );
        }
        if ( them.isFromOpen() ) // !this.isFromOpen()
        {
            return this.getFromInclusive().beforeOrEqual( them.getThruInclusive() );
        }
        if ( this.isThruOpen() ) // !them.isThruOpen()
        {
            return this.getFromInclusive().beforeOrEqual( them.getThruInclusive() );
        }
        if ( them.isThruOpen() ) // !this.isThruOpen()
        {
            return them.getFromInclusive().beforeOrEqual( this.getThruInclusive() );
        }
        // Nothing Open!
        return this.getFromInclusive().beforeOrEqual( them.getThruInclusive() ) && them.getFromInclusive().beforeOrEqual( this.getThruInclusive() );
    }

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

    public boolean equals( CalendarYMDRange them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mFromInclusive, them.mFromInclusive ) //
                && equal( this.mThruInclusive, them.mThruInclusive ) //
               );
    }

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

    @Override
    public int compareTo( CalendarYMDRange them )
    {
        return compareEm( compare( this.mFromInclusive, them.mFromInclusive ), //
                          compare( this.mThruInclusive, them.mThruInclusive ) );
    }

    @Override
    public String toString()
    {
        if ( isAllTime() )
        {
            return "Whenever";
        }
        if ( isFromOpen() )
        {
            return "Whenever-" + mThruInclusive;
        }
        if ( isThruOpen() )
        {
            return mFromInclusive + "-Whenever";
        }
        return mFromInclusive + "-" + mThruInclusive;
    }
}