// This Source Code is in the Public Domain per: http://unlicense.org
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> implements TemporalSimpleType {
    private static final long serialVersionUID = 1L;

    private SimpleTimestamp mFromInclusive = null;
    private SimpleTimestamp mToExclusive = null;

    /**
     * @deprecated - for Serialization
     */
    @SuppressWarnings("deprecation")
    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 infinite 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 );
    }

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

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

    @Override
    public int compareTo( SimpleTimestampRange them ) {
        return compareEm( compare( this.getTimeRes(), them.getTimeRes() ), //
                          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 ( mFromInclusive.before( mToExclusive ) ) {
            return mFromInclusive + "|" + mToExclusive;
        }
        return mFromInclusive + "!<" + mToExclusive;
    }
}