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

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.util.*;

/**
 * Firefox Containers can lie / change their minds.  Specifically:
 *
 * The decoration size appears to be able to adjust by 1 pixel under certain conditions (it appears after an explicit sizing).
 *
 * In addition, the size of a container may NOT be the sum of its TD sizes, there appears to be an opportunity for Firefox to
 * mis-calculate the Offsets such that there is an empty pixel between the TDs (this has only been observed when the Table is
 * explicitly sized larger then the natural summed size of the children).
 */
public abstract class MockContainer extends MockRenderableRect implements RenderableContainer
{
    private int mDecorationSizeX = 0;
    private int mDecorationSizeY = 0;

    public MockContainer( String pName )
    {
        super( insureName( pName, "MockContainer_" ) );
    }

    public RenderHelperProcess setSizeX( int pRequestedSizeX )
    {
        return super.setSizeX( pRequestedSizeX ); // For Debugging
    }

    public RenderHelperProcess setSizeY( int pRequestedSizeY )
    {
        return super.setSizeY( pRequestedSizeY ); // For Debugging
    }

    public void renderingParticipationChanged()
    {
        RenderingParticipationChangedHelper.participationChanged( this, getChildren() );
    }

    protected final void LLsetDecorationSizeX( int pDecorationSizeX )
    {
        mDecorationSizeX = Integers.assertNonNegative( "DecorationSizeX", pDecorationSizeX );
        changedPosOrSize();
    }

    protected final void LLsetDecorationSizeY( int pDecorationSizeY )
    {
        mDecorationSizeY = Integers.assertNonNegative( "DecorationSizeY", pDecorationSizeY );
        changedPosOrSize();
    }

    public final int getDecorationSizeX()
    {
        return mDecorationSizeX;
    }

    public final int getDecorationSizeY()
    {
        return mDecorationSizeY;
    }

    abstract public RenderContainerHelper getRenderContainerHelperX();

    abstract public RenderContainerHelper getRenderContainerHelperY();

    public final RenderHelper getRenderHelperX()
    {
        return getRenderContainerHelperX();
    }

    public final RenderHelper getRenderHelperY()
    {
        return getRenderContainerHelperY();
    }

    public boolean removeChild( MockNativeRect pNativeRect )
    {
        if ( !isChild( pNativeRect ) )
        {
            return false;
        }
        pNativeRect.setParent( null );
        return true;
    }

    abstract public MockNativeRect[] getChildren();

    /**
     * @return false if pNativeRect is null, otherwise True if it is currently a child of "this"
     */
    public boolean isChild( MockNativeRect pNativeRect )
    {
        MockNativeRect[] zChildren = getChildren();
        for ( MockNativeRect zChild : zChildren )
        {
            if ( pNativeRect == zChild )
            {
                return true;
            }
        }
        return false;
    }

    /**
     * called by child to tell Container we just had our parent set
     */
    protected void LLchildAdded( MockNativeRect pNativeRect )
    {
        if ( !isChild( pNativeRect ) )
        {
            throw notAchild( pNativeRect, "add", "probably via its' setParent method to" );
        }
        if ( isAttached() )
        {
            pNativeRect.justAttached();
        }
    }

    /**
     * called by child to tell Container we just had our parent cleared
     */
    protected void LLchildRemoved( MockNativeRect pNativeRect )
    {
        if ( !isChild( pNativeRect ) )
        {
            throw notAchild( pNativeRect, "remove", "but not currently a child of" );
        }
        if ( isAttached() )
        {
            pNativeRect.justDetached();
        }
        getRenderContainerHelperX().childRemoved( pNativeRect );
        getRenderContainerHelperY().childRemoved( pNativeRect );
        LLremoveChild( pNativeRect );
    }

    abstract protected void LLremoveChild( MockNativeRect pNativeRect );

    protected void justAttached()
    {
        native_justAttached();
        MockNativeRect[] zChildren = getChildren();
        for ( MockNativeRect zChild : zChildren )
        {
            zChild.justAttached();
        }
        renderingParticipationChanged();
    }

    protected void justDetached()
    {
        native_justDetached();
        MockNativeRect[] zChildren = getChildren();
        for ( MockNativeRect zChild : zChildren )
        {
            zChild.justDetached();
        }
        renderingParticipationChanged();
    }

    public StringBuilder toStringBuilder( StringBuilder pSB, int pDepth )
    {
        super.toStringBuilder( pSB, pDepth++ );
        MockNativeRect[] zChildren = getChildren();
        for ( MockNativeRect zChild : zChildren )
        {
            LineIndentUtil.newLine( pSB, pDepth );
            zChild.toStringBuilder( pSB, pDepth );
        }
        return pSB;
    }

    protected void appendPostSize( StringBuilder pSB )
    {
        if ( mDecorationSizeX != 0 || mDecorationSizeY != 0 )
        {
            appendTo( pSB, "-(", mDecorationSizeX, mDecorationSizeX, mDecorationSizeY, mDecorationSizeY );
        }
    }

    private IllegalStateException notAchild( MockNativeRect pNativeRect, String pWhat, String pWhy )
    {
        StringBuilder sb = new StringBuilder().append( "Attempt to " ).append( pWhat ).append( " a child:" );
        LineIndentUtil.newLine( sb, 2 );
        if ( pNativeRect == null )
        {
            sb.append( pNativeRect );
        }
        else
        {
            pNativeRect.toStringBuilder( sb, 2 );
        }
        LineIndentUtil.newLine( sb, 1 );
        sb.append( pWhy ).append( ":" );
        LineIndentUtil.newLine( sb, 2 );
        toStringBuilder( sb, 2 );
        return new IllegalStateException( sb.toString() );
    }

    protected interface SizeCalculator
    {
        public int calculate( MockNativeRect[] pChildren, RenderDimensionAdapter pDimensionAdapter );
    }

    protected static class Sum_SC implements SizeCalculator
    {
        public static final SizeCalculator INSTANCE = new Sum_SC();

        private Sum_SC()
        {
        }

        public int calculate( MockNativeRect[] pChildren, RenderDimensionAdapter pDimensionAdapter )
        {
            int rv = 0;
            for ( MockNativeRect zChild : pChildren )
            {
                rv += pDimensionAdapter.getSize( zChild );
            }
            return rv;
        }
    }

    protected static class Max_SC implements SizeCalculator
    {
        public static final SizeCalculator INSTANCE = new Max_SC();

        private Max_SC()
        {
        }

        public int calculate( MockNativeRect[] pChildren, RenderDimensionAdapter pDimensionAdapter )
        {
            int rv = 0;
            for ( MockNativeRect zChild : pChildren )
            {
                rv = Math.max( rv, pDimensionAdapter.getSize( zChild ) );
            }
            return rv;
        }
    }
}