package org.litesoft.core.simpletypes.temporal;

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

/**
 * A Simple Timestamp Range object with variable resolution from the Hour thru the Millisecond.
 */
public final class SimpleTimestampRange extends AbstractWithTimeRes<SimpleTimestampRange>
{
    private SimpleTimestamp mFromInclusive = null;
    private SimpleTimestamp mToExclusive = null;

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

    public SimpleTimestampRange( TimeRes pResolution )
    {
        super( pResolution );
    }

    public SimpleTimestampRange( TimeRes pResolution, SimpleTimestamp pFromInclusive, SimpleTimestamp pToExclusive )
    {
        this( pResolution );
        setFromInclusive( pFromInclusive );
        setToExclusive( pToExclusive );
    }

    public SimpleTimestampRange copy()
    {
        return new SimpleTimestampRange( this.getTimeRes(), 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( SimpleTimestamp pFromInclusive )
            throws IllegalArgumentException
    {
        mFromInclusive = checkRes( pFromInclusive );
    }

    /**
     * @return null means infite past (e.g. beginning of day)
     */
    public SimpleTimestamp 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( SimpleTimestamp pToExclusive )
            throws IllegalArgumentException
    {
        mToExclusive = checkRes( pToExclusive );
    }

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

    private SimpleTimestamp checkRes( SimpleTimestamp pToCheck )
            throws IllegalArgumentException
    {
        if ( (pToCheck != null) )
        {
            TimeRes thisRes = this.getTimeRes();
            TimeRes themRes = pToCheck.getTimeRes();
            if ( !thisRes.equals( themRes ) )
            {
                throw new IllegalArgumentException( "Expected " + thisRes + ", but got " + themRes );
            }
        }
        return pToCheck;
    }

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

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

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

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mFromInclusive ), //
                           calcHashCode( mToExclusive ), //
                           calcHashCode( getTimeRes() ) );
    }

    public int compareTo( SimpleTimestampRange them )
    {
        return compareEm( compare( this.getTimeRes(), them.getTimeRes() ), //
                          compare( this.mFromInclusive, them.mFromInclusive ), //
                          compare( this.mToExclusive, them.mToExclusive ) );
    }

    public String toString()
    {
        if ( (mFromInclusive == null) && (mToExclusive == null) )
        {
            return "Whenever";
        }
        if ( mFromInclusive == null )
        {
            return "Whenever|" + mToExclusive;
        }
        if ( mToExclusive == null )
        {
            return mFromInclusive + "|Whenever";
        }
        if ( mFromInclusive.before( mToExclusive ) )
        {
            return mFromInclusive + "|" + mToExclusive;
        }
        return mFromInclusive + "!<" + mToExclusive;
    }
}