/**
 * @class isc.GeListGrid
 */
isc.defineClass("GeListGrid", "ListGrid");

isc.GeListGrid.addProperties({
    autoDraw: false,
    /**
     * Ein Objekt, welches einen getter und setter für ConfigValues implementiert. (siehe isc.PublicationFilterForm)
     * Es wird lediglich genutzt, um dessen Filtereinstellungen in der table_config zu speichern.
     */
    externFilter: null,
    debugMode: true,

    // Override initWidget to populate a special sort normalizer on a field when its type is "langtext"
    initWidget: function () {
        this.Super("initWidget", arguments);

        // Add special behaviour to all fields of type "langtext"
        var fields = this.getAllFields();
        if (isc.isAn.Array(fields)) {
            for (var i = 0; i < fields.length; i++) {
                var field = fields[i];
                if (isc.isAn.String(field.type)) {
                    if (field.type == "langtext") {
                        field.formatCellValue = isc.LangTextItem.DEFAULT_FORMAT_CELL_VALUE;
                        field.getGroupValue = isc.LangTextItem.DEFAULT_GET_GROUP_VALUE;
                        if ((field.sortNormalizer == undefined) || (field.sortNormalizer == null)) {
                            field.sortNormalizer = isc.LangTextItem.DEFAULT_SORT_NORMALIZER;
                        }
                    }
                }
                field.indexId = i;
            }
        }

        if (this.debugMode) {
            isc.logWarn("##### init table config for: " + this.tableId);
        }

        if (isc.isA.String(this.tableId) && this.tableId.length > 0) {
            this.setTableConfiguration(fields);
        }

        return true;
    },

    draw: function () {
        this.Super("draw", arguments);
        if (this.debugMode) {
            isc.logWarn("##### table drawn. set column order for: " + this.tableId);
        }
        this.setColumnOrder(); // order of columns can only changed after they are drawn

        return true;
    },

    dataArrived: function () {
        this.Super("dataArrived", arguments);
        this.setColumnSort();
    },

    groupBy: function () {
        this.Super("groupBy", arguments);
        if (isc.isA.Boolean(this.columnsConfigured) && this.columnsConfigured && isc.isA.Boolean(this.columnsOrdered) && this.columnsOrdered) {
            this.saveTableConfig();
        }

        return true;
    },

    sort: function () {
        this.Super("sort", arguments);
        if (isc.isA.Boolean(this.columnsConfigured) && this.columnsConfigured && isc.isA.Boolean(this.columnsOrdered) && this.columnsOrdered) {
            this.saveTableConfig();
        }

        return true;
    },

    fieldStateChanged: function () {
        this.Super("fieldStateChanged", arguments);
        if (isc.isA.Boolean(this.columnsConfigured) && this.columnsConfigured && isc.isA.Boolean(this.columnsOrdered) && this.columnsOrdered) {
            this.saveTableConfig();
        }

        return true;
    },

    /**
     * Setzt das Objekt, welches einen getter und setter für ConfigValues implementiert. (siehe isc.PublicationFilterForm)
     * Es wird lediglich genutzt, um dessen Filtereinstellungen in der table_config zu speichern.
     */
    setExternFilter: function (externFilter) {
        if (isc.isA.Object(externFilter)) {
            this.externFilter = externFilter;
            this.externFilter.onConfigValueChanged = {target: this, methodName: 'saveTableConfig'};
        }
    },

    setTableConfiguration: function (fields) {
        if (this.debugMode) {
            isc.logWarn("##### set table config: " + this.columnsConfigured + " // " + this.columnsOrdered);
        }

        if (isc.isA.Boolean(this.columnsConfigured) && this.columnsConfigured) {
            return true;
        }

        var tableConfig = userTableConfigs[this.tableId];
        if (isc.isAn.Object(tableConfig) && isc.isAn.Array(fields)) {
            var i;
            var fieldSize = fields.length;

            //column filter
            if (isc.isA.String(tableConfig.columnFilter)) {
                var filter = tableConfig.columnFilter.split(",");
                if (isc.isAn.Array(filter)) {
                    for (i = 0; i < filter.length && i < fieldSize; i++) {
                        if (isc.isA.String(filter[i]) && filter[i].length > 0 && fields[i].canFilter) {
                            fields[i].defaultFilterValue = filter[i];
                        }
                    }
                }
            }

            //column width
            if (isc.isA.String(tableConfig.columnWidth)) {
                var width = tableConfig.columnWidth.split(",");
                if (isc.isAn.Array(width)) {
                    for (i = 0; i < width.length && i < fieldSize; i++) {
                        fields[i].width = width[i];
                    }
                }
            }

            //group rows by column
            var group = tableConfig.tableGroup;
            if (isc.isA.String(group) && group.length > 0) {
                this.groupBy(group);
            }
        }
        this.columnsConfigured = true;

        return true;
    },

    setColumnOrder: function () {
        if (this.debugMode) {
            isc.logWarn("##### columns order for " + this.tableId + " : " + this.columnsOrdered);
        }

        if (isc.isA.Boolean(this.columnsOrdered) && this.columnsOrdered) {
            return true;
        }

        var fields = this.getAllFields();
        var tableConfig = userTableConfigs[this.tableId];
        if (isc.isAn.Object(tableConfig)) {
            if (this.debugMode) {
                isc.logWarn("##### start to order columns");
            }
            var i;
            var j;

            // column order
            for (i = 0; i < fieldSize; i++) {
                this.showField(fields[i].name);
            }
            if (isc.isA.String(tableConfig.columnOrder)) {
                var order = tableConfig.columnOrder.split(",");
                var orderIndex;
                var fieldSize = fields.length;
                if (isc.isAn.Array(order)) {
                    for (i = 0; i < order.length && i < fieldSize; i++) {
                        orderIndex = parseInt(order[i]);
                        if (fields[i].indexId == orderIndex) continue;
                        var fieldIndex = null;
                        for (j = i; j < fieldSize; j++) {
                            if (fields[j].indexId == orderIndex) {
                                fieldIndex = j;
                                break;
                            }
                        }
                        if (isc.isA.Number(fieldIndex)) {
                            this.reorderField(fieldIndex, i);
                        }
                    }
                }
            }

            //hidden fields
            if (isc.isA.String(tableConfig.invisibleColumns)) {
                var hiddenFields = tableConfig.invisibleColumns.split(",");
                if (isc.isAn.Array(hiddenFields)) {
                    if (this.debugMode) {
                        isc.logEcho(hiddenFields, "##### hidden fields");
                    }
                    for (i = 0; i < hiddenFields.length; i++) {
                        if (hiddenFields[i] === "") continue;
                        this.hideField(hiddenFields[i]);
                    }
                }
            }

            //sort rows by column
            if (isc.isA.String(tableConfig.tableSort)) {
                var sort = tableConfig.tableSort.split(",");
                if (isc.isAn.Array(sort) && sort.length > 1 && false) {
                    if (this.debugMode) {
                        isc.logWarn("##### sort: " + sort[0] + "/" + sort[1]);
                    }
                    this.sort((sort[0]), sort[1]);
                }
            }
        }

        if (this.debugMode) {
            isc.logWarn("##### columns ordered");
        }

        this.columnsOrdered = true;

        return true;
    },

    setColumnSort: function () {
        if (this.debugMode) {
            isc.logWarn("##### columns sort for " + this.tableId + " : " + this.columnsSort);
        }

        if (isc.isA.Boolean(this.columnsSort) && this.columnsSort) {
            return true;
        }

        var tableConfig = userTableConfigs[this.tableId];
        if (isc.isAn.Object(tableConfig)) {
            if (this.debugMode) {
                isc.logWarn("##### start to sort columns");
            }

            //sort rows by column
            if (isc.isA.String(tableConfig.tableSort)) {
                var sort = tableConfig.tableSort.split(",");
                if (isc.isAn.Array(sort) && sort.length > 1) {
                    if (this.debugMode) {
                        isc.logWarn("##### sort: " + sort[0] + "/" + sort[1]);
                    }
                    this.sort((sort[0]), sort[1]);
                }
            }
        }

        if (this.debugMode) {
            isc.logWarn("##### columns sorted");
        }

        this.columnsSort = true;

        return true;
    },

    saveTableConfig: function () {
        isc.logWarn("##### try to save");

        if (!isc.isA.String(this.tableId) || this.tableId.length == 0) {
            return false;
        }

        var tableConfig = userTableConfigs[this.tableId];
        if (!isc.isAn.Object(tableConfig)) {
            tableConfig = {tableId: this.tableId};
        }
        var fields = this.getAllFields();
        var hiddenColumns = "";
        var columnWidth = [];
        var columnOrder = "";
        var columnWidthString = "";
        var i;
        for (i = 0; i < fields.length; i++) {
            if (!this.fieldIsVisible(fields[i].name)) {
                if (hiddenColumns.length > 0) {
                    hiddenColumns += ",";
                }
                hiddenColumns += fields[i].name;
            }
            columnWidth[fields[i].indexId] =
                (isc.isAn.Number(fields[i].width) && fields[i].width > 0 ? this.getFieldWidth(fields[i].name) : "*");
            if (columnOrder.length > 0) {
                columnOrder += ",";
            }
            columnOrder += fields[i].indexId;
        }
        for (i = 0; i < columnWidth.length; i++) {
            if (i > 0) {
                columnWidthString += ",";
            }
            columnWidthString += columnWidth[i];
        }
        tableConfig.invisibleColumns = hiddenColumns;
        tableConfig.columnOrder = columnOrder;
        tableConfig.columnWidth = columnWidthString;
        tableConfig.columnFilter = null;

        var sort = null;
        if (isc.isA.Number(this.sortFieldNum)) {
            isc.logEcho(this.sortField, "###### sort field " + this.sortFieldNum);
            sort = this.getField(this.sortFieldNum).name + "," + (this.sortDirection ? "ascending" : "descending")
        }
        tableConfig.tableSort = sort;

        var group = null;
        if (this.isGrouped) {
            group = this.groupByField[0];
        }
        tableConfig.tableGroup = group;

        var externFilterConfigValues = '';
        if (isc.isA.Object(this.externFilter)) {
            externFilterConfigValues = this.externFilter.getConfigValue();
        }
        tableConfig.externFilters = externFilterConfigValues;

        if (this.debugMode) {
            isc.logEcho(tableConfig, "##### save table Config");
        }

        RPCManager.sendRequest({
            showPrompt: false,
            actionURL: '/tableconfig/saveTableConfig.json',
            params: tableConfig
        });

        return true;
    }
});