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;
    }
});