// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.render;

import org.litesoft.core.typeutils.*;

import java.util.concurrent.atomic.*;

public class MockNativeRect
{
    public static final MockNativeRect[] EMPTY_ARRAY = new MockNativeRect[0];

    private String mName;
    protected int mNaturalSizeX = 0;
    protected int mNaturalSizeY = 0;
    protected int mRequestedSizeX = 0;
    protected int mRequestedSizeY = 0;
    protected int mRequestedRelativePosX = 0;
    protected int mRequestedRelativePosY = 0;
    private int mLastSizeX = 0;
    private int mLastSizeY = 0;
    private int mLastRelativePosX = 0;
    private int mLastRelativePosY = 0;
    private MockContainer mParent = null;
    protected boolean mParticipating = true;

    protected MockNativeRect( String pName )
    {
        mName = insureName( pName, "NativeRect_" );
    }

    public MockNativeRect( String pName, int pNaturalSizeX, int pNaturalSizeY )
    {
        this( pName );
        mNaturalSizeX = Integers.assertNonNegative( "NaturalSizeX", pNaturalSizeX );
        mNaturalSizeY = Integers.assertNonNegative( "NaturalSizeY", pNaturalSizeY );
    }

    public String getName()
    {
        return mName;
    }

    public final int getSizeX()
    {
        return reportingCorrectly() ? mLastSizeX = LLgetCorrectSizeX() : mLastSizeX;
    }

    protected int LLgetCorrectSizeX()
    {
        return LLgetExpectedSizeX();
    }

    private int LLgetExpectedSizeX()
    {
        return (mRequestedSizeX != 0) ? mRequestedSizeX : mNaturalSizeX;
    }

    public final int getSizeY()
    {
        return reportingCorrectly() ? mLastSizeY = LLgetCorrectSizeY() : mLastSizeY;
    }

    protected int LLgetCorrectSizeY()
    {
        return LLgetExpectedSizeY();
    }

    private int LLgetExpectedSizeY()
    {
        return (mRequestedSizeY != 0) ? mRequestedSizeY : mNaturalSizeY;
    }

    public final int getRelativePosX()
    {
        return reportingCorrectly() ? mLastRelativePosX = LLgetCorrectRelativePosX() : mLastRelativePosX;
    }

    protected int LLgetCorrectRelativePosX()
    {
        return mRequestedRelativePosX;
    }

    public final int getRelativePosY()
    {
        return reportingCorrectly() ? mLastRelativePosY = LLgetCorrectRelativePosY() : mLastRelativePosY;
    }

    protected int LLgetCorrectRelativePosY()
    {
        return mRequestedRelativePosY;
    }

    public RenderHelperProcess setSizeX( int pRequestedSizeX )
    {
        throw new UnsupportedOperationException( "setSizeX( " + pRequestedSizeX + ") on: " + getName() );
    }

    public RenderHelperProcess setSizeY( int pRequestedSizeY )
    {
        throw new UnsupportedOperationException( "setSizeY( " + pRequestedSizeY + ") on: " + getName() );
    }

    public void setRelativePosX( int pRequestedRelativePosX )
    {
        throw new UnsupportedOperationException( "setRelativePosX( " + pRequestedRelativePosX + ") on: " + getName() );
    }

    public void setRelativePosY( int pRequestedRelativePosY )
    {
        throw new UnsupportedOperationException( "setRelativePosY( " + pRequestedRelativePosY + ") on: " + getName() );
    }

    protected void LLsetSizeX( int pRequestedSizeX )
    {
        mRequestedSizeX = Integers.assertPositive( "SizeX", pRequestedSizeX );
        changedPosOrSize();
    }

    public void LLremoveSetSizeX()
    {
        mRequestedSizeX = 0;
        changedPosOrSize();
    }

    protected void LLsetSizeY( int pRequestedSizeY )
    {
        mRequestedSizeY = Integers.assertPositive( "SizeY", pRequestedSizeY );
        changedPosOrSize();
    }

    public void LLremoveSetSizeY()
    {
        mRequestedSizeY = 0;
        changedPosOrSize();
    }

    protected void LLsetRelativePosX( int pRequestedRelativePosX )
    {
        mRequestedRelativePosX = pRequestedRelativePosX;
        changedPosOrSize();
    }

    protected void LLsetRelativePosY( int pRequestedRelativePosY )
    {
        mRequestedRelativePosY = pRequestedRelativePosY;
        changedPosOrSize();
    }

    protected final void changedPosOrSize()
    {
        if ( isAttachedAndParticipating() )
        {
            setPnAts();
        }
    }

    public MockContainer getParent()
    {
        return mParent;
    }

    public void setParent( MockContainer pParent )
    {
        if ( mParent != null )
        {
            MockContainer zParent = mParent;
            mParent = null;
            zParent.LLchildRemoved( this );
        }
        if ( null != (mParent = pParent) )
        {
            mParent.LLchildAdded( this );
        }
    }

    public boolean isAttached()
    {
        return (mParent != null) && mParent.isAttached();
    }

    /**
     * called by Parent Container when this NativeRect was "justAttached".
     */
    protected void justAttached()
    {
        if ( isParticipating() )
        {
            setPnAts();
        }
    }

    /**
     * called by Parent Container when this NativeRect was "justDetached".
     */
    protected void justDetached()
    {
        clrPnAts();
    }

    public boolean isParticipating()
    {
        return mParticipating && (mParent != null) && mParent.isParticipating();
    }

    public void setParticipating( boolean pParticipating )
    {
        if ( !(mParticipating = pParticipating) )
        {
            clrPnAts();
        }
        else if ( isAttached() )
        {
            setPnAts();
        }
    }

    public boolean isAttachedAndParticipating()
    {
        return isAttached() && isParticipating();
    }

    public String toString()
    {
        StringBuilder zSB = new StringBuilder();
        return toStringBuilder( zSB, 0 ).toString();
    }

    public StringBuilder toStringBuilder( StringBuilder pSB, int pDepth )
    {
        pSB.append( mName );

        int zReportedSizeX = getSizeX();
        int zReportedSizeY = getSizeY();
        int zReportedRelativePosX = getRelativePosX();
        int zReportedRelativePosY = getRelativePosY();

        appendTo( pSB, " (", //
                  zReportedSizeX, LLgetExpectedSizeX(), zReportedSizeY, LLgetExpectedSizeY() );

        appendPostSize( pSB );

        if ( (zReportedRelativePosX != 0) || (mRequestedRelativePosX != 0) ||
             (zReportedRelativePosY != 0) || (mRequestedRelativePosY != 0) )
        {
            appendTo( pSB, " @ (", //
                      zReportedRelativePosX, mRequestedRelativePosX, zReportedRelativePosY, mRequestedRelativePosY );
        }

        return pSB;
    }

    protected void appendPostSize( StringBuilder pSB )
    {
    }

    protected final void appendTo( StringBuilder pSB, String pPrefix, //
                                   int pReportedX, int pRequestedX, int pReportedY, int pRequestedY )
    {
        appendTo( pSB, pPrefix, pReportedX, pRequestedX );
        appendTo( pSB, ",", pReportedY, pRequestedY );
        pSB.append( ")" );
    }

    private void appendTo( StringBuilder pSB, String pPrefix, int pReported, int pRequested )
    {
        pSB.append( pPrefix ).append( pReported );
        if ( (pReported != pRequested) && (pRequested != 0) )
        {
            pSB.append( "!=" ).append( pRequested );
        }
    }

    private static final AtomicInteger sSequenceSource = new AtomicInteger( 0 );

    protected static String insureName( String pName, String pDefaultPrefix )
    {
        return (null != (pName = Strings.noEmpty( pName ))) ? //
               pName : //
               pDefaultPrefix + sSequenceSource.incrementAndGet();
    }

    private Long mPnAts = null;

    private void setPnAts()
    {
        mPnAts = Timestamps.now().getTime();
    }

    private void clrPnAts()
    {
        mPnAts = null;
    }

    protected final boolean reportingCorrectly()
    {
        if ( mPnAts != null )
        {
            long zTime = Timestamps.now().getTime();
            return (zTime >= (mPnAts + 10));
        }
        return false;
    }
}