package org.litesoft.render;

public class DistributeToChildren
{
    private ChildAdjustStruct m1stChild = null;
    private int mCount = 0;

    public DistributeToChildren add( ChildAdjustStruct pStruct )
    {
        mCount++;
        if ( m1stChild == null )
        {
            m1stChild = pStruct;
        }
        else
        {
            pStruct.insertBefore( m1stChild );
        }
        return this;
    }

    public boolean hasChildren()
    {
        return (mCount != 0);
    }

    public ChildAdjustStruct[] getChildren()
    {
        return mChildren;
    }

    private ChildAdjustStruct[] mChildren = null;

    private ChildAdjustStruct buildChildren( int pIndexOfLastAdjusted )
    {
        ChildAdjustStruct rv = m1stChild;
        mChildren = new ChildAdjustStruct[mCount];
        ChildAdjustStruct zChild = m1stChild;
        for ( int i = 0; i < mChildren.length; i++ )
        {
            if ( zChild.getIndex() <= pIndexOfLastAdjusted )
            {
                rv = zChild;
            }
            mChildren[i] = zChild;
            zChild = zChild.mNext;
        }
        return rv;
    }

    private void freeChildren()
    {
        for ( ChildAdjustStruct zChild : mChildren )
        {
            zChild.clearLinks();
        }
    }

    /**
     * @param pAdjustSizeBy !0
     */
    public int distribute( int pAdjustSizeBy, int pIndexOfLastAdjusted )
    {
        ChildAdjustStruct zLastAdjusted = buildChildren( pIndexOfLastAdjusted );
        zLastAdjusted = (pAdjustSizeBy > 0) ? //
                        increaseBy( pAdjustSizeBy, zLastAdjusted ) :
                        decreaseBy( -pAdjustSizeBy, zLastAdjusted );
        freeChildren();
        return zLastAdjusted.getIndex();
    }

    /**
     * @param pIncreaseBy > 0
     */
    private ChildAdjustStruct increaseBy( int pIncreaseBy, ChildAdjustStruct pLastAdjusted )
    {
        int zPerInc = pIncreaseBy / mCount;
        if ( zPerInc > 0 )
        {
            // Since going all the way around, pLastAdjusted will be back at the starting point
            for ( int i = 0; i < mCount; i++ )
            {
                pIncreaseBy -= (pLastAdjusted = pLastAdjusted.mNext).incAdjustBy( zPerInc );
            }
        }
        while ( pIncreaseBy > 0 )
        {
            pIncreaseBy -= (pLastAdjusted = pLastAdjusted.mNext).incAdjustBy();
        }
        return pLastAdjusted;
    }

    /**
     * @param pDecreaseBy > 0
     */
    private ChildAdjustStruct decreaseBy( int pDecreaseBy, ChildAdjustStruct pLastAdjusted )
    {
        int zPerInc = pDecreaseBy / mCount;
        if ( zPerInc > 0 )
        {
            // Since going all the way around, pLastAdjusted will be back at the starting point
            for ( int i = 0; i < mCount; i++ )
            {
                pDecreaseBy -= pLastAdjusted.decAdjustBy( zPerInc );
                pLastAdjusted = pLastAdjusted.mPrev;
            }
        }
        while ( pDecreaseBy > 0 )
        {
            ChildAdjustStruct zPrev = pLastAdjusted.mPrev;
            int zDecreasedBy = pLastAdjusted.decAdjustBy();
            pDecreaseBy -= zDecreasedBy;
            if ( zDecreasedBy == 0 )
            {
                if ( zPrev == null ) // Unlinked last node - we can make no more progress
                {
                    return pLastAdjusted;
                }
                pLastAdjusted.unlink();
            }
            pLastAdjusted = zPrev;
        }
        return pLastAdjusted;
    }

    public String toString()
    {
        StringBuilder sb = new StringBuilder().append( "DTC(" ).append( mCount ).append( "): " );
        if ( mChildren == null )
        {
            sb.append( mChildren );
        }
        else
        {
            sb.append( mChildren[0] );
            for ( int i = 1; i < mChildren.length; i++ )
            {
                sb.append( ", " ).append( mChildren[i] );
            }
        }
        return sb.toString();
    }
}