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

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.nonpublic.*;

public final class Line extends CompareSupport<Line> implements SimpleType
{
    private static final long serialVersionUID = 1L;

    private /* final */ int mOffset;
    private /* final */ int mLength;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected Line()
    {
    }

    public Line( int pOffset, int pLength )
    {
        mOffset = pOffset;
        if ( (mLength = pLength) < 0 )
        {
            throw new IllegalArgumentException( "A Line 'length'" + Numerics.CANNOT_BE_NEGATIVE );
        }
    }

    public int getOffset()
    {
        return mOffset;
    }

    public int getLength()
    {
        return mLength;
    }

    public int getEndOffset()
    {
        return mOffset + (mLength - 1);
    }

    private boolean doWeObscure( int pOffset )
    {
        return (getOffset() <= pOffset) && (pOffset <= getEndOffset());
    }

    /**
     * Determine if a Line would be obscured by (covered by / inclusively contained by) 'this'.
     *
     * @param pThem !null
     */
    public boolean obscures( Line pThem )
    {
        return doWeObscure( pThem.getOffset() ) && doWeObscure( pThem.getEndOffset() );
    }

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

    public boolean equals( Line them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mOffset, them.mOffset ) //
                && equal( this.mLength, them.mLength ) //
               );
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mOffset ), //
                           calcHashCode( mLength ) );
    }

    /**
     * Order by Offsets and then Lengths
     */
    public int compareTo( Line them )
    {
        return compareEm( compare( this.mOffset, them.mOffset ), //
                          compare( this.mLength, them.mLength ) );
    }

    public String toString()
    {
        return toStringBuilder().toString();
    }

    public StringBuilder toStringBuilder()
    {
        return appendTo( new StringBuilder() );
    }

    public StringBuilder appendTo( StringBuilder pSB )
    {
        return pSB.append( "Line @ " ).append( mOffset ).append( " len: " ).append( mLength );
    }

    /**
     * @return this or a new Line if pNewOffset is !null and is a change
     */
    public Line moveTo( Integer pNewOffset )
    {
        return (pNewOffset == null) ? this : moveTo( pNewOffset.intValue() );
    }

    /**
     * @return this or a new Line if pNewOffset is a change
     */
    public Line moveTo( int pNewOffset )
    {
        return (getOffset() == pNewOffset) ? this : new Line( pNewOffset, getLength() );
    }

    /**
     * @return this or a new Line if pNewLength is !null and is a change
     */
    public Line resizeTo( Integer pNewLength )
    {
        return (pNewLength == null) ? this : resizeTo( pNewLength.intValue() );
    }

    /**
     * @return this or a new Line if pNewLength is a change
     */
    public Line resizeTo( int pNewLength )
    {
        return (getLength() == pNewLength) ? this : new Line( getOffset(), pNewLength );
    }

    /**
     * @return this or a new Line if offset &/ length was changed, prefer adjusting offset over length
     */
    public Line adjustToBeObscuredBy( Line pThem )
    {
        if ( pThem == null )
        {
            throw new IllegalArgumentException( "Can NOT adjust to be obscured by 'null' Line" );
        }
        return resizeTo( Math.min( this.getLength(), pThem.getLength() ) ).adjustOffsetToBeObscuredBy( pThem );
    }

    private Line adjustOffsetToBeObscuredBy( Line pThem ) // Note the Lengths are compatible
    {
        if ( this.getOffset() < pThem.getOffset() )
        {
            return moveTo( pThem.getOffset() );
        }
        int zThisEndOffset = this.getEndOffset();
        int zThemEndOffset = pThem.getEndOffset();
        if ( zThisEndOffset > zThemEndOffset )
        {
            return moveTo( this.getOffset() - (zThisEndOffset - zThemEndOffset) );
        }
        return this;
    }
}