package org.litesoft.core.simpletypes;

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

public final class Rect extends CompareSupport<Rect> implements SimpleType
{
    private PointXY mPointXY;
    private SizeXY mSizeXY;

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

    public Rect( PointXY pPointXY, SizeXY pSizeXY )
    {
        UtilsCommon.assertNotNull( "PointXY", mPointXY = pPointXY );
        UtilsCommon.assertNotNull( "SizeXY", mSizeXY = pSizeXY );
    }

    public Rect( Line pLineX, Line pLineY )
    {
        UtilsCommon.assertNotNull( "LineX", pLineX );
        UtilsCommon.assertNotNull( "LineY", pLineY );
        mPointXY = new PointXY( pLineX.getOffset(), pLineY.getOffset() );
        mSizeXY = new SizeXY( pLineX.getLength(), pLineY.getLength() );
    }

    public Rect( int pXpos, int pYpos, int pXsize, int pYsize )
    {
        mPointXY = new PointXY( pXpos, pYpos );
        mSizeXY = new SizeXY( pXsize, pYsize );
    }

    public PointXY getPointXY()
    {
        return mPointXY;
    }

    public SizeXY getSizeXY()
    {
        return mSizeXY;
    }

    public int getXpos()
    {
        return mPointXY.getX();
    }

    public int getYpos()
    {
        return mPointXY.getY();
    }

    public int getXsize()
    {
        return mSizeXY.getX();
    }

    public int getYsize()
    {
        return mSizeXY.getY();
    }

    public int getXleft()
    {
        return getXpos();
    }

    public int getXright()
    {
        return getXpos() + getXsize();
    }

    public int getYtop()
    {
        return getYpos();
    }

    public int getYbottom()
    {
        return getYpos() + getYsize();
    }

    public PointXY getRightBottomPointXY()
    {
        return new PointXY( getXright(), getYbottom() );
    }

    public Line getXline()
    {
        return new Line( getXpos(), getXsize() );
    }

    public Line getYline()
    {
        return new Line( getYpos(), getYsize() );
    }

    private boolean doesOurXlineObscure( int pX )
    {
        return (getXleft() <= pX) && (pX <= getXright());
    }

    private boolean doesOurYlineObscure( int pY )
    {
        return (getYtop() <= pY) && (pY <= getYbottom());
    }

    /**
     * Determine if a PointXY (pPointXY) would be obscured by (covered by / inclusively contained by) 'this'.
     *
     * @param pPointXY !null
     */
    public boolean obscures( PointXY pPointXY )
    {
        return doesOurXlineObscure( pPointXY.getX() ) && doesOurYlineObscure( pPointXY.getY() );
    }

    /**
     * Determine if a Rect (pThem) would be completely obscured by (covered by / completely inclusively contained by) 'this'.
     *
     * @param pThem !null
     */
    public boolean obscures( Rect pThem )
    {
        return obscures( pThem.getPointXY() ) && obscures( pThem.getRightBottomPointXY() );
    }

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

    public boolean equals( Rect them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mPointXY, them.mPointXY ) //
                && equal( this.mSizeXY, them.mSizeXY ) //
               );
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mPointXY ), //
                           calcHashCode( mSizeXY ) );
    }

    /**
     * Order by Points and then Area
     */
    public int compareTo( Rect them )
    {
        return compareEm( compare( this.mPointXY, them.mPointXY ), //
                          compare( this.mSizeXY, them.mSizeXY ) );
    }

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

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

    public StringBuilder appendTo( StringBuilder pSB )
    {
        return pSB.append( "pos" ).append( mPointXY ).append( " size" ).append( mSizeXY );
    }

    /**
     * @return this or a new Rect if pNewPointXY is !null
     */
    public Rect moveTo( PointXY pNewPointXY )
    {
        return (pNewPointXY == null) ? this : new Rect( pNewPointXY, getSizeXY() );
    }

    /**
     * @return this or a new Rect if pNewSizeXY is !null
     */
    public Rect resizeTo( SizeXY pNewSizeXY )
    {
        return (pNewSizeXY == null) ? this : new Rect( getPointXY(), pNewSizeXY );
    }

    /**
     * @return this or a new Rect if size &/ position was changed
     */
    public Rect adjustToBeObscuredBy( Rect pThem )
    {
        if ( pThem == null )
        {
            throw new IllegalArgumentException( "Can NOT shrink to be obscured by 'null' Rectangle" );
        }
        if ( pThem.obscures( this ) )
        {
            return this;
        }
        Line zNewXline = this.getXline().adjustToBeObscuredBy( pThem.getXline() );
        Line zNewYline = this.getYline().adjustToBeObscuredBy( pThem.getYline() );
        return new Rect( zNewXline, zNewYline );
    }
}