// 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 Time Range object with variable resolution from the Hour thru the Millisecond.
 */
public final class SimpleTimeRange extends AbstractWithTimeRes<SimpleTimeRange> implements TemporalSimpleType
{
    private static final long serialVersionUID = 1L;

    private SimpleTime mFromInclusive = null;
    private SimpleTime mToExclusive = null;

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

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

    public SimpleTimeRange( TimeRes pResolution, SimpleTime pFromInclusive, SimpleTime pToExclusive )
    {
        this( pResolution );
        setFromInclusive( pFromInclusive );
        setToExclusive( pToExclusive );
    }

    public SimpleTimeRange copy()
    {
        return new SimpleTimeRange( 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( SimpleTime pFromInclusive )
            throws IllegalArgumentException
    {
        mFromInclusive = checkRes( pFromInclusive );
    }

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

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

    private SimpleTime checkRes( SimpleTime 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 SimpleTimeRange) && equals( (SimpleTimeRange) o ));
    }

    public boolean equals( SimpleTimeRange 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( SimpleTimeRange 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;
    }
}