/**
 * Component layout for Ext.form.FieldSet components
 * @private
 */
Ext.define('Ext.layout.component.FieldSet', {
    extend: 'Ext.layout.component.Body',
    alias: ['layout.fieldset'],

    type: 'fieldset',

    defaultCollapsedWidth: 100,

    beforeLayoutCycle: function(ownerContext) {
        if (ownerContext.target.collapsed) {
            ownerContext.heightModel = this.sizeModels.shrinkWrap;
        }
    },

    beginLayout: function(ownerContext) {
        var legend = this.owner.legend;

        this.callParent([ownerContext]);

        if (legend) {
            ownerContext.legendContext = ownerContext.context.getCmp(legend);
        }
    },

    beginLayoutCycle: function(ownerContext) {
        var target = ownerContext.target,
            lastSize;

        this.callParent(arguments);

        // Each time we begin (2nd+ would be due to invalidate) we need to publish the
        // known contentHeight if we are collapsed:
        //
        if (target.collapsed) {
            ownerContext.setContentHeight(0);
            // if we're collapsed, ignore a minHeight because it's likely going to
            // be greater than the collapsed height
            ownerContext.restoreMinHeight = target.minHeight;
            delete target.minHeight;

            // If we are also shrinkWrap width, we must provide a contentWidth (since the
            // container layout is not going to run).
            //
            if (ownerContext.widthModel.shrinkWrap) {
                lastSize = this.lastComponentSize;
                ownerContext.setContentWidth(
                    (lastSize && lastSize.contentWidth) || this.defaultCollapsedWidth
                );
            }
        }
    },

    finishedLayout: function(ownerContext) {
        var owner = this.owner,
            restore = ownerContext.restoreMinHeight;

        this.callParent(arguments);

        if (restore) {
            owner.minHeight = restore;
        }
    },

    calculateOwnerWidthFromContentWidth: function(ownerContext, contentWidth) {
        var legendContext = ownerContext.legendContext;

        if (legendContext) {
            contentWidth = Math.max(contentWidth, legendContext.getProp('width'));
        }

        return this.callParent([ownerContext, contentWidth]);
    },

    calculateOwnerHeightFromContentHeight: function(ownerContext, contentHeight) {
        var border = ownerContext.getBorderInfo(),
            legendContext = ownerContext.legendContext;

        // Height of fieldset is content height plus top border width (which is either the
        // legend height or top border width) plus bottom border width
        return ownerContext.getProp('contentHeight') +
               ownerContext.getPaddingInfo().height +
               // In IE8m the top padding is on the body el
               (Ext.isIE8 ? ownerContext.bodyContext.getPaddingInfo().top : 0) +
               (legendContext ? legendContext.getProp('height') : border.top) +
               border.bottom;
    },

    publishInnerHeight: function(ownerContext, height) {
        // Subtract the legend off here and pass it up to the body
        // We do this because we don't want to set an incorrect body height
        // and then setting it again with the correct value
        var legendContext = ownerContext.legendContext,
            legendHeight = 0;

        if (legendContext) {
            legendHeight = legendContext.getProp('height');
        }

        if (legendHeight === undefined) {
            this.done = false;
        }
        else {
            this.callParent([ownerContext, height - legendHeight]);
        }
    },

    getLayoutItems: function() {
        var legend = this.owner.legend;

        return legend ? [legend] : [];
    }
});