/**
 * DevExtreme (cjs/__internal/grids/data_grid/summary/m_summary.js)
 * Version: 23.1.12
 * Build date: Fri Aug 09 2024
 *
 * Copyright (c) 2012 - 2024 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */
"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.renderSummaryCell = exports.FooterView = void 0;
var _renderer = _interopRequireDefault(require("../../../../core/renderer"));
var _common = require("../../../../core/utils/common");
var _data = require("../../../../core/utils/data");
var _extend = require("../../../../core/utils/extend");
var _iterator = require("../../../../core/utils/iterator");
var _type = require("../../../../core/utils/type");
var _query = _interopRequireDefault(require("../../../../data/query"));
var _store_helper = _interopRequireDefault(require("../../../../data/store_helper"));
var _utils = require("../../../../data/utils");
var _message = _interopRequireDefault(require("../../../../localization/message"));
var _ui = _interopRequireDefault(require("../../../../ui/widget/ui.errors"));
var _m_columns_view = require("../../../grids/grid_core/views/m_columns_view");
var _m_aggregate_calculator = _interopRequireDefault(require("../m_aggregate_calculator"));
var _m_core = _interopRequireDefault(require("../m_core"));
var _m_data_source_adapter = _interopRequireDefault(require("../m_data_source_adapter"));

function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    }
}

function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    _setPrototypeOf(subClass, superClass)
}

function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
        o.__proto__ = p;
        return o
    };
    return _setPrototypeOf(o, p)
}
var DATAGRID_TOTAL_FOOTER_CLASS = "dx-datagrid-total-footer";
var DATAGRID_SUMMARY_ITEM_CLASS = "dx-datagrid-summary-item";
var DATAGRID_TEXT_CONTENT_CLASS = "dx-datagrid-text-content";
var DATAGRID_GROUP_FOOTER_CLASS = "dx-datagrid-group-footer";
var DATAGRID_GROUP_TEXT_CONTENT_CLASS = "dx-datagrid-group-text-content";
var DATAGRID_NOWRAP_CLASS = "dx-datagrid-nowrap";
var DATAGRID_FOOTER_ROW_CLASS = "dx-footer-row";
var DATAGRID_GROUP_FOOTER_ROW_TYPE = "groupFooter";
var DATAGRID_TOTAL_FOOTER_ROW_TYPE = "totalFooter";
var renderSummaryCell = function(cell, options) {
    var $cell = (0, _renderer.default)(cell);
    var column = options.column;
    var summaryItems = options.summaryItems;
    var $summaryItems = [];
    if (!column.command && summaryItems) {
        for (var i = 0; i < summaryItems.length; i++) {
            var summaryItem = summaryItems[i];
            $summaryItems.push((0, _renderer.default)("<div>").css("textAlign", summaryItem.alignment || column.alignment).addClass(DATAGRID_SUMMARY_ITEM_CLASS).addClass(DATAGRID_TEXT_CONTENT_CLASS).addClass(summaryItem.cssClass).toggleClass(DATAGRID_GROUP_TEXT_CONTENT_CLASS, "group" === options.rowType).text(_m_core.default.getSummaryText(summaryItem, options.summaryTexts)))
        }
        $cell.append($summaryItems)
    }
};
exports.renderSummaryCell = renderSummaryCell;
var getSummaryCellOptions = function(that, options) {
    var summaryTexts = that.option("summary.texts") || {};
    return {
        totalItem: options.row,
        summaryItems: options.row.summaryCells[options.columnIndex],
        summaryTexts: summaryTexts
    }
};
var getGroupAggregates = function(data) {
    return data.summary || data.aggregates || []
};
var recalculateWhileEditing = function(that) {
    return that.option("summary.recalculateWhileEditing")
};
var forEachGroup = function forEachGroup(groups, groupCount, callback, path) {
    path = path || [];
    for (var i = 0; i < groups.length; i++) {
        path.push(groups[i].key);
        if (1 === groupCount) {
            callback(path, groups[i].items)
        } else {
            forEachGroup(groups[i].items, groupCount - 1, callback, path)
        }
        path.pop()
    }
};
var applyAddedData = function applyAddedData(data, insertedData, groupLevel) {
    if (groupLevel) {
        return applyAddedData(data, insertedData.map((function(item) {
            return {
                items: [item]
            }
        }), groupLevel - 1))
    }
    return data.concat(insertedData)
};
var applyRemovedData = function applyRemovedData(data, removedData, groupLevel) {
    if (groupLevel) {
        return data.map((function(data) {
            var updatedData = {};
            var updatedItems = applyRemovedData(data.items || [], removedData, groupLevel - 1);
            Object.defineProperty(updatedData, "aggregates", {
                get: function() {
                    return data.aggregates
                },
                set: function(value) {
                    data.aggregates = value
                }
            });
            return (0, _extend.extend)(updatedData, data, {
                items: updatedItems
            })
        }))
    }
    return data.filter((function(data) {
        return removedData.indexOf(data) < 0
    }))
};
var sortGroupsBySummaryCore = function sortGroupsBySummaryCore(items, groups, sortByGroups) {
    if (!items || !groups.length) {
        return items
    }
    var group = groups[0];
    var sorts = sortByGroups[0];
    var query;
    if (group && sorts && sorts.length) {
        query = (0, _query.default)(items);
        (0, _iterator.each)(sorts, (function(index) {
            if (0 === index) {
                query = query.sortBy(this.selector, this.desc)
            } else {
                query = query.thenBy(this.selector, this.desc)
            }
        }));
        query.enumerate().done((function(sortedItems) {
            items = sortedItems
        }))
    }
    groups = groups.slice(1);
    sortByGroups = sortByGroups.slice(1);
    if (groups.length && sortByGroups.length) {
        (0, _iterator.each)(items, (function() {
            this.items = sortGroupsBySummaryCore(this.items, groups, sortByGroups)
        }))
    }
    return items
};
var sortGroupsBySummary = function(data, group, summary) {
    var sortByGroups = summary && summary.sortByGroups && summary.sortByGroups();
    if (sortByGroups && sortByGroups.length) {
        return sortGroupsBySummaryCore(data, group, sortByGroups)
    }
    return data
};
var calculateAggregates = function(that, summary, data, groupLevel) {
    var calculator;
    if (recalculateWhileEditing(that)) {
        var editingController = that._editingController;
        if (editingController) {
            var insertedData = editingController.getInsertedData();
            if (insertedData.length) {
                data = applyAddedData(data, insertedData, groupLevel)
            }
            var removedData = editingController.getRemovedData();
            if (removedData.length) {
                data = applyRemovedData(data, removedData, groupLevel)
            }
        }
    }
    if (summary) {
        calculator = new _m_aggregate_calculator.default({
            totalAggregates: summary.totalAggregates,
            groupAggregates: summary.groupAggregates,
            data: data,
            groupLevel: groupLevel
        });
        calculator.calculate()
    }
    return calculator ? calculator.totalAggregates() : []
};
var FooterView = function(_ColumnsView) {
    _inheritsLoose(FooterView, _ColumnsView);

    function FooterView() {
        return _ColumnsView.apply(this, arguments) || this
    }
    var _proto = FooterView.prototype;
    _proto._getRows = function() {
        return this._dataController.footerItems()
    };
    _proto._getCellOptions = function(options) {
        return (0, _extend.extend)(_ColumnsView.prototype._getCellOptions.call(this, options), getSummaryCellOptions(this, options))
    };
    _proto._renderCellContent = function($cell, options) {
        renderSummaryCell($cell, options);
        _ColumnsView.prototype._renderCellContent.apply(this, arguments)
    };
    _proto._renderCore = function(change) {
        var needUpdateScrollLeft = false;
        var totalItem = this._dataController.footerItems()[0];
        if (!change || !change.columnIndices) {
            this.element().empty().addClass(DATAGRID_TOTAL_FOOTER_CLASS).toggleClass(DATAGRID_NOWRAP_CLASS, !this.option("wordWrapEnabled"));
            needUpdateScrollLeft = true
        }
        if (totalItem && totalItem.summaryCells && totalItem.summaryCells.length) {
            this._updateContent(this._renderTable({
                change: change
            }), change);
            needUpdateScrollLeft && this._updateScrollLeftPosition()
        }
    };
    _proto._updateContent = function($newTable, change) {
        var _this = this;
        if (change && "update" === change.changeType && change.columnIndices) {
            return this.waitAsyncTemplates().done((function() {
                var $row = _this.getTableElement().find(".dx-row");
                var $newRow = $newTable.find(".dx-row");
                _this._updateCells($row, $newRow, change.columnIndices[0])
            }))
        }
        return _ColumnsView.prototype._updateContent.apply(this, arguments)
    };
    _proto._rowClick = function(e) {
        var item = this._dataController.footerItems()[e.rowIndex] || {};
        this.executeAction("onRowClick", (0, _extend.extend)({}, e, item))
    };
    _proto._columnOptionChanged = function(e) {
        var optionNames = e.optionNames;
        if (e.changeTypes.grouping) {
            return
        }
        if (optionNames.width || optionNames.visibleWidth) {
            _ColumnsView.prototype._columnOptionChanged.call(this, e)
        }
    };
    _proto._handleDataChanged = function(e) {
        var changeType = e.changeType;
        if ("update" === e.changeType && e.repaintChangesOnly) {
            if (!e.totalColumnIndices) {
                this.render()
            } else if (e.totalColumnIndices.length) {
                this.render(null, {
                    changeType: "update",
                    columnIndices: [e.totalColumnIndices]
                })
            }
        } else if ("refresh" === changeType || "append" === changeType || "prepend" === changeType) {
            this.render()
        }
    };
    _proto._createRow = function(row) {
        var $row = _ColumnsView.prototype._createRow.apply(this, arguments);
        if (row.rowType === DATAGRID_TOTAL_FOOTER_ROW_TYPE) {
            $row.addClass(DATAGRID_FOOTER_ROW_CLASS)
        }
        return $row
    };
    _proto.getHeight = function() {
        return this.getElementHeight()
    };
    _proto.isVisible = function() {
        return !!this._dataController.footerItems().length
    };
    return FooterView
}(_m_columns_view.ColumnsView);
exports.FooterView = FooterView;
var dataSourceAdapterExtender = function(Base) {
    return function(_Base) {
        _inheritsLoose(SummaryDataSourceAdapterExtender, _Base);

        function SummaryDataSourceAdapterExtender() {
            return _Base.apply(this, arguments) || this
        }
        var _proto2 = SummaryDataSourceAdapterExtender.prototype;
        _proto2.init = function() {
            _Base.prototype.init.apply(this, arguments);
            this._editingController = this.getController("editing");
            this._totalAggregates = [];
            this._summaryGetter = _common.noop
        };
        _proto2.summaryGetter = function(_summaryGetter) {
            if (!arguments.length) {
                return this._summaryGetter
            }
            if ((0, _type.isFunction)(_summaryGetter)) {
                this._summaryGetter = _summaryGetter
            }
        };
        _proto2.summary = function(_summary) {
            if (!arguments.length) {
                return this._summaryGetter()
            }
            this._summaryGetter = function() {
                return _summary
            }
        };
        _proto2.totalAggregates = function() {
            return this._totalAggregates
        };
        _proto2.isLastLevelGroupItemsPagingLocal = function() {
            var summary = this.summary();
            var sortByGroupsInfo = null === summary || void 0 === summary ? void 0 : summary.sortByGroups();
            return null === sortByGroupsInfo || void 0 === sortByGroupsInfo ? void 0 : sortByGroupsInfo.length
        };
        _proto2.sortLastLevelGroupItems = function(items, groups, paths) {
            var groupedItems = _store_helper.default.multiLevelGroup((0, _query.default)(items), groups).toArray();
            var result = [];
            paths.forEach((function(path) {
                forEachGroup(groupedItems, groups.length, (function(itemsPath, items) {
                    if (path.toString() === itemsPath.toString()) {
                        result = result.concat(items)
                    }
                }))
            }));
            return result
        };
        _proto2._customizeRemoteOperations = function(options) {
            var summary = this.summary();
            if (summary) {
                if (options.remoteOperations.summary) {
                    if (!options.isCustomLoading || options.storeLoadOptions.isLoadingAll) {
                        if (options.storeLoadOptions.group) {
                            if (options.remoteOperations.grouping) {
                                options.storeLoadOptions.groupSummary = summary.groupAggregates
                            } else if (summary.groupAggregates.length) {
                                options.remoteOperations.paging = false
                            }
                        }
                        options.storeLoadOptions.totalSummary = summary.totalAggregates
                    }
                } else if (summary.totalAggregates.length || summary.groupAggregates.length && options.storeLoadOptions.group) {
                    options.remoteOperations.paging = false
                }
            }
            _Base.prototype._customizeRemoteOperations.apply(this, arguments);
            var cachedExtra = options.cachedData.extra;
            if ((null === cachedExtra || void 0 === cachedExtra ? void 0 : cachedExtra.summary) && !options.isCustomLoading) {
                options.storeLoadOptions.totalSummary = void 0
            }
        };
        _proto2._handleDataLoadedCore = function(options) {
            var _a, _b;
            var groups = (0, _utils.normalizeSortingInfo)(options.storeLoadOptions.group || options.loadOptions.group || []);
            var remoteOperations = options.remoteOperations || {};
            var summary = this.summaryGetter()(remoteOperations);
            if (!options.isCustomLoading || options.storeLoadOptions.isLoadingAll) {
                if (remoteOperations.summary) {
                    if (!remoteOperations.paging && groups.length && summary) {
                        if (!remoteOperations.grouping) {
                            calculateAggregates(this, {
                                groupAggregates: summary.groupAggregates
                            }, options.data, groups.length)
                        }
                        options.data = sortGroupsBySummary(options.data, groups, summary)
                    }
                } else if (!remoteOperations.paging && summary) {
                    var operationTypes = options.operationTypes || {};
                    var hasOperations = Object.keys(operationTypes).some((function(type) {
                        return operationTypes[type]
                    }));
                    if (!hasOperations || !(null === (_b = null === (_a = options.cachedData) || void 0 === _a ? void 0 : _a.extra) || void 0 === _b ? void 0 : _b.summary) || groups.length && summary.groupAggregates.length) {
                        var totalAggregates = calculateAggregates(this, summary, options.data, groups.length);
                        options.extra = (0, _type.isPlainObject)(options.extra) ? options.extra : {};
                        options.extra.summary = totalAggregates;
                        if (options.cachedData) {
                            options.cachedData.extra = options.extra
                        }
                    }
                    options.data = sortGroupsBySummary(options.data, groups, summary)
                }
            }
            if (!options.isCustomLoading) {
                this._totalAggregates = options.extra && options.extra.summary || this._totalAggregates
            }
            _Base.prototype._handleDataLoadedCore.call(this, options)
        };
        return SummaryDataSourceAdapterExtender
    }(Base)
};
_m_data_source_adapter.default.extend(dataSourceAdapterExtender);
var data = function(Base) {
    return function(_Base2) {
        _inheritsLoose(SummaryDataControllerExtender, _Base2);

        function SummaryDataControllerExtender() {
            return _Base2.apply(this, arguments) || this
        }
        var _proto3 = SummaryDataControllerExtender.prototype;
        _proto3._isDataColumn = function(column) {
            return column && (!(0, _type.isDefined)(column.groupIndex) || column.showWhenGrouped)
        };
        _proto3._isGroupFooterVisible = function() {
            var groupItems = this.option("summary.groupItems") || [];
            for (var i = 0; i < groupItems.length; i++) {
                var groupItem = groupItems[i];
                var column = this._columnsController.columnOption(groupItem.showInColumn || groupItem.column);
                if (groupItem.showInGroupFooter && this._isDataColumn(column)) {
                    return true
                }
            }
            return false
        };
        _proto3._processGroupItems = function(items, groupCount, options) {
            var data = options && options.data;
            var result = _Base2.prototype._processGroupItems.apply(this, arguments);
            if (options) {
                if (void 0 === options.isGroupFooterVisible) {
                    options.isGroupFooterVisible = this._isGroupFooterVisible()
                }
                if (data && data.items && options.isGroupFooterVisible && (options.collectContinuationItems || !data.isContinuationOnNextPage)) {
                    result.push({
                        rowType: DATAGRID_GROUP_FOOTER_ROW_TYPE,
                        key: options.path.slice(),
                        data: data,
                        groupIndex: options.path.length - 1,
                        values: []
                    })
                }
            }
            return result
        };
        _proto3._processGroupItem = function(groupItem, options) {
            var that = this;
            if (!options.summaryGroupItems) {
                options.summaryGroupItems = that.option("summary.groupItems") || []
            }
            if ("group" === groupItem.rowType) {
                var groupColumnIndex = -1;
                var afterGroupColumnIndex = -1;
                (0, _iterator.each)(options.visibleColumns, (function(visibleIndex) {
                    var prevColumn = options.visibleColumns[visibleIndex - 1];
                    if (groupItem.groupIndex === this.groupIndex) {
                        groupColumnIndex = this.index
                    }
                    if (visibleIndex > 0 && "expand" === prevColumn.command && "expand" !== this.command) {
                        afterGroupColumnIndex = this.index
                    }
                }));
                groupItem.summaryCells = this._calculateSummaryCells(options.summaryGroupItems, getGroupAggregates(groupItem.data), options.visibleColumns, (function(summaryItem, column) {
                    if (summaryItem.showInGroupFooter) {
                        return -1
                    }
                    if (summaryItem.alignByColumn && column && !(0, _type.isDefined)(column.groupIndex) && column.index !== afterGroupColumnIndex) {
                        return column.index
                    }
                    return groupColumnIndex
                }), true)
            }
            if (groupItem.rowType === DATAGRID_GROUP_FOOTER_ROW_TYPE) {
                groupItem.summaryCells = this._calculateSummaryCells(options.summaryGroupItems, getGroupAggregates(groupItem.data), options.visibleColumns, (function(summaryItem, column) {
                    return summaryItem.showInGroupFooter && that._isDataColumn(column) ? column.index : -1
                }))
            }
            return groupItem
        };
        _proto3._calculateSummaryCells = function(summaryItems, aggregates, visibleColumns, calculateTargetColumnIndex, isGroupRow) {
            var that = this;
            var summaryCells = [];
            var summaryCellsByColumns = {};
            (0, _iterator.each)(summaryItems, (function(summaryIndex, summaryItem) {
                var column = that._columnsController.columnOption(summaryItem.column);
                var showInColumn = summaryItem.showInColumn && that._columnsController.columnOption(summaryItem.showInColumn) || column;
                var columnIndex = calculateTargetColumnIndex(summaryItem, showInColumn);
                if (columnIndex >= 0) {
                    if (!summaryCellsByColumns[columnIndex]) {
                        summaryCellsByColumns[columnIndex] = []
                    }
                    var aggregate = aggregates[summaryIndex];
                    if (aggregate === aggregate) {
                        var valueFormat;
                        if ((0, _type.isDefined)(summaryItem.valueFormat)) {
                            valueFormat = summaryItem.valueFormat
                        } else if ("count" !== summaryItem.summaryType) {
                            valueFormat = _m_core.default.getFormatByDataType(column && column.dataType)
                        }
                        summaryCellsByColumns[columnIndex].push((0, _extend.extend)({}, summaryItem, {
                            value: (0, _type.isString)(aggregate) && column && column.deserializeValue ? column.deserializeValue(aggregate) : aggregate,
                            valueFormat: valueFormat,
                            columnCaption: column && column.index !== columnIndex ? column.caption : void 0
                        }))
                    }
                }
            }));
            if (!(0, _type.isEmptyObject)(summaryCellsByColumns)) {
                visibleColumns.forEach((function(column, visibleIndex) {
                    var prevColumn = visibleColumns[visibleIndex - 1];
                    var columnIndex = isGroupRow && ("expand" === (null === prevColumn || void 0 === prevColumn ? void 0 : prevColumn.command) || "expand" === column.command) ? null === prevColumn || void 0 === prevColumn ? void 0 : prevColumn.index : column.index;
                    summaryCells.push(summaryCellsByColumns[columnIndex] || [])
                }))
            }
            return summaryCells
        };
        _proto3._getSummaryCells = function(summaryTotalItems, totalAggregates) {
            var that = this;
            var columnsController = that._columnsController;
            return that._calculateSummaryCells(summaryTotalItems, totalAggregates, columnsController.getVisibleColumns(), (function(summaryItem, column) {
                return that._isDataColumn(column) ? column.index : -1
            }))
        };
        _proto3._updateItemsCore = function(change) {
            var summaryCells;
            var dataSource = this._dataSource;
            var footerItems = this._footerItems;
            var oldSummaryCells = footerItems && footerItems[0] && footerItems[0].summaryCells;
            var summaryTotalItems = this.option("summary.totalItems");
            this._footerItems = [];
            if (dataSource && summaryTotalItems && summaryTotalItems.length) {
                var totalAggregates = dataSource.totalAggregates();
                summaryCells = this._getSummaryCells(summaryTotalItems, totalAggregates);
                if (change && change.repaintChangesOnly && oldSummaryCells) {
                    change.totalColumnIndices = summaryCells.map((function(summaryCell, index) {
                        if (JSON.stringify(summaryCell) !== JSON.stringify(oldSummaryCells[index])) {
                            return index
                        }
                        return -1
                    })).filter((function(index) {
                        return index >= 0
                    }))
                }
                if (summaryCells.length) {
                    this._footerItems.push({
                        rowType: DATAGRID_TOTAL_FOOTER_ROW_TYPE,
                        summaryCells: summaryCells
                    })
                }
            }
            _Base2.prototype._updateItemsCore.call(this, change)
        };
        _proto3._prepareUnsavedDataSelector = function(selector) {
            if (recalculateWhileEditing(this)) {
                var editingController = this._editingController;
                if (editingController) {
                    return function(data) {
                        data = editingController.getUpdatedData(data);
                        return selector(data)
                    }
                }
            }
            return selector
        };
        _proto3._prepareAggregateSelector = function(selector, aggregator) {
            selector = this._prepareUnsavedDataSelector(selector);
            if ("avg" === aggregator || "sum" === aggregator) {
                return function(data) {
                    var value = selector(data);
                    return (0, _type.isDefined)(value) ? Number(value) : value
                }
            }
            return selector
        };
        _proto3._getAggregates = function(summaryItems, remoteOperations) {
            var _this2 = this;
            var that = this;
            var calculateCustomSummary = that.option("summary.calculateCustomSummary");
            var commonSkipEmptyValues = that.option("summary.skipEmptyValues");
            return (0, _iterator.map)(summaryItems || [], (function(summaryItem) {
                var column = _this2._columnsController.columnOption(summaryItem.column);
                var calculateCellValue = column && column.calculateCellValue ? column.calculateCellValue.bind(column) : (0, _data.compileGetter)(column ? column.dataField : summaryItem.column);
                var aggregator = summaryItem.summaryType || "count";
                var skipEmptyValues = (0, _type.isDefined)(summaryItem.skipEmptyValues) ? summaryItem.skipEmptyValues : commonSkipEmptyValues;
                if (remoteOperations) {
                    return {
                        selector: summaryItem.column,
                        summaryType: aggregator
                    }
                }
                var selector = that._prepareAggregateSelector(calculateCellValue, aggregator);
                if ("custom" === aggregator) {
                    if (!calculateCustomSummary) {
                        _ui.default.log("E1026");
                        calculateCustomSummary = function() {}
                    }
                    var options = {
                        component: that.component,
                        name: summaryItem.name
                    };
                    calculateCustomSummary(options);
                    options.summaryProcess = "calculate";
                    aggregator = {
                        seed: function(groupIndex) {
                            options.summaryProcess = "start";
                            options.totalValue = void 0;
                            options.groupIndex = groupIndex;
                            delete options.value;
                            calculateCustomSummary(options);
                            return options.totalValue
                        },
                        step: function(totalValue, value) {
                            options.summaryProcess = "calculate";
                            options.totalValue = totalValue;
                            options.value = value;
                            calculateCustomSummary(options);
                            return options.totalValue
                        },
                        finalize: function(totalValue) {
                            options.summaryProcess = "finalize";
                            options.totalValue = totalValue;
                            delete options.value;
                            calculateCustomSummary(options);
                            return options.totalValue
                        }
                    }
                }
                return {
                    selector: selector,
                    aggregator: aggregator,
                    skipEmptyValues: skipEmptyValues
                }
            }))
        };
        _proto3._addSortInfo = function(sortByGroups, groupColumn, selector, sortOrder) {
            if (groupColumn) {
                var groupIndex = groupColumn.groupIndex;
                sortOrder = sortOrder || groupColumn.sortOrder;
                if ((0, _type.isDefined)(groupIndex)) {
                    sortByGroups[groupIndex] = sortByGroups[groupIndex] || [];
                    sortByGroups[groupIndex].push({
                        selector: selector,
                        desc: "desc" === sortOrder
                    })
                }
            }
        };
        _proto3._findSummaryItem = function(summaryItems, name) {
            var summaryItemIndex = -1;
            if ((0, _type.isDefined)(name)) {
                (0, _iterator.each)(summaryItems || [], (function(index) {
                    if (this.name === name || index === name || this.summaryType === name || this.column === name || (summaryItem = this, summaryType = summaryItem.summaryType, column = summaryItem.column, summaryType && column && "".concat(summaryType, "_").concat(column)) === name) {
                        summaryItemIndex = index;
                        return false
                    }
                    var summaryItem, summaryType, column
                }))
            }
            return summaryItemIndex
        };
        _proto3._getSummarySortByGroups = function(sortByGroupSummaryInfo, groupSummaryItems) {
            var that = this;
            var columnsController = that._columnsController;
            var groupColumns = columnsController.getGroupColumns();
            var sortByGroups = [];
            if (!groupSummaryItems || !groupSummaryItems.length) {
                return
            }(0, _iterator.each)(sortByGroupSummaryInfo || [], (function() {
                var sortOrder = this.sortOrder;
                var groupColumn = this.groupColumn;
                var summaryItemIndex = that._findSummaryItem(groupSummaryItems, this.summaryItem);
                if (summaryItemIndex < 0) {
                    return
                }
                var selector = function(data) {
                    return getGroupAggregates(data)[summaryItemIndex]
                };
                if ((0, _type.isDefined)(groupColumn)) {
                    groupColumn = columnsController.columnOption(groupColumn);
                    that._addSortInfo(sortByGroups, groupColumn, selector, sortOrder)
                } else {
                    (0, _iterator.each)(groupColumns, (function(groupIndex, groupColumn) {
                        that._addSortInfo(sortByGroups, groupColumn, selector, sortOrder)
                    }))
                }
            }));
            return sortByGroups
        };
        _proto3._createDataSourceAdapterCore = function(dataSource, remoteOperations) {
            var that = this;
            var dataSourceAdapter = _Base2.prototype._createDataSourceAdapterCore.call(this, dataSource, remoteOperations);
            dataSourceAdapter.summaryGetter((function(currentRemoteOperations) {
                return that._getSummaryOptions(currentRemoteOperations || remoteOperations)
            }));
            return dataSourceAdapter
        };
        _proto3._getSummaryOptions = function(remoteOperations) {
            var that = this;
            var groupSummaryItems = that.option("summary.groupItems");
            var totalSummaryItems = that.option("summary.totalItems");
            var sortByGroupSummaryInfo = that.option("sortByGroupSummaryInfo");
            var groupAggregates = that._getAggregates(groupSummaryItems, remoteOperations && remoteOperations.grouping && remoteOperations.summary);
            var totalAggregates = that._getAggregates(totalSummaryItems, remoteOperations && remoteOperations.summary);
            if (groupAggregates.length || totalAggregates.length) {
                return {
                    groupAggregates: groupAggregates,
                    totalAggregates: totalAggregates,
                    sortByGroups: function() {
                        return that._getSummarySortByGroups(sortByGroupSummaryInfo, groupSummaryItems)
                    }
                }
            }
            return
        };
        _proto3.publicMethods = function() {
            var methods = _Base2.prototype.publicMethods.call(this);
            methods.push("getTotalSummaryValue");
            return methods
        };
        _proto3.getTotalSummaryValue = function(summaryItemName) {
            var summaryItemIndex = this._findSummaryItem(this.option("summary.totalItems"), summaryItemName);
            var aggregates = this._dataSource.totalAggregates();
            if (aggregates.length && summaryItemIndex > -1) {
                return aggregates[summaryItemIndex]
            }
        };
        _proto3.optionChanged = function(args) {
            if ("summary" === args.name || "sortByGroupSummaryInfo" === args.name) {
                args.name = "dataSource"
            }
            _Base2.prototype.optionChanged.call(this, args)
        };
        _proto3.init = function() {
            this._footerItems = [];
            _Base2.prototype.init.call(this)
        };
        _proto3.footerItems = function() {
            return this._footerItems
        };
        return SummaryDataControllerExtender
    }(Base)
};
var editing = function(Base) {
    return function(_Base3) {
        _inheritsLoose(SummaryEditingController, _Base3);

        function SummaryEditingController() {
            return _Base3.apply(this, arguments) || this
        }
        var _proto4 = SummaryEditingController.prototype;
        _proto4._refreshSummary = function() {
            if (recalculateWhileEditing(this) && !this.isSaving()) {
                this._dataController.refresh({
                    load: true,
                    changesOnly: true
                })
            }
        };
        _proto4._addChange = function(params) {
            var result = _Base3.prototype._addChange.apply(this, arguments);
            if (params.type) {
                this._refreshSummary()
            }
            return result
        };
        _proto4._removeChange = function() {
            var result = _Base3.prototype._removeChange.apply(this, arguments);
            this._refreshSummary();
            return result
        };
        _proto4.cancelEditData = function() {
            var result = _Base3.prototype.cancelEditData.apply(this, arguments);
            this._refreshSummary();
            return result
        };
        return SummaryEditingController
    }(Base)
};
var rowsView = function(Base) {
    return function(_Base4) {
        _inheritsLoose(SummaryRowsViewExtender, _Base4);

        function SummaryRowsViewExtender() {
            return _Base4.apply(this, arguments) || this
        }
        var _proto5 = SummaryRowsViewExtender.prototype;
        _proto5._createRow = function(row) {
            var $row = _Base4.prototype._createRow.apply(this, arguments);
            row && $row.addClass(row.rowType === DATAGRID_GROUP_FOOTER_ROW_TYPE ? DATAGRID_GROUP_FOOTER_CLASS : "");
            return $row
        };
        _proto5._renderCells = function($row, options) {
            _Base4.prototype._renderCells.apply(this, arguments);
            if ("group" === options.row.rowType && options.row.summaryCells && options.row.summaryCells.length) {
                this._renderGroupSummaryCells($row, options)
            }
        };
        _proto5._hasAlignByColumnSummaryItems = function(columnIndex, options) {
            return !(0, _type.isDefined)(options.columns[columnIndex].groupIndex) && options.row.summaryCells[columnIndex].length
        };
        _proto5._getAlignByColumnCellCount = function(groupCellColSpan, options) {
            var alignByColumnCellCount = 0;
            for (var i = 1; i < groupCellColSpan; i++) {
                var columnIndex = options.row.summaryCells.length - i;
                alignByColumnCellCount = this._hasAlignByColumnSummaryItems(columnIndex, options) ? i : alignByColumnCellCount
            }
            return alignByColumnCellCount
        };
        _proto5._renderGroupSummaryCells = function($row, options) {
            var $groupCell = $row.children().last();
            var groupCellColSpan = Number($groupCell.attr("colSpan")) || 1;
            var alignByColumnCellCount = this._getAlignByColumnCellCount(groupCellColSpan, options);
            this._renderGroupSummaryCellsCore($groupCell, options, groupCellColSpan, alignByColumnCellCount)
        };
        _proto5._renderGroupSummaryCellsCore = function($groupCell, options, groupCellColSpan, alignByColumnCellCount) {
            if (alignByColumnCellCount > 0) {
                $groupCell.attr("colSpan", groupCellColSpan - alignByColumnCellCount);
                for (var i = 0; i < alignByColumnCellCount; i++) {
                    var columnIndex = options.columns.length - alignByColumnCellCount + i;
                    this._renderCell($groupCell.parent(), (0, _extend.extend)({
                        column: options.columns[columnIndex],
                        columnIndex: this._getSummaryCellIndex(columnIndex, options.columns)
                    }, options))
                }
            }
        };
        _proto5._getSummaryCellIndex = function(columnIndex, columns) {
            return columnIndex
        };
        _proto5._getCellTemplate = function(options) {
            if (!options.column.command && !(0, _type.isDefined)(options.column.groupIndex) && options.summaryItems && options.summaryItems.length) {
                return renderSummaryCell
            }
            return _Base4.prototype._getCellTemplate.call(this, options)
        };
        _proto5._getCellOptions = function(options) {
            var parameters = _Base4.prototype._getCellOptions.call(this, options);
            if (options.row.summaryCells) {
                return (0, _extend.extend)(parameters, getSummaryCellOptions(this, options))
            }
            return parameters
        };
        return SummaryRowsViewExtender
    }(Base)
};
_m_core.default.registerModule("summary", {
    defaultOptions: function() {
        return {
            summary: {
                groupItems: void 0,
                totalItems: void 0,
                calculateCustomSummary: void 0,
                skipEmptyValues: true,
                recalculateWhileEditing: false,
                texts: {
                    sum: _message.default.format("dxDataGrid-summarySum"),
                    sumOtherColumn: _message.default.format("dxDataGrid-summarySumOtherColumn"),
                    min: _message.default.format("dxDataGrid-summaryMin"),
                    minOtherColumn: _message.default.format("dxDataGrid-summaryMinOtherColumn"),
                    max: _message.default.format("dxDataGrid-summaryMax"),
                    maxOtherColumn: _message.default.format("dxDataGrid-summaryMaxOtherColumn"),
                    avg: _message.default.format("dxDataGrid-summaryAvg"),
                    avgOtherColumn: _message.default.format("dxDataGrid-summaryAvgOtherColumn"),
                    count: _message.default.format("dxDataGrid-summaryCount")
                }
            },
            sortByGroupSummaryInfo: void 0
        }
    },
    views: {
        footerView: FooterView
    },
    extenders: {
        controllers: {
            data: data,
            editing: editing
        },
        views: {
            rowsView: rowsView
        }
    }
});
