Calculation/app/reports/rpt_component/jpc_cross_tab.js

'use strict';

const JV = require('./jpc_value_define');
const JE = require('./jpc_rte');
const JpcFieldHelper = require('./helper/jpc_helper_field');
const JpcBandHelper = require('./helper/jpc_helper_band');
const JpcBand = require('./jpc_band');
const JpcCrossTabHelper = require('./helper/jpc_helper_cross_tab');
const JpcCommonHelper = require('./helper/jpc_helper_common');
const JpcDiscreteHelper = require('./helper/jpc_helper_discrete');
const JpcTextHelper = require('./helper/jpc_helper_text');
const JpcCommonOutputHelper = require('./helper/jpc_helper_common_output');
const JpcAreaHelper = require('./helper/jpc_helper_area');
const $FS_UTIL = require('../../public/js/fsUtil');
const bc = require('../../lib/base_calc.js');

const JpcCrossTabSrv = function() {};

JpcCrossTabSrv.prototype.createNew = function() {
    function private_addTabValue(tabValuedIdxLst, sortedSequence, segIdx, preRec, nextRec, dispSerialIdxLst, sorted_sum_value_Lst, rst_sum_value_Lst) {
        if (tabValuedIdxLst) {
            let serial1stTier = null;
            if (dispSerialIdxLst) serial1stTier = [];
            const pgseg1stTier = [];
            const sumVal = [];
            let sumValL = 1;
            if (sortedSequence) {
                const arrDupVals = sortedSequence[segIdx];
                let arrDupSumVals = null;
                if (sorted_sum_value_Lst !== null) {
                    arrDupSumVals = sorted_sum_value_Lst[segIdx];
                    sumValL = arrDupSumVals[0].length;
                }

                for (let i = 0; i < nextRec; i++) {
                    if (arrDupVals.length <= preRec + i) {
                        pgseg1stTier[i] = JV.BLANK_VALUE_INDEX;
                        sumVal[i] = [];
                        for (let ei = 0; ei < sumValL; ei++) {
                            sumVal[i][ei] = null;
                        }
                        if (serial1stTier !== null) {
                            serial1stTier[i] = JV.BLANK_VALUE_INDEX;
                        }
                        continue;
                    }
                    const duplicateValueArr = arrDupVals[preRec + i];
                    pgseg1stTier[i] = duplicateValueArr[0];
                    if (arrDupSumVals !== null) sumVal[i] = arrDupSumVals[preRec + i];

                    if (serial1stTier !== null) {
                        serial1stTier[i] = preRec + i;
                    }
                }
                tabValuedIdxLst.push(pgseg1stTier);
                if (dispSerialIdxLst !== null) {
                    dispSerialIdxLst.push(serial1stTier);
                }
                if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                    rst_sum_value_Lst.push(sumVal);
                }
            } else {
                // should push blank value index rather than null
                for (let i = 0; i < nextRec; i++) {
                    pgseg1stTier[i] = JV.BLANK_VALUE_INDEX;
                    sumVal[i] = null;
                    if (serial1stTier !== null) {
                        serial1stTier[i] = JV.BLANK_VALUE_INDEX;
                    }
                }
                tabValuedIdxLst.push(pgseg1stTier);
                if (dispSerialIdxLst !== null) {
                    dispSerialIdxLst.push(serial1stTier);
                }
                if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                    rst_sum_value_Lst.push(sumVal);
                }
            }
        }
    }
    function private_addContentValue(dispValueIdxLst_Content, sortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, page_seg_map, pageIdx) {
        if (dispValueIdxLst_Content !== null) {
            page_seg_map.push([pageIdx, segIdx]);
            const arrContents = [];
            if (sortedContentSequence !== null) {
                const arrAllContent = sortedContentSequence[segIdx];
                for (let i = 0; i < maxRowRec; i++) {
                    arrContents.push([]);
                    for (let j = 0; j < maxColRec; j++) {
                        if (arrAllContent.length <= counterRowRec + i || arrAllContent[counterRowRec + i].length <= counterColRec + j) {
                            arrContents[i][j] = JV.BLANK_VALUE_INDEX;
                        } else {
                            arrContents[i][j] = arrAllContent[counterRowRec + i][counterColRec + j];
                        }
                    }
                }
                dispValueIdxLst_Content.push(arrContents);
            } else {
                // should push blank value index rather than null
                for (let i = 0; i < maxRowRec; i++) {
                    arrContents.push([]);
                    for (let j = 0; j < maxColRec; j++) {
                        arrContents[i][j] = JV.BLANK_VALUE_INDEX;
                    }
                }
                dispValueIdxLst_Content.push(arrContents);
            }
        }
    }
    function _addRowSumValue() {
        // 此方法是专门为交叉行(拓展)合计用
    }
    function private_SortAndOptimize(rptTpl, dataObj, dataSeq, sortTab, rstFieldsIdx, $CURRENT_RPT) {
        const result = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][sortTab];
        if (tab) {
            let sIDX = 0;
            // 1. prepare and sort by tab-field
            const fields = [];
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab[JV.PROP_CROSS_FIELDS], fields, rstFieldsIdx);
            const data_details = dataObj[JV.DATA_DETAIL_DATA];
            JpcCrossTabHelper.sortTabFields(fields, rstFieldsIdx, data_details, dataSeq, $CURRENT_RPT);
            // 2. distinguish sort tab fields value
            let b1 = false;
            for (let i = 0; i < dataSeq.length; i++) {
                sIDX = 0;
                const segArr = [];
                if (dataSeq[i].length === 1) {
                    JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, 0, 1);
                } else {
                    for (let j = 1; j < dataSeq[i].length; j++) {
                        b1 = false;
                        for (let k = 0; k < rstFieldsIdx.length; k++) {
                            if (fields[k].hasOwnProperty(JV.TAB_FIELD_PROP_SORT)) {
                                // 只有被选择了作为排序字段的才进入排序及优化
                                if (typeof rstFieldsIdx[k] === 'object') {
                                    const map_data_field = JE.F(rstFieldsIdx[k][JV.PROP_ID], $CURRENT_RPT);
                                    if (map_data_field[JV.PROP_AD_HOC_DATA][dataSeq[i][j - 1]] !== map_data_field[JV.PROP_AD_HOC_DATA][dataSeq[i][j]]) {
                                        b1 = true;
                                        break;
                                    }
                                } else {
                                    if (data_details[rstFieldsIdx[k]][dataSeq[i][j - 1]] !== data_details[rstFieldsIdx[k]][dataSeq[i][j]]) {
                                        b1 = true;
                                        break;
                                    }
                                }
                            }
                        }
                        if (b1) {
                            JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, j);
                            sIDX = j;
                            if (j === dataSeq[i].length - 1) {
                                JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, j, dataSeq[i].length);
                            }
                        } else if (j === dataSeq[i].length - 1) {
                            JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, dataSeq[i].length);
                        }
                    }
                }
                if (segArr.length > 0) result.push(segArr);
            }
        }
        return result;
    }
    function private_SortForDisplayContent(rptTpl, rowSeq, colSeq, rstFieldsIdx) {
        const result = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
        if (tab) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab[JV.PROP_CROSS_FIELDS], null, rstFieldsIdx);
        }
        for (let i = 0; i < rowSeq.length; i++) {
            const rl = rowSeq[i];
            const cl = colSeq[i];
            const ds = [];
            // 1. initialize to blank value index
            for (let j = 0; j < rl.length; j++) {
                ds.push([]);
                for (let k = 0; k < cl.length; k++) {
                    ds[j].push(JV.BLANK_VALUE_INDEX);
                }
            }
            // 2. then fill up the right index
            for (let j = 0; j < rl.length; j++) {
                const ra = rl[j];
                for (let k = 0; k < ra.length; k++) {
                    const colIdx = JpcCrossTabHelper.getColIDX(cl, ra[k]);
                    if (colIdx >= 0) {
                        ds[j][colIdx] = ra[k];
                    }
                }
            }
            result.push(ds);
        }
        return result;
    }

    const JpcCrossTabResult = {};
    JpcCrossTabResult.initialize = function() {
        const me = this;
        me.dispValueIdxLst_Row = [];
        me.dispValueIdxLst_Col = [];
        me.dispValueIdxLst_Content = [];
        me.dispSerialIdxLst_Row = [];
        me.col_sum_fields_idx = [];
        me.col_sum_fields_value_total = [];
        me.row_sum_fields_value_total = [];
        me.dispSumValueLst_Col = []; // 这个是横向合计(一列列累加)
        me.dispSumValueLst_Row = []; // 这个是纵向合计(一行行累加)
        me.page_seg_map = [];
        me.row_fields_idx = [];
        me.row_fields_adhoc_idx = [];
        me.col_fields_idx = [];
        me.content_fields_idx = [];
        me.row_extension_fields_idx = [];
        me.row_sum_extension_fields_idx = []; // 类似col_sum_fields_idx，放在‘交叉行拓展合计’中
        me.crsOrient = JV.PAGE_ORIENTATION_V_FIRST;
        me.pageStatusLst = [];
        me.paging_option = JV.PAGING_OPTION_NORMAL;
        me.signatureRst = [];
        me.signatureDateRst = [];
        me.signatureAuditRst = [];
    };
    JpcCrossTabResult.sorting = function(rptTpl, dataObj, dataSeq, $CURRENT_RPT) {
        const me = this;
        // IMPORTANT: the data should be sorted in SQL/NoSQL level!
        // $FS_UTIL.writeObjToFile(dataSeq, 'D:/GitHome/temp/JL_cross_dataSeq' + (new Date()).getTime() + '.js');
        me.sortedRowSequence = private_SortAndOptimize(rptTpl, dataObj, dataSeq, JV.NODE_CROSS_ROW, me.row_fields_idx, $CURRENT_RPT);
        private_SortAndOptimize(rptTpl, dataObj, dataSeq, JV.NODE_CROSS_ROW_AD_HOC, me.row_fields_adhoc_idx, $CURRENT_RPT);
        me.sortedColSequence = private_SortAndOptimize(rptTpl, dataObj, dataSeq, JV.NODE_CROSS_COL, me.col_fields_idx, $CURRENT_RPT);
        me.sortedContentSequence = private_SortForDisplayContent(rptTpl, me.sortedRowSequence, me.sortedColSequence, me.content_fields_idx);

        // $FS_UTIL.writeObjToFile(me.sortedRowSequence, 'D:/GitHome/temp/JL_cross_sortedRowSequence' + (new Date()).getTime() + '.js');
        // $FS_UTIL.writeObjToFile(me.sortedColSequence, 'D:/GitHome/temp/JL_cross_sortedColSequence' + (new Date()).getTime() + '.js');
        // $FS_UTIL.writeObjToFile(me.sortedContentSequence, 'D:/GitHome/temp/JL_cross_sortedContentSequence' + (new Date()).getTime() + '.js');

        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_COL_SUM][JV.PROP_CROSS_FIELDS], null, me.col_sum_fields_idx);
        // pre-sum the data(for col sum display)
        const data_details = dataObj[JV.DATA_DETAIL_DATA];
        const data_fields = [];
        for (let i = 0; i < me.col_sum_fields_idx.length; i++) {
            let data_field = null;
            if (typeof me.col_sum_fields_idx[i] === 'object') {
                const exField = JE.F(me.col_sum_fields_idx[i][JV.PROP_ID], $CURRENT_RPT);
                if (exField) {
                    data_field = exField[JV.PROP_AD_HOC_DATA];
                }
            } else {
                data_field = data_details[me.col_sum_fields_idx[i]];
            }
            data_fields.push(data_field);
        }
        for (let i = 0; i < me.sortedRowSequence.length; i++) { // seg level
            if (me.sortedRowSequence[i].length > 0) {
                me.col_sum_fields_value_total.push([]);
                for (let j = 0; j < me.sortedRowSequence[i].length; j++) {
                    const rowGrandTotal = [];
                    for (let di = 0; di < data_fields.length; di++) {
                        rowGrandTotal.push(0.0);
                        for (let k = 0; k < me.sortedRowSequence[i][j].length; k++) {
                            // 3. start to sum
                            let vTtl = parseFloat(JpcFieldHelper.getValue(data_fields[di], me.sortedRowSequence[i][j][k]));
                            if (isNaN(vTtl)) {
                                vTtl = 0;
                            }
                            // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * vTtl;
                            rowGrandTotal[di] = bc.add(rowGrandTotal[di], vTtl);
                        }
                    }
                    me.col_sum_fields_value_total[i].push(rowGrandTotal);
                }
            }

        }
        const row_data_fields = [];
        for (let i = 0; i < me.col_sum_fields_idx.length; i++) {
            let data_field = null;
            if (typeof me.col_sum_fields_idx[i] === 'object') {
                const exField = JE.F(me.col_sum_fields_idx[i][JV.PROP_ID], $CURRENT_RPT);
                if (exField) {
                    data_field = exField[JV.PROP_AD_HOC_DATA];
                }
            } else {
                data_field = data_details[me.col_sum_fields_idx[i]];
            }
            row_data_fields.push(data_field);
        }
        for (let i = 0; i < me.sortedColSequence.length; i++) {
            if (me.sortedColSequence[i].length > 0) {
                me.row_sum_fields_value_total.push([]);
                for (let j = 0; j < me.sortedColSequence[i].length; j++) {
                    const rowGrandTotal = [];
                    for (let di = 0; di < row_data_fields.length; di++) {
                        rowGrandTotal.push(0.0);
                        for (let k = 0; k < me.sortedColSequence[i][j].length; k++) {
                            // 3. start to sum
                            let vTtl = parseFloat(JpcFieldHelper.getValue(row_data_fields[di], me.sortedColSequence[i][j][k]));
                            if (isNaN(vTtl)) {
                                vTtl = 0;
                            }
                            // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * vTtl;
                            rowGrandTotal[di] = bc.add(rowGrandTotal[di], vTtl);
                        }
                    }
                    me.row_sum_fields_value_total[i].push(rowGrandTotal);
                }
            }
        }
        // console.log('me.row_sum_fields_value_total');
        // console.log(me.row_sum_fields_value_total);
    };
    JpcCrossTabResult.preSetupPages = function(rptTpl, defProperties, option) {
        const me = this;
        let rst = 0;
        me.paging_option = option || JV.PAGING_OPTION_NORMAL;
        // 1. original initialize
        let maxRowRec = 1;
        let maxColRec = 1;
        let counterRowRec = 0;
        let counterColRec = 0;
        let pageIdx = 0;
        const segCnt = me.sortedContentSequence.length;
        const pageStatus = [true, true, false, true, false, false, false, false];
        // 2. calculate the page info one by one
        let bands = JpcBand.createNew(rptTpl, defProperties);
        function private_resetBandArea() {
            JpcBandHelper.setBandArea(bands, rptTpl, pageStatus);
            maxRowRec = JpcCrossTabHelper.getMaxRowsPerPage(bands, rptTpl);
            maxColRec = JpcCrossTabHelper.getMaxColsPerPage(bands, rptTpl);
        }
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_EXT][JV.PROP_CROSS_FIELDS], null, me.row_extension_fields_idx);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_SUM_EXT][JV.PROP_CROSS_FIELDS], null, me.row_sum_extension_fields_idx);
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            /*
             rst = segCnt;
             pageStatus[JV.STATUS_SEGMENT_START] = true;
             pageStatus[JV.STATUS_SEGMENT_END] = true;
             pageStatus[JV.STATUS_CROSS_ROW_END] = true;
             pageStatus[JV.STATUS_CROSS_COL_END] = true;
             for (let segIdx = 0; segIdx < segCnt; segIdx++) {
             if (segIdx === segCnt - 1) {
             pageStatus[JV.STATUS_REPORT_END] = true;
             }
             if (segIdx > 0) {
             pageStatus[JV.STATUS_REPORT_START] = false;
             }
             me.pageStatusLst.push(pageStatus.slice(0));
             pageIdx++;
             private_addTabValue(me.dispValueIdxLst_Row, me.sortedRowSequence, segIdx, 0, me.sortedRowSequence[segIdx].length, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
             private_addTabValue(me.dispValueIdxLst_Col, me.sortedColSequence, segIdx, 0, me.sortedColSequence[segIdx].length, null, null, null);
             private_addContentValue(me.dispValueIdxLst_Content, me.sortedContentSequence, segIdx, 0, me.sortedRowSequence[segIdx].length, 0, me.sortedColSequence[segIdx].length, me.page_seg_map, pageIdx);
             }
             //*/
        } else {
            for (let segIdx = 0; segIdx < segCnt; segIdx++) {
                // 2.1. seg level initialize
                private_resetBandArea();
                const orgMaxRowRec = maxRowRec;
                const orgMaxColRec = maxColRec;
                let rowSplitCnt = Math.ceil(1.0 * me.sortedRowSequence[segIdx].length / maxRowRec);
                let colSplitCnt = Math.ceil(1.0 * me.sortedColSequence[segIdx].length / maxColRec);
                pageStatus[JV.STATUS_CROSS_ROW_END] = true;
                private_resetBandArea();
                let hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_SUM, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                if (hasAdHocRow) {
                    hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_EXT, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                }
                pageStatus[JV.STATUS_CROSS_ROW_END] = false;
                pageStatus[JV.STATUS_CROSS_COL_END] = true;
                private_resetBandArea();
                const hasAdHocCol = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_COL_SUM, rptTpl, bands, me.sortedColSequence, segIdx, (colSplitCnt - 1) * orgMaxColRec, maxColRec);
                pageStatus[JV.STATUS_CROSS_COL_END] = false;
                private_resetBandArea();
                if (hasAdHocRow) rowSplitCnt++;
                if (hasAdHocCol) colSplitCnt++;
                // 2.2
                if (rptTpl[JV.NODE_MAIN_INFO][JV.NODE_PAGE_INFO][JV.PROP_CROSS_DISPLAY_ORDER] === JV.PAGE_ORIENTATION_H_FIRST) {
                    for (let rowIdx = 0; rowIdx < rowSplitCnt; rowIdx++) {
                        pageStatus[JV.STATUS_CROSS_ROW_END] = (rowIdx === (rowSplitCnt - 1));
                        private_resetBandArea();
                        counterRowRec = orgMaxRowRec * rowIdx;
                        let currentSortedRowSequence = me.sortedRowSequence;
                        let currentSortedContentSequence = me.sortedContentSequence;
                        if (hasAdHocRow && rowIdx === (rowSplitCnt - 1)) {
                            currentSortedRowSequence = null;
                            currentSortedContentSequence = null;
                            counterRowRec = 0;
                        }
                        for (let colIdx = 0; colIdx < colSplitCnt; colIdx++) {
                            pageStatus[JV.STATUS_CROSS_COL_END] = (colIdx === (colSplitCnt - 1));
                            let needOneMoreRptEnd = false;
                            if ((segIdx === segCnt - 1) && pageStatus[JV.STATUS_CROSS_ROW_END] && pageStatus[JV.STATUS_CROSS_COL_END]) {
                                pageStatus[JV.STATUS_REPORT_END] = true;
                                private_resetBandArea();
                                const hasAdHocColEnd = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_COL_SUM, rptTpl, bands, me.sortedColSequence, segIdx, (colSplitCnt - 1) * orgMaxColRec, maxColRec);
                                const hasAdHocRowEnd = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_SUM, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                                if (hasAdHocColEnd || hasAdHocRowEnd) {
                                    needOneMoreRptEnd = true;
                                    pageStatus[JV.STATUS_REPORT_END] = false;
                                }
                            }
                            private_resetBandArea();
                            counterColRec = orgMaxColRec * colIdx;
                            let currentSortedColSequence = me.sortedColSequence;
                            if (hasAdHocCol && colIdx === (colSplitCnt - 1)) {
                                currentSortedColSequence = null;
                                currentSortedContentSequence = null;
                                counterColRec = 0;
                            }
                            me.pageStatusLst.push(pageStatus.slice(0));
                            pageIdx++;
                            private_addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                            private_addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, me.row_sum_fields_value_total, me.dispSumValueLst_Row);
                            private_addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                            // 处理report end情况
                            if (needOneMoreRptEnd) {
                                pageStatus[JV.STATUS_REPORT_END] = true;
                                private_resetBandArea();
                                currentSortedColSequence = null;
                                currentSortedContentSequence = null;
                                counterColRec = 0;
                                me.pageStatusLst.push(pageStatus.slice(0));
                                pageIdx++;
                                private_addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                                private_addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, me.row_sum_fields_value_total, me.dispSumValueLst_Row);
                                private_addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                            }
                        }
                    }
                } else {
                    for (let colIdx = 0; colIdx < colSplitCnt; colIdx++) {
                        pageStatus[JV.STATUS_CROSS_COL_END] = (colIdx === (colSplitCnt - 1));
                        private_resetBandArea();
                        counterColRec = orgMaxColRec * colIdx;
                        let currentSortedContentSequence = me.sortedContentSequence;
                        let currentSortedColSequence = me.sortedColSequence;
                        if (hasAdHocCol && colIdx === (colSplitCnt - 1)) {
                            currentSortedColSequence = null;
                            currentSortedContentSequence = null;
                            counterColRec = 0;
                        }
                        for (let rowIdx = 0; rowIdx < rowSplitCnt; rowIdx++) {
                            pageStatus[JV.STATUS_CROSS_ROW_END] = (rowIdx === (rowSplitCnt - 1));
                            let needOneMoreRptEnd = false;
                            if ((segIdx === segCnt - 1) && pageStatus[JV.STATUS_CROSS_ROW_END] && pageStatus[JV.STATUS_CROSS_COL_END]) {
                                pageStatus[JV.STATUS_REPORT_END] = true;
                                private_resetBandArea();
                                const hasAdHocColEnd = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_COL_SUM, rptTpl, bands, me.sortedColSequence, segIdx, (colSplitCnt - 1) * orgMaxColRec, maxColRec);
                                const hasAdHocRowEnd = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_SUM, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                                if (hasAdHocColEnd || hasAdHocRowEnd) {
                                    needOneMoreRptEnd = true;
                                    pageStatus[JV.STATUS_REPORT_END] = false;
                                }
                            }
                            private_resetBandArea();
                            me.pageStatusLst.push(pageStatus.slice(0));
                            pageIdx++;
                            counterRowRec = orgMaxRowRec * rowIdx;
                            let currentSortedRowSequence = me.sortedRowSequence;
                            if (hasAdHocRow && rowIdx === (rowSplitCnt - 1)) {
                                currentSortedRowSequence = null;
                                currentSortedContentSequence = null;
                                counterRowRec = 0;
                            }
                            private_addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                            private_addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, me.row_sum_fields_value_total, me.dispSumValueLst_Row);
                            private_addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                            // 处理report end情况
                            if (needOneMoreRptEnd) {
                                pageStatus[JV.STATUS_REPORT_END] = true;
                                private_resetBandArea();
                                currentSortedRowSequence = null;
                                currentSortedContentSequence = null;
                                counterRowRec = 0;
                                me.pageStatusLst.push(pageStatus.slice(0));
                                pageIdx++;
                                private_addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                                private_addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, me.row_sum_fields_value_total, me.dispSumValueLst_Row);
                                private_addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                            }
                        }
                    }
                }
                JpcCrossTabHelper.initialPageStatus(pageStatus);
            }
            // 3. set pageSeq and return the result
            rst = pageIdx;
        }
        bands = null;
        return rst;
    };
    JpcCrossTabResult.outputAsPreviewPage = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const pageStatus = [true, true, true, true, true, true, true, true];
        me.pageStatusLst.push(pageStatus);
        // JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS], null, me.disp_fields_idx, false);
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, true, false);
        const maxRowRec = JpcCrossTabHelper.getMaxRowsPerPage(bands, rptTpl);
        const maxColRec = JpcCrossTabHelper.getMaxColsPerPage(bands, rptTpl);
        const unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        // 1. 交叉行
        rst = rst.concat(me.outputPreviewRowTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, unitFactor));
        // 2. 交叉列
        rst = rst.concat(me.outputPreviewColTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor));
        // 3. 交叉数据
        rst = rst.concat(me.outputPreviewContent(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, unitFactor));
        // 4. 交叉行拓展
        rst = rst.concat(me.outputPreviewTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor));
        // 5. 交叉行拓展合计
        rst = rst.concat(me.outputPreviewSumTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, unitFactor));
        // 6. 交叉列合计
        rst = rst.concat(me.outputPreviewTabSumCol(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, JV.NODE_CROSS_COL_SUM, unitFactor));
        // 6.1 交叉行合计
        rst = rst.concat(me.outputPreviewTabSumRow(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, JV.NODE_CROSS_ROW_SUM, unitFactor));
        // 7. 离散
        rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(rptTpl[JV.NODE_CROSS_INFO][JV.NODE_DISCRETE_INFO], bands, unitFactor, pageStatus));
        return rst;
    };
    JpcCrossTabResult.outputPreviewRowTab = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, unitFactor) {
        let rst = this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW], unitFactor);
        rst = rst.concat(this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_AD_HOC], unitFactor));
        return rst;
    };
    JpcCrossTabResult.outputPreviewColTab = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, maxColRec, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_COL], unitFactor);
    };
    JpcCrossTabResult.outputPreviewContent = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT], unitFactor);
    };
    JpcCrossTabResult.outputPreviewTabSumCol = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, tabNodeName, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl[JV.NODE_CROSS_INFO][tabNodeName], unitFactor);
    };
    JpcCrossTabResult.outputPreviewTabSumRow = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, tabNodeName, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, maxColRec, rptTpl[JV.NODE_CROSS_INFO][tabNodeName], unitFactor);
    };
    JpcCrossTabResult.outputPreviewTabExt = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor) {
        // 交叉行拓展
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, maxColRec, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_EXT], unitFactor);
    };
    JpcCrossTabResult.outputPreviewSumTabExt = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, unitFactor) {
        // 交叉行拓展合计
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, 1, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_SUM_EXT], unitFactor);
    };
    JpcCrossTabResult.private_OutputPreviewCommon = function(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, tab, unitFactor) {
        const me = this;
        const rst = [];
        const band = (tab) ? bands[tab[JV.PROP_BAND_NAME]] : null;
        if (band) {
            const tab_fields = tab[JV.PROP_CROSS_FIELDS];
            for (let rowIdx = 0; rowIdx < maxRowRec; rowIdx++) {
                for (let i = 0; i < tab_fields.length; i++) {
                    const tab_field = tab_fields[i];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        for (let colIdx = 0; colIdx < maxColRec; colIdx++) {
                            if (tab_field[JV.PROP_IS_SERIAL]) {
                                rst.push(me.outputTabField(band, tab_field, [rowIdx + 1], 0, -1, maxRowRec, rowIdx, maxColRec, colIdx, unitFactor, false, controls));
                            } else {
                                rst.push(me.outputTabField(band, tab_field, null, -1, -1, maxRowRec, rowIdx, maxColRec, colIdx, unitFactor, false, controls));
                            }
                        }
                    }
                }
                if (tab[JV.PROP_TEXTS]) {
                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                        for (let colIdx = 0; colIdx < maxColRec; colIdx++) {
                            rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, maxRowRec, rowIdx, maxColRec, colIdx, 1, 0));
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputAsSimpleJSONPage = function(rptTpl, dataObj, page, bands, controls, fonts, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const tabRstLst = [];
        const unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            /*
             let segIdx = page - 1;
             //1 calculate the band position
             JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1]);
             //2. then reset the band height
             let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
             let crossContentBand = bands[tab[JV.PROP_BAND_NAME]];
             let actH = JpcCrossTabHelper.getActualRowsHeight(bands, rptTpl, me.sortedRowSequence, page);
             let actW = JpcCrossTabHelper.getActualColsWidth(bands, rptTpl, me.sortedColSequence, page);
             let offsetY = actH - (crossContentBand.Bottom - crossContentBand.Top);
             let offsetX = actW - (crossContentBand.Right - crossContentBand.Left);
             JpcBandHelper.resetBandPos(rptTpl[JV.NODE_BAND_COLLECTION], bands, crossContentBand, offsetX, offsetY);

             //2.1 Row-Tab
             tabRstLst.push(me.outputRowTab(rptTpl, dataObj, page, bands, unitFactor, controls));
             //2.2 Col-Tab
             tabRstLst.push(me.outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls));
             //2.3 Content-Tab
             tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls));
             //2.4 Sum-Tab Row
             //2.4 Sum-tab Col
             tabRstLst.push(me.outputTabSumCol(rptTpl, dataObj, page, bands, unitFactor, JV.NODE_CROSS_COL_SUM, controls));
             //2.x row tab ext
             tabRstLst.push(me.outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls));
             tabRstLst.push(me.outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls));
             //2.5 Discrete
             tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[JV.NODE_CROSS_INFO][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT, customizeCfg));
             //*/
        } else {
            const segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            const segPageIdx = 0; // 暂时设置为0
            // 1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1]);
            // 2. start to output detail-part
            //  2.1 Row-Tab
            // tabRstLst.push(me.outputRowTab(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputRowTabCommon(rptTpl, dataObj, page, bands, JV.NODE_CROSS_ROW, me.row_fields_idx, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputRowTabCommon(rptTpl, dataObj, page, bands, JV.NODE_CROSS_ROW_AD_HOC, me.row_fields_adhoc_idx, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //  2.2 Col-Tab
            tabRstLst.push(me.outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //  2.3 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //  2.4 Sum-Tab Row
            // 现在要加咯，
            tabRstLst.push(me.outputTabSumRow(rptTpl, dataObj, page, bands, unitFactor, JV.NODE_CROSS_ROW_SUM, controls, $CURRENT_RPT, customizeCfg));
            //  2.4 Sum-tab Col
            tabRstLst.push(me.outputTabSumCol(rptTpl, dataObj, page, bands, unitFactor, JV.NODE_CROSS_COL_SUM, controls, $CURRENT_RPT, customizeCfg));
            //  2.x row tab ext
            tabRstLst.push(me.outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls, $CURRENT_RPT, customizeCfg));
            //  2.5 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[JV.NODE_CROSS_INFO][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, segPageIdx, 1, 0, $CURRENT_RPT, customizeCfg, me.signatureRst, me.signatureDateRst, me.signatureAuditRst));
        }
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        me.checkCombineEvent(JV.RUN_TYPE_AFTER_COMBINE, [], [], rst, $CURRENT_RPT, dataObj);
        return rst;
    };
    JpcCrossTabResult.checkCombineEvent = function($RUN_TYPE, $VER_COMB_ARRAY, $HOR_COMB_ARRAY, $CURRENT_CELL_ITEMS, $CURRENT_RPT, $CURRENT_DATA) {
        if ($CURRENT_RPT.formulas) {
            for (let execFmlIdx = 0; execFmlIdx < $CURRENT_RPT.formulas.length; execFmlIdx++) {
                if ($CURRENT_RPT.formulas[execFmlIdx][JV.PROP_RUN_TYPE] === $RUN_TYPE) {
                    const expression = $CURRENT_RPT.formulas[execFmlIdx][JV.PROP_EXPRESSION];
                    if (expression) {
                        const $ME = $CURRENT_RPT.formulas[execFmlIdx];
                        const $JE = JE;
                        try {
                            eval(expression);
                        } catch (ex) {
                            console.log(ex);
                        }
                    }
                }
            }
        }
    };
    JpcCrossTabResult.outputRowTabCommon = function(rptTpl, dataObj, page, bands, tabStr, rowFieldsIdxArr, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][tabStr];
        const band = (tab) ? bands[tab[JV.PROP_BAND_NAME]] : null;
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                const data_details = dataObj[JV.DATA_DETAIL_DATA];
                const valuesIdx = me.dispValueIdxLst_Row[page - 1];
                const serialsIdx = me.dispSerialIdxLst_Row[page - 1];
                let flexiblePrecisionRefObj = null;
                let flexibleRefField = null;
                let precision_ref_data = null;
                for (let i = 0; i < rowFieldsIdxArr.length; i++) {
                    const tab_field = tab_fields[i];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        let data_field = null;
                        const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                        if (typeof rowFieldsIdxArr[i] !== 'object') {
                            data_field = data_details[rowFieldsIdxArr[i]];
                        } else {
                            if (map_data_field) {
                                data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                            }
                        }
                        const rows = valuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            if (map_data_field && map_data_field[JV.PROP_PRECISION] && map_data_field.flexiblePrecisionRefObj) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    flexibleRefField = JE.F(map_data_field[JV.PROP_PRECISION][JV.PROP_FLEXIBLE_REF_FILED_ID], $CURRENT_RPT);
                                    precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                    for (const decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj['refUnit_' + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, valuesIdx[rowIdx], customizeCfg);
                            } else {
                                if (rowIdx === 0) JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            }
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[rowIdx], serialsIdx[rowIdx], rows, rowIdx, 1, 0, unitFactor, true, controls));
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputColTab = function(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        let firstTextOutput = true;
        const tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_COL];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                const data_details = dataObj[JV.DATA_DETAIL_DATA];
                const valuesIdx = me.dispValueIdxLst_Col[page - 1];
                let flexiblePrecisionRefObj = null;
                let flexibleRefField = null;
                let precision_ref_data = null;
                for (let i = 0; i < me.col_fields_idx.length; i++) {
                    const tab_field = tab_fields[i];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        const mergedRst = [];
                        let data_field = null;
                        const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                        if (typeof me.col_fields_idx[i] !== 'object') {
                            data_field = data_details[me.col_fields_idx[i]];
                        } else {
                            if (map_data_field) {
                                data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                            }
                        }
                        const cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            if (map_data_field && map_data_field[JV.PROP_PRECISION] && map_data_field.flexiblePrecisionRefObj) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    flexibleRefField = JE.F(map_data_field[JV.PROP_PRECISION][JV.PROP_FLEXIBLE_REF_FILED_ID], $CURRENT_RPT);
                                    precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                    for (const decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj['refUnit_' + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, valuesIdx[colIdx], customizeCfg);
                            } else {
                                if (colIdx === 0) JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            }
                            mergedRst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            // rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            // 2. output texts
                            if (firstTextOutput) {
                                if (tab[JV.PROP_TEXT]) {
                                    // mergedRst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab[JV.PROP_TEXTS]) {
                                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                                        // mergedRst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                        // 判断是否需要合并
                        if (tab_field[JV.PROP_IS_MERGE] && mergedRst.length > 1) {
                            let lastCell = mergedRst[mergedRst.length - 1];
                            for (let mergeIdx = mergedRst.length - 2; mergeIdx >= 0; mergeIdx--) {
                                if (lastCell[JV.PROP_VALUE] === mergedRst[mergeIdx][JV.PROP_VALUE]) {
                                    mergedRst[mergeIdx][JV.PROP_AREA][JV.PROP_RIGHT] = lastCell[JV.PROP_AREA][JV.PROP_RIGHT];
                                    mergedRst.splice(mergeIdx + 1, 1);
                                }
                                lastCell = mergedRst[mergeIdx];
                            }
                        }
                        rst = rst.concat(mergedRst);
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputContent = function(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                const data_details = dataObj[JV.DATA_DETAIL_DATA];
                const contentValuesIdx = me.dispValueIdxLst_Content[page - 1];
                let flexiblePrecisionRefObj = null;
                let flexibleRefField = null;
                let precision_ref_data = null;
                for (let i = 0; i < tab_fields.length; i++) {
                    const tab_field = tab_fields[i];
                    let data_field = null;
                    const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                    if (typeof me.content_fields_idx[i] !== 'object') {
                        data_field = data_details[me.content_fields_idx[i]];
                    } else {
                        if (map_data_field) {
                            data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                        }
                    }
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        const rows = contentValuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            const cols = contentValuesIdx[rowIdx].length;
                            for (let colIdx = 0; colIdx < cols; colIdx++) {
                                if (map_data_field && map_data_field[JV.PROP_PRECISION] && map_data_field.flexiblePrecisionRefObj) {
                                    if (flexiblePrecisionRefObj === null) {
                                        flexiblePrecisionRefObj = {};
                                        flexibleRefField = JE.F(map_data_field[JV.PROP_PRECISION][JV.PROP_FLEXIBLE_REF_FILED_ID], $CURRENT_RPT);
                                        precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                        for (const decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                            flexiblePrecisionRefObj['refUnit_' + decimalObj.unit] = decimalObj.decimal;
                                        }
                                    }
                                    JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, contentValuesIdx[rowIdx][colIdx], customizeCfg);
                                } else {
                                    if (colIdx === 0) JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                                }
                                rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][colIdx], -1, rows, rowIdx, cols, colIdx, unitFactor, true, controls));
                            }
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabSumRow = function(rptTpl, dataObj, page, bands, unitFactor, tabNodeName, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][tabNodeName];
        const band = tab ? bands[tab[JV.PROP_BAND_NAME]] : null;
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                for (let i = 0; i < me.dispSumValueLst_Row[page - 1].length; i++) {
                    if (i === 0) {
                        for (let tfIdx = 0; tfIdx < tab_fields.length; tfIdx++) {
                            const map_data_field = JE.F(tab_fields[tfIdx][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[tfIdx], map_data_field, customizeCfg);
                        }
                    }
                    if (me.dispSumValueLst_Row[page - 1][i] !== null) {
                        for (let j = 0; j < me.dispSumValueLst_Row[page - 1][i].length; j++) {
                            const tab_field = tab_fields[j];
                            const val = me.dispSumValueLst_Row[page - 1][i][j];
                            const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, 1, 0, me.dispSumValueLst_Row[page - 1].length, i, 1, 0, true, false);
                            // 方向不同，需要调整下
                            if (!(tab_field[JV.PROP_HIDDEN])) {
                                rst.push(cellItem);
                            }
                        }
                    } else {
                        let sumL = 1;
                        for (let si = 0; si < me.dispSumValueLst_Row.length; si++) {
                            if (me.dispSumValueLst_Row[si][0] !== null) {
                                sumL = me.dispSumValueLst_Row[si][0].length;
                                break;
                            }
                        }
                        for (let j = 0; j < sumL; j++) {
                            const tab_field = tab_fields[j];
                            const val = null;
                            const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, 1, 0, me.dispSumValueLst_Row[page - 1].length, i, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabSumCol = function(rptTpl, dataObj, page, bands, unitFactor, tabNodeName, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][tabNodeName];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                for (let i = 0; i < me.dispSumValueLst_Col[page - 1].length; i++) {
                    if (i === 0) {
                        for (let tfIdx = 0; tfIdx < tab_fields.length; tfIdx++) {
                            const map_data_field = JE.F(tab_fields[tfIdx][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[tfIdx], map_data_field, customizeCfg);
                        }
                    }
                    // console.log('当前页:' + page);
                    // console.log(me.dispSumValueLst_Col[page - 1][i]);
                    if (me.dispSumValueLst_Col[page - 1][i] !== null) {
                        for (let j = 0; j < me.dispSumValueLst_Col[page - 1][i].length; j++) {
                            const tab_field = tab_fields[j];
                            const val = me.dispSumValueLst_Col[page - 1][i][j];
                            const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            if (!(tab_field[JV.PROP_HIDDEN])) {
                                rst.push(cellItem);
                            }
                        }
                    } else {
                        let sumL = 1;
                        for (let si = 0; si < me.dispSumValueLst_Col.length; si++) {
                            if (me.dispSumValueLst_Col[si][0] !== null) {
                                sumL = me.dispSumValueLst_Col[si][0].length;
                                break;
                            }
                        }
                        for (let j = 0; j < sumL; j++) {
                            const tab_field = tab_fields[j];
                            const val = null;
                            const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabExt = function(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        let firstTextOutput = true;
        const tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_EXT];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                const data_details = dataObj[JV.DATA_DETAIL_DATA];
                const valuesIdx = me.dispValueIdxLst_Col[page - 1];
                for (let i = 0; i < me.row_extension_fields_idx.length; i++) {
                    const tab_field = tab_fields[i];
                    let data_field = null;
                    const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                    if (typeof me.row_extension_fields_idx[i] !== 'object') {
                        data_field = data_details[me.row_extension_fields_idx[i]];
                    } else {
                        if (map_data_field) {
                            data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                        }
                    }

                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        const cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            if (colIdx === 0) JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            // 2. output texts if has
                            if (firstTextOutput) {
                                if (tab[JV.PROP_TEXT]) {
                                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab[JV.PROP_TEXTS]) {
                                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                    }
                }
                if (me.row_extension_fields_idx.length === 0) {
                    const cols = valuesIdx.length;
                    for (let colIdx = 0; colIdx < cols; colIdx++) {
                        if (tab[JV.PROP_TEXT]) {
                            rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                        }
                        if (tab[JV.PROP_TEXTS]) {
                            for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                                rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                            }
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputSumTabExt = function(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_SUM_EXT];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true && pageStatus[JV.STATUS_CROSS_ROW_END] === true) {
                const tab_fields = tab[JV.PROP_CROSS_FIELDS];
                const data_details = dataObj[JV.DATA_DETAIL_DATA];
                const data_fields = [];
                for (let i = 0; i < me.row_sum_extension_fields_idx.length; i++) {
                    // let data_field = data_details[me.row_sum_extension_fields_idx[i]];
                    const tab_field = tab_fields[i];
                    let data_field = null;
                    const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                    if (typeof me.row_sum_extension_fields_idx[i] !== 'object') {
                        data_field = data_details[me.row_sum_extension_fields_idx[i]];
                    } else {
                        if (map_data_field) {
                            data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                        }
                    }
                    JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                    data_fields.push(data_field);
                }
                // 2. initialize grand total value
                const rowGrandTotal = [];
                for (let di = 0; di < data_fields.length; di++) {
                    rowGrandTotal[di] = 0.0;
                    // 3. start to sum
                    // 这里的合计实际是章合计来的，需要seg level全部累加
                    for (let i = 0; i < me.sortedColSequence[segIdx].length; i++) {
                        for (let j = 0; j < me.sortedColSequence[segIdx][i].length; j++) {
                            // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(data_fields[di], me.sortedColSequence[segIdx][i][j]);
                            let vTtl = parseFloat(JpcFieldHelper.getValue(data_fields[di], me.sortedColSequence[segIdx][i][j]));
                            if (isNaN(vTtl)) {
                                vTtl = 0;
                            }
                            rowGrandTotal[di] = bc.add(rowGrandTotal[di], vTtl);
                        }
                    }
                }
                // 4. output
                for (let di = 0; di < tab_fields.length; di++) {
                    const tab_field = tab_fields[di];
                    if (!tab_field[JV.PROP_HIDDEN]) {
                        const val = rowGrandTotal[di];
                        const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                        cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(cellItem);
                    }
                }
                // output texts if has
                if (tab[JV.PROP_TEXT]) {
                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (tab[JV.PROP_TEXTS]) {
                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabField = function(band, tab_field, data_field, valueIdx, serialIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls) {
        let rst = null;
        if (isRow === true && tab_field[JV.PROP_IS_SERIAL] && tab_field[JV.PROP_IS_SERIAL] === true) {
            if (serialIdx >= 0) {
                rst = JpcCommonOutputHelper.createCommonOutput(tab_field, serialIdx + 1);
            } else {
                rst = JpcCommonOutputHelper.createCommonOutput(tab_field, '', controls);
            }
        } else {
            rst = JpcCommonOutputHelper.createCommonOutput(tab_field, JpcFieldHelper.getValue(data_field, valueIdx), controls);
        }
        // position
        if (isRow === true) {
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, true, false);
        } else {
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, false, false);
        }
        return rst;
    };

    return JpcCrossTabResult;
};

module.exports = new JpcCrossTabSrv();