Calculation/app/reports/rpt_component/jpc_flow_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 JpcFlowTabHelper = require('./helper/jpc_helper_flow_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 fsUtil = require('../public/fsUtil');
const strUtil = require('../public/stringUtil');
const fontWidthMap = require('./helper/jpc_helper_font_width');
const bc = require('../../lib/base_calc.js');
const SEG_PAGE_SPLIT_STR = '`';
const PAGESIZE_THRESHOLD = 2000; // 报表页码的上限值

const JpcFlowTabSrv = function() {};
JpcFlowTabSrv.prototype.createNew = function() {
    // grpPageInfo ：{"segGrpRecStartIdx": 0, "insertedGrpRecAmt": 0, "preAddPageGrpInfo": null}; //纯属解释参数grpPageInfo结构
    // valueIdx: [isFollowMode, type(normal, auto-height, group), valueIndex, sub-value-index(自动行高特有), total-value-amount(自动行高特有)] //解释 dispValueIdxLst 数据构造
    function private_addPageValue(ValuedIdxLst, sortedSequence, grpSequenceInfo, startRecIdx, maxRecPerPage, page_seg_map, segIdx, pageIdx, grpPageInfo, isFollow, segAutoHeightInfo, prePageLeftAutoHeightRecAmt) {
        let vIdx = [];
        const vFirstIdx = [];
        let preAmt = 0;
        let insertedGrpAmt = 0;
        let grp_lines = 0;
        let hasPrePageGrp = false;
        const followMode = (isFollow) ? JV.TYPE_FOLLOW_MODE : -1;
        let nextPageAutoHeightRecAmt = 0;
        if (grpSequenceInfo && grpPageInfo) {
            if (grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO].length > 0) {
                for (const grpLineIdx of grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO]) {
                    // vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_GROUP, grpPageInfo[JV.PROP_SEG_GRP_IDX], grpLineIdx]);
                    vFirstIdx.push([followMode, JV.DISPLAY_VAL_TYPE_GROUP, grpPageInfo[JV.PROP_SEG_GRP_IDX], grpLineIdx]);
                }
                grpPageInfo[JV.PROP_SEG_GRP_IDX]++;
            }
            preAmt = grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO].length;
            grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO] = [];
            grp_lines = grpPageInfo[JV.PROP_GRP_LINES];
        }
        let autoHeightAmt = 0;
        const private_addAutoHeightPageValue = function(vi) {
            let couldBreak = false;
            let startIdx = 0;
            let ttlValAmt = 0;
            if (segAutoHeightInfo[segIdx].length > startRecIdx + vi) {
                ttlValAmt = segAutoHeightInfo[segIdx][startRecIdx + vi];
            }
            if (prePageLeftAutoHeightRecAmt > 0 && vi === 0) {
                startIdx = prePageLeftAutoHeightRecAmt;
            }
            for (let subValIdx = startIdx; subValIdx < ttlValAmt; subValIdx++) {
                vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_AUTO_HEIGHT, sortedSequence[startRecIdx + vi], subValIdx, ttlValAmt]);
                autoHeightAmt++;
                if (autoHeightAmt >= maxRecPerPage) {
                    nextPageAutoHeightRecAmt = (subValIdx + 1) % ttlValAmt;
                    couldBreak = true;
                    break;
                }
            }
            return couldBreak;
        };
        const private_inner_add_grp_rec = function(vi) {
            let hasFullGrp = true;
            let couldBreak = false;
            for (let i = 0; i < grp_lines; i++) {
                if (vIdx.length >= maxRecPerPage) {
                    if (grp_lines === 1) {
                        hasPrePageGrp = true; // 在此情况下，说明最后一条记录应该是group，但是不够正常空间，那么就硬塞这1条数据!
                        vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_GROUP, grpPageInfo[JV.PROP_SEG_GRP_IDX], i]);
                    } else {
                        for (let j = i; j < grp_lines; j++) {
                            grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO].push(j);
                        }
                        // 准备要跳出去了
                        hasFullGrp = false;
                    }
                    break;
                } else {
                    vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_GROUP, grpPageInfo[JV.PROP_SEG_GRP_IDX], i]);
                }
            }
            // 3. 进位下一个group信息所在位置
            if (hasFullGrp) {
                grpPageInfo[JV.PROP_INSERTED_GRP_REC]++;
                insertedGrpAmt++;
                grpPageInfo[JV.PROP_SEG_GRP_IDX]++;
            } else {
                couldBreak = true;
            }
            return couldBreak;
        };
        const private_normal_add_rec = function(vi) {
            let couldBreak = false;
            if (segAutoHeightInfo && segAutoHeightInfo.length > 0) {
                if (segAutoHeightInfo[segIdx].length > startRecIdx + vi) {
                    couldBreak = private_addAutoHeightPageValue(vi);
                    // if (couldBreak) break;
                } else if (vIdx.length < maxRecPerPage) {
                    vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_NORMAL, JV.BLANK_VALUE_INDEX]);
                }
            } else {
                if (sortedSequence.length > startRecIdx + vi) {
                    vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_NORMAL, sortedSequence[startRecIdx + vi]]);
                } else {
                    vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_NORMAL, JV.BLANK_VALUE_INDEX]);
                }
            }
            return couldBreak;
        };
        for (let vi = 0; (vi + insertedGrpAmt * grp_lines) < maxRecPerPage - preAmt; vi++) {
            if (grpSequenceInfo && grpPageInfo) {
                if ((startRecIdx + vi) === grpSequenceInfo[grpPageInfo[JV.PROP_SEG_GRP_IDX]]) {
                    // 表示这里要插入grouping信息！
                    let couldBreak = false;
                    // 1. 首先push正常的记录(要考虑自动行高调整的分支)
                    if (segAutoHeightInfo && segAutoHeightInfo.length > 0) {
                        couldBreak = private_addAutoHeightPageValue(vi);
                    } else {
                        vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_NORMAL, sortedSequence[startRecIdx + vi]]);
                    }
                    // 2. 然后就要push grouping记录了
                    if (private_inner_add_grp_rec(vi)) break;
                    if (couldBreak) break;
                } else {
                    // 备注： 在有group的情况下，如果grpPageInfo[JV.PROP_SEG_GRP_IDX] 范围大于 grpSequenceInfo.length，则表示已经到最后了，不要再加空白数据了
                    //      ！！！但这是在有ex数据的情况下！！！
                    if (grpPageInfo[JV.PROP_SEG_GRP_IDX] < grpSequenceInfo.length) {
                        if (private_normal_add_rec(vi)) break;
                    } else {
                        // 还得判断是否是普通的流水数据情况，这里可以用isFollow来进行判断，暂时不需要特意加新参数(以后如isFollow的意义有变化则需要调整)
                        if (!isFollow) {
                            if (private_normal_add_rec(vi)) break;
                        } else {
                            break;
                        }
                    }
                }
            } else {
                if (private_normal_add_rec(vi)) break;
            }
        }
        if (vFirstIdx.length > 0) {
            vIdx = vIdx.concat(vFirstIdx);
            // 备注： 在一开始就加grp的情况下，这些数据应该放在后面才对
        }
        page_seg_map.push([pageIdx, segIdx]);
        ValuedIdxLst.push(vIdx);
        return nextPageAutoHeightRecAmt;
    }
    const JpcFlowTabResult = {};
    JpcFlowTabResult.initialize = function(isEx) {
        const me = this;
        me.isEx = isEx;
        me.paging_option = JV.PAGING_OPTION_NORMAL;
        me.segments = [];
        me.dispValueIdxLst = [];
        me.page_seg_map = [];
        me.disp_fields_idx = [];
        me.disp_fields_ex_idx = [];
        me.seg_sum_fields_idx = [];
        me.seg_sum_tab_fields = [];
        me.page_sum_fields_idx = [];
        me.page_sum_tab_fields = [];

        me.auto_height_fields_idx = [];// 那些被标记为判断自动行高的指标集合
        me.auto_height_info = [];
        me.group_check_fields = [];
        me.group_sum_fields = [];
        me.group_sum_values = null;
        me.group_node_info = null; // 记录在哪个seg及到哪条记录后有group sum信息
        me.group_lines_amt = 0; // 每group一次占用多少行，计算page信息会用到

        me.pageStatusLst = [];
        me.groupSumValLst = [];
        me.segSumValLst = [];
        me.pageSumValLst = [];
        me.multiCols = 1;
        me.pagesAmt = 0;

        me.signatureRst = [];
        me.signatureDateRst = [];
        me.signatureAuditRst = [];
        me.interactRst = [];
        me.figureRst = [];

        me.hasBreakFlowArr = [];
    };
    JpcFlowTabResult.sorting = function(rptTpl, dataObj, dataSeq, $CURRENT_RPT) {
        const me = this;
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        if (rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_SEG_SUM]) JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_SEG_SUM][JV.PROP_SUM_FIELDS], me.seg_sum_tab_fields, me.seg_sum_fields_idx, me.isEx);
        if (rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_PAGE_SUM]) JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_PAGE_SUM][JV.PROP_SUM_FIELDS], me.page_sum_tab_fields, me.page_sum_fields_idx, me.isEx);
        if (rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP]) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_FIELDS], me.group_check_fields, null, me.isEx);
            if (rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_LINES]) {
                for (const grpLine of rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_LINES]) {
                    if (grpLine[JV.PROP_GROUP_SUM_KEYS] && grpLine[JV.PROP_GROUP_SUM_KEYS].length > 0) {
                        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, grpLine[JV.PROP_GROUP_SUM_KEYS], me.group_sum_fields, null, me.isEx);
                    }
                }
            }
            for (const grp_sum_f of me.group_sum_fields) {
                grp_sum_f[JV.PROP_SUM_KEY] = 'grp_sum_key_' + grp_sum_f[JV.PROP_FIELD_ID];
            }
        }
        JpcFieldHelper.findAutoHeightFieldIdx(rptTpl, rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS], me.auto_height_fields_idx, me.isEx);
        for (let si = 0; si < dataSeq.length; si++) {
            me.segments.push(dataSeq[si].slice(0));
        }
        // pre-sum the data(for seg sum display)
        // 考虑到实际会有离散指标的汇总，这些离散指标数据是通过计算式后得来的，这种情况下，不适宜在sorting阶段进行汇总统计，现挪到preSetupPages阶段处理
    };
    JpcFlowTabResult.sumSeg = function(dataObj, $CURRENT_RPT) {
        const me = this;
        const data_details = me.isEx ? dataObj[JV.DATA_DETAIL_DATA_EX] : dataObj[JV.DATA_DETAIL_DATA];
        const data_fields = [];
        for (let i = 0; i < me.seg_sum_fields_idx.length; i++) {
            if (typeof (me.seg_sum_fields_idx[i]) === 'object') {
                const exField = JE.F(me.seg_sum_fields_idx[i][JV.PROP_ID], $CURRENT_RPT);
                if (exField) {
                    data_fields.push(exField[JV.PROP_AD_HOC_DATA]);
                } else {
                    data_fields.push(null);
                }
            } else {
                const data_field = data_details[me.seg_sum_fields_idx[i]];
                data_fields.push(data_field);
            }
        }
        for (let i = 0; i < me.segments.length; i++) { // seg level
            if (me.segments[i].length > 0) {
                const rowGrandTotal = [];
                for (let di = 0; di < data_fields.length; di++) {
                    rowGrandTotal.push(0.0);
                    let precisionAmt = 4;
                    const sum_field = JE.F(me.seg_sum_tab_fields[di][JV.PROP_FIELD_ID], $CURRENT_RPT);
                    if (sum_field[JV.PROP_PRECISION] && sum_field[JV.PROP_PRECISION].type === 'fixed') {
                        precisionAmt = sum_field[JV.PROP_FIXED_PRECISION_AMT];
                    } else {
                        const flowF = me.seg_sum_tab_fields[di];
                        if (flowF && !strUtil.isEmptyString(flowF[JV.PROP_FORMAT])) {
                            const idx = flowF[JV.PROP_FORMAT].indexOf('.');
                            if (idx >= 0) {
                                precisionAmt = flowF[JV.PROP_FORMAT].length - idx - 1;
                            }
                        }
                    }
                    // for (let j = 0; j < me.segments[i].length; j++) {
                    //     // 3. start to sum
                    //     // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(data_fields[di], me.segments[i][j]);
                    //     const sv = JpcFieldHelper.getValue(data_fields[di], me.segments[i][j]);
                    //     if (sv) {
                    //         rowGrandTotal[di] = rowGrandTotal[di] + parseFloat(parseFloat(sv).toFixed(precisionAmt));
                    //     }
                    // }
                    for (let j = 0; j < me.segments[i].length; j++) {
                        let sv = JpcFieldHelper.getValue(data_fields[di], me.segments[i][j]);
                        if (sv) {
                            if (typeof sv === 'string') sv = parseFloat(sv);
                            rowGrandTotal[di] = bc.add(rowGrandTotal[di] ? rowGrandTotal[di] : 0, sv ? sv : 0);
                        }
                    }
                }
                me.segSumValLst.push(rowGrandTotal);
            }
        }
    };

    JpcFlowTabResult.sumUpGrp = function(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx) {
        const me = this;
        const segDataIdx = me.segments[segIdx];
        for (let j = 0; j < me.group_sum_fields.length; j++) {
            const sum_field = JE.F(me.group_sum_fields[j][JV.PROP_FIELD_ID], $CURRENT_RPT);
            if (sum_field) {
                let data_field = null;
                if (sum_field[JV.PROP_AD_HOC_DATA]) {
                    data_field = sum_field[JV.PROP_AD_HOC_DATA];
                } else {
                    data_field = dataObj[sum_field.DataNodeName][sum_field.DataSeq];
                }
                let sumV = 0;
                let precisionAmt = 4;
                for (let si = preGrpIdx; si <= nexGrpIdx; si++) {
                    if (sum_field[JV.PROP_PRECISION] && sum_field[JV.PROP_PRECISION].type === 'fixed') {
                        precisionAmt = sum_field[JV.PROP_FIXED_PRECISION_AMT];
                    } else {
                        const flowF = me.group_sum_fields[j]; // 调整后，me.group_sum_fields[j]就是group lines下数组SumKey_S的元素值，无需再找
                        if (flowF && !strUtil.isEmptyString(flowF[JV.PROP_FORMAT])) {
                            const idx = flowF[JV.PROP_FORMAT].indexOf('.');
                            if (idx >= 0) {
                                precisionAmt = flowF[JV.PROP_FORMAT].length - idx - 1;
                            }
                        }
                    }
                    // sumV += parseFloat(JpcFieldHelper.getValue(data_field, segDataIdx[si]));

                    let sv = JpcFieldHelper.getValue(data_field, segDataIdx[si]);
                    if (sv) {
                        if (typeof sv === 'string') sv = parseFloat(sv);
                        sumV = bc.add(sumV, sv ? sv : 0);
                    }
                    // sumV += parseFloat(parseFloat(JpcFieldHelper.getValue(data_field, segDataIdx[si])).toFixed(precisionAmt));
                }
                // me.group_sum_values[segIdx][j].push(sumV);
                me.group_sum_values[segIdx][me.group_sum_fields[j][JV.PROP_SUM_KEY]].push(sumV);
            }
        }
        me.group_node_info[segIdx].push(nexGrpIdx);
    };
    JpcFlowTabResult.setupGroupingData = function(rptTpl, dataObj, $CURRENT_RPT) {
        const me = this;
        if (me.group_check_fields.length > 0 && me.group_sum_fields.length > 0) {
            me.group_sum_values = [];
            me.group_node_info = [];
            const CURRENT_FLOW_INFO = (me.isEx) ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
            me.group_lines_amt = rptTpl[CURRENT_FLOW_INFO][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_LINES].length;

            let preGrpIdx = 0;
            let nexGrpIdx = 0;
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                const segDataIdx = me.segments[segIdx];
                // me.group_sum_values.push([]);
                me.group_sum_values.push({});
                me.group_node_info.push([]);
                for (let j = 0; j < me.group_sum_fields.length; j++) {
                    // me.group_sum_values[segIdx].push([]);
                    me.group_sum_values[segIdx][me.group_sum_fields[j][JV.PROP_SUM_KEY]] = [];
                    // me.group_node_info[segIdx].push([]);
                }
                for (let di = 0; di < segDataIdx.length; di++) {
                    let hasDiff = false;
                    if (di >= 1) {
                        for (let i = 0; i < me.group_check_fields.length; i++) {
                            const grp_field = JE.F(me.group_check_fields[i][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            if (grp_field) {
                                let data_field = null;
                                if (grp_field[JV.PROP_AD_HOC_DATA]) {
                                    data_field = grp_field[JV.PROP_AD_HOC_DATA];
                                } else {
                                    data_field = dataObj[grp_field.DataNodeName][grp_field.DataSeq];
                                }
                                const v1 = JpcFieldHelper.getValue(data_field, segDataIdx[di]);
                                const v2 = JpcFieldHelper.getValue(data_field, segDataIdx[di - 1]);
                                if (v1 !== v2) {
                                    hasDiff = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (hasDiff) {
                        // then sum up the fields
                        me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx);
                        nexGrpIdx = di;
                        preGrpIdx = di;
                        if (di === segDataIdx.length - 1) {
                            me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx);
                        }
                    } else if (di === segDataIdx.length - 1) {
                        me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, di);
                    } else {
                        nexGrpIdx = di;
                    }
                }
            }
        }
    };
    JpcFlowTabResult.setupAutoHeightData = function(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties, outputType) {
        const me = this;
        if (me.auto_height_fields_idx.length > 0) {
            const CURRENT_FLOW_INFO = (me.isEx) ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
            const band = bands[rptTpl[CURRENT_FLOW_INFO][JV.NODE_FLOW_CONTENT][JV.PROP_BAND_NAME]];
            const data_details = me.isEx ? dataObj[JV.DATA_DETAIL_DATA_EX] : dataObj[JV.DATA_DETAIL_DATA];
            const tab_fields = rptTpl[CURRENT_FLOW_INFO][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS];
            const adHocAutoHeightStyleStr = [];
            const reg1 = new RegExp('\n\r', 'g');
            const reg2 = new RegExp('\r\n', 'g');
            const reg3 = new RegExp('\n', 'g');
            const reg4 = new RegExp('\r', 'g');
            const reg5 = new RegExp('\t', 'g');
            const fonts = defProperties.fonts;
            const fontCache = {};
            const private_get_font = function(fontKey) {
                let rst = null;
                if (fontCache[fontKey]) {
                    rst = fontCache[fontKey];
                } else {
                    for (let i = 0; i < fonts.length; i++) {
                        if (fonts[i][JV.PROP_ID] === fontKey) {
                            fontCache[fontKey] = fonts[i];
                            rst = fonts[i];
                            break;
                        }
                    }
                }
                return rst;
            };
            const private_get_max_lines_of_the_record = function(theRecIdx) {
                let rst = 1;
                let maxAmt = 1;
                for (let loop = 0; loop < me.auto_height_fields_idx.length; loop++) {
                    /*
                    let data_field = null;
                    let tab_field = me.auto_height_fields_idx[loop][1];
                    if (me.auto_height_fields_idx[loop][0] !== JV.BLANK_FIELD_INDEX) {
                        data_field = data_details[me.auto_height_fields_idx[loop][0]];
                    }
                    /*/
                    const tab_field = me.auto_height_fields_idx[loop][1];
                    let data_field = null;
                    const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                    if (me.auto_height_fields_idx[loop][0] !== JV.BLANK_FIELD_INDEX && (typeof me.auto_height_fields_idx[loop][0] !== 'object')) {
                        data_field = data_details[me.auto_height_fields_idx[loop][0]];
                    } else {
                        if (map_data_field) {
                            data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                        }
                    }
                    // */
                    if (data_field) {
                        let value = JpcFieldHelper.getValue(data_field, theRecIdx);
                        const area = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, 1, 1, 0, 1, 0, 1, 0, false, false);
                        if (value !== null && value !== undefined) {
                            if (typeof value === 'string') {
                                value = value.replace('\t', '');
                                value = value.replace(reg1, '|').replace(reg2, '|').replace(reg3, '|').replace(reg4, '|').replace(reg5, '');
                            } else {
                                value = '' + value;
                            }
                        } else {
                            value = '';
                        }
                        JpcFieldHelper.setValue(data_field, theRecIdx, value);
                        const values = value.split('|');
                        // if (values.length > rst) rst = values.length; // 考虑到紧凑输出，不能那么快设置rst
                        const font = private_get_font(tab_field[JV.PROP_FONT]);
                        let chkFontName = '宋体';
                        let chkFontHeight = 12;
                        if (font) {
                            chkFontName = font[JV.FONT_PROPS[0]];
                            chkFontHeight = parseFloat(font[JV.FONT_PROPS[JV.FONT_PROP_IDX_HEIGHT]]);
                        }
                        let hasSplitStr = false;
                        let splitStrArr = [];
                        let accAmt = 0;
                        const chnW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '宽');
                        const otherW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '窄');
                        for (let i = 0; i < values.length; i++) {
                            const amt = JpcCommonHelper.getStringLinesInArea(area, values[i], chnW, otherW);
                            accAmt += amt;
                            if (amt > 1) {
                                hasSplitStr = true;
                                splitStrArr.push(i);
                            }
                        }
                        // if (accAmt > rst) rst = accAmt;
                        if (rst > 3) {
                            // 新优化，计算实际能显示完的真正行数
                            const rowHeight = JpcFlowTabHelper.getRowHeight(bands, rptTpl, me.isEx);
                            const tmpFV = ((chkFontHeight + JV.CLOSE_OUTPUT_ROW_BUFFER) * accAmt) / rowHeight;
                            let tmpAmt = Math.floor(tmpFV);
                            if (Math.ceil(tmpFV) > tmpAmt) {
                                tmpAmt++;
                            }
                            // rst = tmpAmt;
                            if (maxAmt < tmpAmt) maxAmt = tmpAmt;
                        } else {
                            if (maxAmt < accAmt) maxAmt = accAmt;
                        }
                        // if (hasSplitStr && outputType !== JV.OUTPUT_TYPE_EXCEL) {
                        if (hasSplitStr) {
                            let newValArr = [];
                            for (let i = 0; i < values.length; i++) {
                                if (splitStrArr.indexOf(i) < 0) {
                                    newValArr.push(values[i]);
                                } else {
                                    newValArr = newValArr.concat(JpcCommonHelper.splitString(area, values[i], chnW, otherW));
                                }
                            }
                            JpcFieldHelper.setValue(data_field, theRecIdx, newValArr.join('|'));
                            splitStrArr = [];
                            newValArr = [];
                        }
                        // 备注： 如果outputType是excel类型，那么就只保留原始的分行符，无需介入分行，由excel本身去处理分行，只需要保留足够的空间即可。
                        //      根据最新需求，暂时不考虑excel类型输出,换回原来逻辑
                    }
                }
                if (rst < maxAmt) rst = maxAmt; // 最后才设置最大结果
                return rst;
            };
            for (const tabField of tab_fields) {
                if (adHocAutoHeightStyleStr.indexOf(tabField[JV.PROP_STYLE]) < 0) {
                    adHocAutoHeightStyleStr.push(tabField[JV.PROP_STYLE]);
                }
            }
            if (adHocAutoHeightStyleStr.length > 0) {
                if (!(rptTpl[JV.NODE_STYLE_COLLECTION])) {
                    rptTpl[JV.NODE_STYLE_COLLECTION] = [];
                }
                for (const styleStr of adHocAutoHeightStyleStr) {
                    rptTpl[JV.NODE_STYLE_COLLECTION].push({ ID: styleStr + '_AutoHeightMerge_Top' });
                    rptTpl[JV.NODE_STYLE_COLLECTION].push({ ID: styleStr + '_AutoHeightMerge_Middle' });
                    rptTpl[JV.NODE_STYLE_COLLECTION].push({ ID: styleStr + '_AutoHeightMerge_Bottom' });
                }
            }
            // 这里先记录下来每一Segment里的每一条record占用行的数量（普通是1行高度，超过1就表示需要调整行数了）
            const infoArr = [];
            me.auto_height_info.push(infoArr);
            const segArr = me.segments[segIdx];
            for (let i = 0; i < segArr.length; i++) {
                infoArr.push(private_get_max_lines_of_the_record(segArr[i]));
            }
        }
    };

    JpcFlowTabResult.getDftRowsPerPage = function(rptTpl, defProperties, $CURRENT_RPT) {
        const me = this;
        let rst = 1;
        const bands = JpcBand.createNew(rptTpl, defProperties);
        const pageStatus = [true, true, true, true, true, true, true, true];
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, true, false);
        rst = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, false);
        return rst;
    };

    JpcFlowTabResult.preSetupPages = function(rptTpl, dataObj, defProperties, option, $CURRENT_RPT, followTabEx, outputType) {
        // 换一种思路来整理流水式数据
        const me = this;
        let rst = 1;
        let counterRowRec = 0;
        let counterRowRecEx = 0;
        let maxRowRec = 1;
        let pageIdx = 0;
        let currentRecAmt = 0;
        me.paging_option = option || JV.PAGING_OPTION_NORMAL;

        if (rptTpl[JV.NODE_CUSTOM_DEFINE] && rptTpl[JV.NODE_CUSTOM_DEFINE][JV.NODE_CUS_OPTION]) {
            const optionStr = rptTpl[JV.NODE_CUSTOM_DEFINE][JV.NODE_CUS_OPTION] || '';
            if (optionStr.includes('sheetSplitMasterID') && optionStr.includes('sheetSplitDetailID')) {
                // 导出Excel时的操作选项(比如：TASK：5565 根据主从关系分多个sheet导出)，但在这里只是把option对象装出来，后续使用
                me.excelExportOptions = JSON.parse(optionStr.replace(/\n/g, ''));
                // 找masterID指标及detailID指标
                me.excelExportOptions.segs = {};
                me.excelExportOptions.segsAmt = 0;
                me.excelExportOptions.masterField = JE.F(me.excelExportOptions.sheetSplitMasterID, $CURRENT_RPT);
                me.excelExportOptions.detailField = JE.F(me.excelExportOptions.sheetSplitDetailID, $CURRENT_RPT);
                if (me.excelExportOptions.sheetNameID) me.excelExportOptions.sheetNameField = JE.F(me.excelExportOptions.sheetNameID, $CURRENT_RPT);
            }
            if (optionStr.includes('fileSplitMasterID') && optionStr.includes('fileSplitDetailID')) {
                // 导出Excel时的操作选项(类似上面，但需要导出成单独的Excel文件)
                me.excelFileExportOptions = JSON.parse(optionStr.replace(/\n/g, ''));
                me.excelFileExportOptions.segs = {};
                me.excelFileExportOptions.segsAmt = 0;
                me.excelFileExportOptions.masterField = JE.F(me.excelFileExportOptions.fileSplitMasterID, $CURRENT_RPT);
                me.excelFileExportOptions.detailField = JE.F(me.excelFileExportOptions.fileSplitDetailID, $CURRENT_RPT);
                if (me.excelFileExportOptions.fileNameID) me.excelFileExportOptions.fileNameField = JE.F(me.excelFileExportOptions.fileNameID, $CURRENT_RPT);
                //
            }
        }

        const CURRENT_FLOW_INFO = (me.isEx) ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[CURRENT_FLOW_INFO][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS], null, me.disp_fields_idx, me.isEx);
        if (followTabEx) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_FLOW_INFO_EX][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS], null, me.disp_fields_ex_idx, true);
        }
        // 根据实际情况，统计前要先根据format整理好小数位数，否则会出现显示的数据的累计与最后统计的结果不一致
        me.setupGroupingData(rptTpl, dataObj, $CURRENT_RPT);
        if (followTabEx) {
            followTabEx.setupGroupingData(rptTpl, dataObj, $CURRENT_RPT);
        }
        me.sumSeg(dataObj, $CURRENT_RPT); // 考虑到实际会有离散指标的汇总，这些离散指标数据是通过计算式后得来的，这种情况下，不适宜在sorting阶段进行汇总统计，现统一挪到这里处理
        // const _chkHasBreakFlow = function(segIdx, pageIdx) {
        //     if (rptTpl[JV.NODE_FLOW_INFO][JV.NODE_DISCRETE_INFO]) {
        //         for (const discrete of rptTpl[JV.NODE_FLOW_INFO][JV.NODE_DISCRETE_INFO]) {
        //             if (discrete[JV.PROP_DISCRETE_FIELDS] && discrete[JV.PROP_DISCRETE_FIELDS].length > 0) {
        //                 for (const df of discrete[JV.PROP_DISCRETE_FIELDS]) {
        //                     const map_data_field = JE.F(df[JV.PROP_FIELD_ID], $CURRENT_RPT);
        //                     if (map_data_field) {
        //                         const val = JE.getFieldValue(map_data_field, dataObj, segIdx, '');
        //                         if (typeof val === 'string') {
        //                             if (val.indexOf(SEG_PAGE_SPLIT_STR) >= 0) {
        //                                 me.hasBreakFlowArr[pageIdx][0] = true;
        //                                 break;
        //                             }
        //                         }
        //                     }
        //                     if (me.hasBreakFlowArr[pageIdx][0]) break;
        //                 }
        //             }
        //             if (me.hasBreakFlowArr[pageIdx][0]) break;
        //         }
        //     }
        // };
        const bands = JpcBand.createNew(rptTpl, defProperties);
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            rst = me.segments.length;
            const pageStatus = [true, true, false, true, true, true, true, true];
            const grpPageInfo = {};
            let pageIdx = 0;
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                /*
                me.hasBreakFlowArr[pageIdx] = [];
                me.hasBreakFlowArr[pageIdx][0] = false;
                me.hasBreakFlowArr[pageIdx][1] = segIdx;
                _chkHasBreakFlow(segIdx, pageIdx);
                //*/
                // 备注：有break flow的情况下 连续输出 要考虑段(seg)的多页输出问题
                if (segIdx === me.segments.length - 1) {
                    pageStatus[JV.STATUS_REPORT_END] = true;
                }
                if (segIdx > 0) {
                    pageStatus[JV.STATUS_REPORT_START] = false;
                }
                const grpSeqInfo = (me.group_node_info) ? me.group_node_info[segIdx] : null;
                const grpRecAmt = (grpSeqInfo) ? (grpSeqInfo.length * me.group_lines_amt) : 0;
                grpPageInfo[JV.PROP_SEG_GRP_IDX] = 0;
                grpPageInfo[JV.PROP_INSERTED_GRP_REC] = 0;
                grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO] = [];
                grpPageInfo[JV.PROP_GRP_LINES] = me.group_lines_amt;
                JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, !me.isEx, me.isEx);
                maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
                me.setupAutoHeightData(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties, outputType);
                let adHocAutoHeightAmt = 0;
                if (me.auto_height_info.length > 0) {
                    for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                        adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                    }
                }
                me.pageStatusLst.push(pageStatus.slice(0));
                pageIdx++;
                const rowAmt = Math.max(maxRowRec, me.segments[segIdx].length + adHocAutoHeightAmt);
                /*
                if (me.hasBreakFlowArr[pageIdx][0]) {
                    let accAmt = 0;
                    rowAmt = maxRowRec;
                    while (accAmt < me.segments[segIdx].length + adHocAutoHeightAmt) {
                        me.hasBreakFlowArr[pageIdx][0] = true;
                        me.hasBreakFlowArr[pageIdx][1] = segIdx;
                        private_addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, 0, rowAmt, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, 0);
                        pageIdx++;
                        accAmt += maxRowRec;
                        // remark: 需要再细化
                    }
                } else {
                    private_addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, 0, rowAmt, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, 0);
                    pageIdx++;
                }
                //*/
                private_addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, 0, rowAmt, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, 0);
            }
            // 目前不支持flowTabEx
        } else {
            const pageStatus = [true, true, false, true, false, false, false, false];
            if (me.isEx) {
                pageStatus[JV.STATUS_REPORT_START] = false;
            }
            if (rptTpl[CURRENT_FLOW_INFO][JV.PROP_MULTI_COLUMN]) {
                me.multiCols = 1 * rptTpl[CURRENT_FLOW_INFO][JV.PROP_MULTI_COLUMN];
            }
            const grpPageInfo = {};
            let prePageLeftAutoHeightRecAmt = 0; // 考虑自动行高的跨页情况
            const private_resetBandArea = function() {
                JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, !me.isEx, me.isEx);
                maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
            };
            let handledRowAmt = 0; // handledRowAmt纪录的是真正处理过的显示行数，包含了空白行，主要是为分页用（自动行高）
            let segRestRecAmt = 0; // 一般情况下为0，只有在特殊情况下才需要，如09-x表中，正常流水一页显示不了的时候，就有大问题了
            const private_addPage = function(segIdx, grpSeqInfo, isFollow, isMix, mixSplitPoint) {
                private_resetBandArea();
                me.pageStatusLst.push(pageStatus.slice(0));
                currentRecAmt += maxRowRec; // 在自动行高的场景下，currentRecAmt在后面还需要调整
                handledRowAmt += maxRowRec;
                let redundantRecAmt = 0;
                pageIdx++;
                function private_chk_handle_rec_amt(dv, isEx) {
                    if ((dv[1] === JV.DISPLAY_VAL_TYPE_NORMAL) || (dv[1] === JV.DISPLAY_VAL_TYPE_AUTO_HEIGHT && dv[3] === dv[4] - 1)) {
                        if (isEx) { counterRowRecEx++; } else counterRowRec++;
                    } else if (dv[1] === JV.DISPLAY_VAL_TYPE_AUTO_HEIGHT) {
                        redundantRecAmt++;
                    }
                }
                let restRecAmt = 0;
                if (isMix) {
                    // 先处理上半部分
                    prePageLeftAutoHeightRecAmt = private_addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, counterRowRec, mixSplitPoint, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, prePageLeftAutoHeightRecAmt);
                    for (const dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, false);
                    }
                    // 再处理下半部分
                    restRecAmt = maxRowRec - me.dispValueIdxLst[me.dispValueIdxLst.length - 1].length; // 备注：在一些极端条件下，mixSplitPoint这个分割点不合适处理下半部分数据，以实际生成的value-index数量为准
                    // private_addPageValue(me.dispValueIdxLst, followTabEx.segments[segIdx], null, counterRowRecEx, maxRowRec - mixSplitPoint, me.page_seg_map, segIdx, pageIdx, null, true, null, 0);
                    private_addPageValue(me.dispValueIdxLst, followTabEx.segments[segIdx], null, counterRowRecEx, restRecAmt, me.page_seg_map, segIdx, pageIdx, null, true, null, 0);
                    for (const dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, true);
                    }
                    // 合并到一页中
                    me.page_seg_map.splice(me.page_seg_map.length - 1, 1);
                    const vl = me.dispValueIdxLst[me.dispValueIdxLst.length - 2];
                    for (const item of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        vl.push(item);
                    }
                    me.dispValueIdxLst.splice(me.dispValueIdxLst.length - 1, 1);
                } else if (isFollow) {
                    prePageLeftAutoHeightRecAmt = private_addPageValue(me.dispValueIdxLst, followTabEx.segments[segIdx], null, counterRowRecEx, maxRowRec, me.page_seg_map, segIdx, pageIdx, null, true, null, 0);
                    for (const dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, true);
                    }
                } else {
                    prePageLeftAutoHeightRecAmt = private_addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, counterRowRec, maxRowRec, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, prePageLeftAutoHeightRecAmt);
                    for (const dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, false);
                    }
                }
                currentRecAmt -= redundantRecAmt; // 在自动行高调整场景下，需要减去冗余的数量
                if (restRecAmt < 0) {
                    currentRecAmt -= restRecAmt;
                    segRestRecAmt = restRecAmt;
                }
            };
            const pagesForPreSplit = [];
            let splitFieldInfo;
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                if (dataObj.splitArcVals) {
                    // 流水式的分页强制以主数据划分，如果不是，那后果由做模板的人负责
                    pagesForPreSplit.push(Math.ceil((pageIdx + 1) / me.multiCols));
                    if (segIdx === 0) {
                        splitFieldInfo = { Name: dataObj.splitField.Name, ID: dataObj.splitField.ID, splitPageValues: [] };
                    }
                    splitFieldInfo.splitPageValues.push(dataObj.splitArcVals[segIdx]);
                }
                const grpSeqInfo = (me.group_node_info) ? me.group_node_info[segIdx] : null;
                const grpRecAmt = (grpSeqInfo) ? (grpSeqInfo.length * me.group_lines_amt) : 0;
                let grpRecAmtEx = 0;
                let accAutoHeightAmt = 0; // 累计的自动行高数量
                handledRowAmt = 0; // 初始化每一段的已处理纪录行数
                segRestRecAmt = 0;
                if (followTabEx && followTabEx.group_node_info) {
                    grpRecAmtEx = followTabEx.group_node_info.length * followTabEx.group_lines_amt;
                }
                grpPageInfo[JV.PROP_SEG_GRP_IDX] = 0;
                grpPageInfo[JV.PROP_INSERTED_GRP_REC] = 0;
                grpPageInfo[JV.PROP_PRE_ADD_GRP_REC_INFO] = [];
                grpPageInfo[JV.PROP_GRP_LINES] = me.group_lines_amt;
                pageStatus[JV.STATUS_SEGMENT_START] = true;
                private_resetBandArea();
                me.setupAutoHeightData(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties, outputType);
                let threshold = 0;
                currentRecAmt = 0;
                counterRowRec = 0;
                counterRowRecEx = 0;
                let ttlSegRecAmtNormal = me.segments[segIdx].length + grpRecAmt; // 正常的segment下的数据长度累计(含grouping data)
                let ttlSegRecAmt = (followTabEx) ? (me.segments[segIdx].length + grpRecAmt + followTabEx.segments[segIdx].length + grpRecAmtEx) : (me.segments[segIdx].length + grpRecAmt); // 所有的segment下的数据长度累计(包括ex部分)
                let adHocAutoHeightAmt = 0;
                let normalContentAmt = 0;
                let exBuffer = 0;
                let adHocAutoHeightGrpStartIdx = 0;
                if (me.auto_height_fields_idx.length > 0) {
                    for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                        adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                        normalContentAmt++;
                        if (me.group_node_info && me.group_node_info[segIdx]) {
                            if (me.group_node_info[segIdx][adHocAutoHeightGrpStartIdx] === loop) {
                                adHocAutoHeightGrpStartIdx++;
                            }
                        }
                    }
                    ttlSegRecAmtNormal += adHocAutoHeightAmt;
                    ttlSegRecAmt += adHocAutoHeightAmt;
                    if (adHocAutoHeightAmt > 0) exBuffer = grpRecAmt;
                }
                // 自动行高调整在多流水合并方式时，只支持前部分(后期需要再加)
                while (true) {
                    if (currentRecAmt > 0) pageStatus[JV.STATUS_SEGMENT_START] = false;
                    if (pageIdx > 0) pageStatus[JV.STATUS_REPORT_START] = false;
                    private_resetBandArea(); // 这里得预先算maxRowRec（实际数据情况，会有章首页框，在章数据多的情况下，章第二页开始就得补上章首页框不显示遗留下来的row）
                    // 开始判断各种scenarios
                    adHocAutoHeightAmt = 0;
                    if (me.auto_height_fields_idx.length > 0) {
                        adHocAutoHeightAmt -= prePageLeftAutoHeightRecAmt;
                        for (let loop = currentRecAmt; loop < currentRecAmt + maxRowRec; loop++) {
                            if (me.auto_height_info[segIdx].length > loop) {
                                adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                            } else {
                                break;
                            }
                        }
                    }
                    if ((ttlSegRecAmtNormal < ttlSegRecAmt) || (followTabEx !== null)) {
                        // 有流水拓展，并且是follow mode
                        if (currentRecAmt + accAutoHeightAmt + exBuffer + maxRowRec > ttlSegRecAmtNormal) {
                            if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                // 纯 followTabEx 数据
                                if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                    pageStatus[JV.STATUS_SEGMENT_END] = true;
                                    private_resetBandArea();
                                    const hasAdHocRow = !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, currentRecAmt + adHocAutoHeightAmt, maxRowRec, me.isEx);
                                    if (hasAdHocRow) {
                                        // add page info(pre segment end)
                                        pageStatus[JV.STATUS_SEGMENT_END] = false;
                                        private_addPage(segIdx, null, true, false, -1);
                                    }
                                    // add page info
                                    pageStatus[JV.STATUS_SEGMENT_END] = true;
                                    private_addPage(segIdx, null, true, false, -1);
                                } else {
                                    private_addPage(segIdx, null, true, false, -1);
                                }
                            } else {
                                // 混合数据
                                // if (currentRecAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                    pageStatus[JV.STATUS_SEGMENT_END] = true;
                                    private_resetBandArea();
                                    const hasAdHocRow = !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, currentRecAmt + adHocAutoHeightAmt, maxRowRec, me.isEx);
                                    if (hasAdHocRow) {
                                        // add page info(pre segment end)
                                        pageStatus[JV.STATUS_SEGMENT_END] = false;
                                        private_addPage(segIdx, grpSeqInfo, false, true, ttlSegRecAmtNormal);
                                    }
                                    // add page info
                                    pageStatus[JV.STATUS_SEGMENT_END] = true;
                                    // if (currentRecAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                    if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                        // 纯 followTabEx 数据啦
                                        private_addPage(segIdx, null, true, false, -1);
                                    } else {
                                        private_addPage(segIdx, grpSeqInfo, false, true, ttlSegRecAmtNormal);
                                    }
                                } else {
                                    // 在这里要考虑如果有多页正常的流水数据情况，那么就得考虑这页有多少条普通流水记录，不应该一刀切地用ttlSegRecAmtNormal
                                    const splitPoint = ttlSegRecAmtNormal - handledRowAmt;
                                    private_addPage(segIdx, grpSeqInfo, false, true, splitPoint);
                                }
                            }
                        } else {
                            // 纯followTab数据
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                        }
                    } else {
                        // 普通流水数据情况
                        if (handledRowAmt + maxRowRec >= ttlSegRecAmt) {
                            // 备注： 理论上自动行高是没有上限的，有可能正常一页的数据可以拓展到3页及以上，在此极端情况下，必须做一些限制判断，否则会出现缺页情况。
                            // 2018-08-04 其实之前的判断逻辑完全是自找麻烦，而且还不够正确。其实只需要判断已经处理了多少行纪录(所有的都算，包括空白行)，
                            // 与总的seg纪录数想比较，就很容易得到结果，而且能处理极端边界的情况。
                            pageStatus[JV.STATUS_SEGMENT_END] = true;
                            // pageStatus[JV.STATUS_REPORT_END] = true;
                            pageStatus[JV.STATUS_REPORT_END] = (segIdx === me.segments.length - 1);
                            private_resetBandArea();
                            const hasAdHocRow = ((adHocAutoHeightAmt > maxRowRec) || !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, handledRowAmt, maxRowRec, me.isEx));

                            if (hasAdHocRow) {
                                // add page info(pre segment end)
                                pageStatus[JV.STATUS_SEGMENT_END] = false;
                                pageStatus[JV.STATUS_REPORT_END] = false;
                                private_addPage(segIdx, grpSeqInfo, false, false, -1);
                                pageStatus[JV.STATUS_REPORT_START] = false;
                                pageStatus[JV.STATUS_SEGMENT_START] = false;
                            }
                            // add page info
                            pageStatus[JV.STATUS_SEGMENT_END] = true;
                            pageStatus[JV.STATUS_REPORT_END] = (segIdx === me.segments.length - 1);
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                            pageStatus[JV.STATUS_SEGMENT_END] = false; // 加完章统计页后，记得把章尾页设置为false
                        } else {
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                        }
                    }
                    // 检测是否可退出
                    if (handledRowAmt >= (ttlSegRecAmt + segRestRecAmt) && (pageIdx % me.multiCols === 0)) {
                        // 备注：这里必须得考虑多栏的情况，否则会造成pageStatus出界的问题
                        break;
                    }
                    accAutoHeightAmt += adHocAutoHeightAmt;
                    // 控制阈值，超过阈值则强制退出，防止死循环
                    threshold++;
                    if (threshold > PAGESIZE_THRESHOLD) {
                        console.log('Hey! There may be a dead loop here!!!');
                        break;
                    }
                }
            }
            if (dataObj.splitArcVals) {
                dataObj.splitArcPages = pagesForPreSplit;
                dataObj.splitArcPagesInfo = splitFieldInfo;
            }
            rst = Math.ceil(pageIdx / me.multiCols);
        }
        me.pagesAmt = rst;
        return rst;
    };

    JpcFlowTabResult.outputAsPreviewPage = function(rptTpl, bands, controls, $CURRENT_RPT) {
        const me = this;
        let rst = [];
        const vIdx = [];
        // 只预览第一页的数据
        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 = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, false);
        for (let i = 0; i < maxRowRec; i++) {
            vIdx.push([-1, JV.DISPLAY_VAL_TYPE_NORMAL, JV.BLANK_VALUE_INDEX]);
        }
        const unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        // 2.2 Column tab
        rst = rst.concat(me.outputColumn(rptTpl, null, 1, 0, 0, bands, unitFactor, 0, $CURRENT_RPT, null));
        // 2.1 Content-Tab
        rst = rst.concat(me.outputPreviewContent(rptTpl, bands, unitFactor, controls, pageStatus, maxRowRec));
        // 2.3 Sum Seg
        rst = rst.concat(me.outputPreviewSegSum(rptTpl, bands, unitFactor, controls, pageStatus));
        // 2.4 Sum Page
        rst = rst.concat(me.outputPreviewPageSum(rptTpl, bands, unitFactor, controls, pageStatus));
        // 2.5 Group
        // 2.6 Discrete
        me.interactRst = [];
        rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(rptTpl[JV.NODE_FLOW_INFO][JV.NODE_DISCRETE_INFO], bands, unitFactor, pageStatus, $CURRENT_RPT, me.interactRst, me.signatureRst, me.signatureDateRst, me.signatureAuditRst));
        return rst;
    };
    JpcFlowTabResult.outputAsSimpleJSONPage = function(rptTpl, dataObj, page, bands, controls, fonts, adHocMergePos, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const tabRstLst = [];
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        const unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        // 电子签名内容需要先清空
        me.signatureRst = [];
        me.signatureDateRst = [];
        me.signatureAuditRst = [];
        me.interactRst = [];
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            const segIdx = page - 1;
            // 1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1], !me.isEx, me.isEx);
            const maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
            // 2. then reset the band height
            const tab = rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_CONTENT];
            const flowContentBand = bands[tab[JV.PROP_BAND_NAME]];
            let adHocAutoHeightAmt = 0;
            if (me.auto_height_info.length > 0) {
                for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                    adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                }
            }
            const rowAmt = Math.max(maxRowRec, me.segments[segIdx].length + adHocAutoHeightAmt); // 如不满一页，则需要填充满一页
            // if (me.hasBreakFlowArr[segIdx]) {
            //     rowAmt = maxRowRec;
            // }
            const actH = JpcFlowTabHelper.getActualContentAreaHeight(bands, rptTpl, me.segments, rowAmt, page, me.isEx);
            const offsetY = actH - (flowContentBand.Bottom - flowContentBand.Top);
            JpcBandHelper.resetBandPos(rptTpl[JV.NODE_BAND_COLLECTION], bands, flowContentBand, 0, offsetY);
            // 2.1 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, fonts, 0, $CURRENT_RPT, customizeCfg));
            // 2.2 Column tab
            tabRstLst.push(me.outputColumn(rptTpl, dataObj, page, segIdx, 0, bands, unitFactor, 0, $CURRENT_RPT, customizeCfg));
            // 2.3 Sum Seg
            tabRstLst.push(me.outputSegSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            // 2.4 Sum Page
            tabRstLst.push(me.outputPageSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            // 2.5 Group
            // 2.6 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[FLOW_NODE_STR][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 0, 1, 0, $CURRENT_RPT, customizeCfg, me.signatureRst, me.signatureDateRst, me.signatureAuditRst, me.interactRst));
            // 3. reset merge band position
            if (bands[JV.BAND_PROP_MERGE_BAND] && adHocMergePos) {
                const mergedBand = bands[JV.BAND_PROP_MERGE_BAND];
                let arr = [];
                arr.push(parseInt(mergedBand[JV.PROP_LEFT].toFixed(0)));
                adHocMergePos[JV.PROP_LEFT] = arr;
                arr = [];
                arr.push(parseInt(mergedBand[JV.PROP_RIGHT].toFixed(0)));
                adHocMergePos[JV.PROP_RIGHT] = arr;
                arr = [];
                arr.push(parseInt(mergedBand[JV.PROP_TOP].toFixed(0)));
                adHocMergePos[JV.PROP_TOP] = arr;
                arr = [];
                arr.push(parseInt((mergedBand[JV.PROP_BOTTOM]).toFixed(0)));
                adHocMergePos[JV.PROP_BOTTOM] = arr;
            }
        } else {
            const segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            const segPageIdx = JpcCommonHelper.getSegPageIdxByPage(page, me.page_seg_map);
            if (me.excelExportOptions) {
                // 整理excel导出页码数据
                if (!me.excelExportOptions.segs[`_${segIdx}`]) me.excelExportOptions.segs[`_${segIdx}`] = { pages: [], sheetName: `${segIdx + 1}` };
                me.excelExportOptions.segs[`_${segIdx}`].pages.push(page);
                if (me.excelExportOptions.segsAmt < (segIdx + 1)) me.excelExportOptions.segsAmt = segIdx + 1;
                if (me.excelExportOptions.sheetNameField) {
                    const sheetName = JE.getFieldValue(me.excelExportOptions.sheetNameField, dataObj, segIdx, '');
                    me.excelExportOptions.segs[`_${segIdx}`].sheetName = sheetName;
                }
            }
            if (me.excelFileExportOptions) {
                const sVal = me.excelFileExportOptions.orgMasterFieldValues[segIdx];
                // 整理excel导出文件数据
                if (me.excelFileExportOptions.segs[sVal]) me.excelFileExportOptions.segs[sVal].pages.push(page);
            }
            // 1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1], !me.isEx, me.isEx);
            // 2. start to output detail-part
            for (let pi = 0; pi < me.multiCols; pi++) {
                const actualPage = (page - 1) * me.multiCols + pi + 1;
                // 2.1 Content-Tab
                tabRstLst.push(me.outputContent(rptTpl, dataObj, actualPage, bands, unitFactor, controls, fonts, pi, $CURRENT_RPT, customizeCfg));
                if (me.multiCols === 1) me.prepareBlankCellsForErase(tabRstLst[tabRstLst.length - 1]);
                // 2.2 Column tab
                tabRstLst.push(me.outputColumn(rptTpl, dataObj, actualPage, segIdx, segPageIdx, bands, unitFactor, pi, $CURRENT_RPT, customizeCfg));
                // 2.3 Sum Seg
                tabRstLst.push(me.outputSegSum(rptTpl, dataObj, actualPage, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
                // 2.4 Sum Page
                tabRstLst.push(me.outputPageSum(rptTpl, dataObj, actualPage, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
                // 2.5 Group
                // 2.6 Discrete
                if (pi === 0) {
                    tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[FLOW_NODE_STR][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[actualPage - 1], segIdx, segPageIdx, 1, pi, $CURRENT_RPT, customizeCfg, me.signatureRst, me.signatureDateRst, me.signatureAuditRst, me.interactRst));
                }
            }
        }
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        return rst;
    };
    JpcFlowTabResult.setPageFlow = function(rptTpl, dataObj, page, thisPageRst, $CURRENT_RPT) {
        const me = this;
        const segPageIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
        // me.page_seg_map
        // 专门的'流程'签字处理
        if (rptTpl[JV.NODE_CUSTOM_DEFINE] && rptTpl[JV.NODE_CUSTOM_DEFINE][JV.NODE_CUS_OPTION]) {
            const flowStr = rptTpl[JV.NODE_CUSTOM_DEFINE][JV.NODE_CUS_OPTION] || '';
            if (flowStr.includes('"ledgerFieldId"')) {
                // 得先判断是否有这个台账ID（判断是含双引号的），毕竟这个选项是通用的
                const flowObj = JSON.parse(flowStr);
                if (flowObj.ledgerFieldId) {
                    const flowField = JE.F(flowObj.ledgerFieldId, $CURRENT_RPT);
                    const flowDataField = dataObj[flowField.DataNodeName][flowField.DataSeq];
                    thisPageRst[JV.PROP_EXT_FLOW_OPTIONS] = flowDataField[segPageIdx] || '';
                }
            }
        }
        //
    };
    JpcFlowTabResult.prepareBlankCellsForErase = function(contentCells) {
        // 此方法过滤出符合要求的空白行cells，并初始化 pageBlankCellsForErase
        const me = this;
        const rstCells = [];
        const tmpCells = [];
        me.pageBlankCellsForErase = [];
        let minLeft = 10000,
            maxRight = -1;
        // 1. 首先收集所有空cell
        contentCells.forEach(cell => {
            if (cell.Value === '' || cell.Value === null) {
                tmpCells.push(cell);
            }
            if (cell.area[JV.PROP_LEFT] < minLeft) minLeft = cell.area[JV.PROP_LEFT];
            if (cell.area[JV.PROP_RIGHT] > maxRight) maxRight = cell.area[JV.PROP_RIGHT];
        });
        if (tmpCells.length > 0) {
            // 2. 以top为基准归类所有同top位置的cells
            const cellCache = {};
            let maxCnt = 0;
            tmpCells.forEach(cell => {
                const preTop = cell.area[JV.PROP_TOP];
                const cacheKey = `_${preTop}`;
                if (!cellCache[cacheKey]) {
                    cellCache[cacheKey] = [];
                }
                cellCache[cacheKey].push(cell);
            });
            // 3. 剔除不完整的行(cell高度不一致、左右位置没有衔接、数量不正等)
            const propKeys = [];
            for (const key in cellCache) {
                // 3.1 剔除前再排一次序
                cellCache[key].sort(function(c1, c2) {
                    return c1.area[JV.PROP_LEFT] - c2.area[JV.PROP_LEFT];
                });
                // 3.2 先剔除高度不一致、左右位置没衔接
                let isAlign = true;
                let preCell = cellCache[key][0];
                if (maxCnt < cellCache[key].length) maxCnt = cellCache[key].length;
                const cHeight = preCell.area[JV.PROP_BOTTOM] - preCell.area[JV.PROP_TOP];
                for (let idx = 1; idx < cellCache[key].length; idx++) {
                    const cH = cellCache[key][idx].area[JV.PROP_BOTTOM] - cellCache[key][idx].area[JV.PROP_TOP];
                    if (preCell.area[JV.PROP_RIGHT] !== cellCache[key][idx].area[JV.PROP_LEFT] || cHeight !== cH) {
                        isAlign = false;
                        break;
                    }
                    preCell = cellCache[key][idx];
                }
                if (isAlign) propKeys.push(key);
            }
            // 3.3 再剔除数量不正的（这里的判断是有争议的，可能理论上应该是那种贴着MergeBorder的左右位置的为准，但后又想到一种特殊情况，左右带竖行输出的，这种判断不合适了
            //     所以应该这样判断：上下位置要连续的，不能断节！），那么 propKeys 应该再做一次排序
            propKeys.sort(function(key1, key2) {
                let rst = 0;
                const v1 = parseFloat(key1.slice(1, key1.length));
                const v2 = parseFloat(key2.slice(1, key2.length));
                rst = v1 - v2;
                return rst;
            });
            propKeys.forEach(propKey => {
                if (maxCnt === cellCache[propKey].length) {
                    rstCells.push(...cellCache[propKey]);
                }
            });
            // 3.4 还真的出现需要判断是否贴边的情况(3.3)，从数据来看，这种情况还真的出现几率较大，反而带竖行输出的几率极少，这必须得认真考虑
            if (rstCells.length > 0) {
                let hasLeft = false,
                    hasRight = false;
                rstCells.forEach(cell => {
                    if (cell.area[JV.PROP_LEFT] === minLeft) hasLeft = true;
                    if (cell.area[JV.PROP_RIGHT] === maxRight) hasRight = true;
                });
                if (!hasLeft || !hasRight) {
                    rstCells.splice(0, rstCells.length);
                }
            }
        }
        // console.log(rstCells);
        me.pageBlankCellsForErase.push(...rstCells);
    };
    JpcFlowTabResult.eraseBlankCells = function(rptTpl, pageItem) {
        const me = this;
        const liftUpCells = (cells, maxBottom, upHeight, forceToAdjust = false) => {
            if (cells && cells.length > 0) {
                cells.forEach(cell => {
                    if (forceToAdjust || cell.area[JV.PROP_TOP] >= maxBottom) {
                        cell.area[JV.PROP_TOP] -= upHeight;
                        cell.area[JV.PROP_BOTTOM] -= upHeight;
                    } else if (forceToAdjust || cell.area[JV.PROP_BOTTOM] > maxBottom) {
                        // 未来可能会有那种特殊cell(如左右竖行): top在maxBottom之上，bottom在maxBottom之下，那么需要的是align bottom，减upHeight高度
                        cell.area[JV.PROP_BOTTOM] -= upHeight;
                    }
                });
            }
        };
        if (rptTpl[JV.NODE_FLOW_INFO][JV.PROP_ERASE_BLANK_ROWS] && me.pageBlankCellsForErase && me.pageBlankCellsForErase.length > 0) {
            // 1. 确定好位置和高度
            const cTop = me.pageBlankCellsForErase[0].area[JV.PROP_TOP];
            const cBottom = me.pageBlankCellsForErase[me.pageBlankCellsForErase.length - 1].area[JV.PROP_BOTTOM];
            const cHeight = cBottom - cTop;
            // 2. 开始重新设置
            // 2.1 剔除cells下的空行
            me.pageBlankCellsForErase.forEach(eCell => {
                const idx = pageItem.cells.indexOf(eCell);
                if (idx >= 0) pageItem.cells.splice(idx, 1);
            });
            me.pageBlankCellsForErase.splice(0, me.pageBlankCellsForErase.length);
            // 2.2 边框位置提上
            if (pageItem[JV.PROP_PAGE_MERGE_BORDER]) {
                // pageItem[JV.PROP_PAGE_MERGE_BORDER][JV.PROP_TOP] -= cHeight;
                pageItem[JV.PROP_PAGE_MERGE_BORDER][JV.PROP_BOTTOM] -= cHeight;
            }
            // 2.3 cells其他位置提上
            liftUpCells(pageItem[JV.PROP_CELLS], cBottom, cHeight);
            // 2.4 签名位置调整(签名、日期、意见等)
            liftUpCells(pageItem[JV.PROP_SIGNATURE_CELLS], cBottom, cHeight);
            liftUpCells(pageItem[JV.PROP_SIGNATURE_DATE_CELLS], cBottom, cHeight);
            liftUpCells(pageItem[JV.PROP_SIGNATURE_AUDIT_CELLS], cBottom, cHeight);
            liftUpCells(pageItem[JV.PROP_INTERACT_CELLS], cBottom, cHeight);
            liftUpCells(pageItem[JV.PROP_FIGURE_CELLS], cBottom, cHeight); // 这个用途不一样，提法不同
            pageItem.liftUpInfo = {
                liftUpCheckBottom: cBottom,
                liftUpHeight: cHeight,
            }; // 这里要把提上信息放上去，为签章准备
        }
    };
    JpcFlowTabResult.combinePageCells = function(rstPageCells, verticalCombinePos, horizonCombinePos, controls, fonts) {
        // let me = this;
        // 备注：纵向合并要考虑以下因素：
        //     如果有多个column纵向合并，需要总体考虑分割，
        //     假如：第一列的前3个数据(1、2、3)是相同的，第二列中第2、3、4行数据相同，那么第二列只能合并2、3行的数据，不能合并到第四行
        //     同理如此类推第三列...n列
        // 另：要考虑紧密输出情况，需要重新拆分数据
        const _splitValues = function(oCell) {
            // JpcFieldHelper.setValue(data_field, theRecIdx, value);
            const values = (typeof oCell.Value === 'string') ? oCell.Value.split('|') : [oCell.Value];
            let font = oCell[JV.PROP_FONT];
            if (typeof oCell[JV.PROP_FONT] === 'string') {
                font = fonts[oCell[JV.PROP_FONT]];
            }
            // // if (values.length > rst) rst = values.length; // 考虑到紧凑输出，不能那么快设置rst
            // const font = private_get_font(tab_field[JV.PROP_FONT]);
            let chkFontName = '宋体';
            let chkFontHeight = 12;
            if (font) {
                chkFontName = font[JV.FONT_PROPS[0]];
                chkFontHeight = parseFloat(font[JV.FONT_PROPS[JV.FONT_PROP_IDX_HEIGHT]]);
            }
            let hasSplitStr = false;
            const splitStrArr = [];
            let accAmt = 0;
            const chnW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '宽');
            const otherW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '窄');
            for (let i = 0; i < values.length; i++) {
                const amt = JpcCommonHelper.getStringLinesInArea(oCell.area, values[i], chnW, otherW);
                accAmt += amt;
                if (amt > 1) {
                    hasSplitStr = true;
                    splitStrArr.push(i);
                }
            }
            if (hasSplitStr) {
                let newValArr = [];
                for (let i = 0; i < values.length; i++) {
                    if (splitStrArr.indexOf(i) < 0) {
                        newValArr.push(values[i]);
                    } else {
                        newValArr = newValArr.concat(JpcCommonHelper.splitString(oCell.area, values[i], chnW, otherW));
                    }
                }
                oCell.Value = newValArr.join('|');
            }
        };
        if (verticalCombinePos.length > 0 || horizonCombinePos.length > 1) {
            const cacheObj = { vCache: {}, hCache: {}, hCacheStr: [] };
            const removeCellIds = [];
            const reservedCells = [];
            for (const vPosArr of verticalCombinePos) {
                const pStr = '_' + vPosArr[0] + '_' + vPosArr[1];
                cacheObj.vCache[pStr] = [];
            }
            // horizonCombinePos不需要预记
            for (let idx = 0; idx < rstPageCells.length; idx++) {
                const cell = rstPageCells[idx];
                for (const vPosArr of verticalCombinePos) {
                    if (cell[JV.PROP_AREA][JV.PROP_LEFT] === vPosArr[0] && cell[JV.PROP_AREA][JV.PROP_RIGHT] === vPosArr[1]) {
                        cacheObj.vCache['_' + vPosArr[0] + '_' + vPosArr[1]].push(idx);
                    }
                }
                for (const hPosArr of horizonCombinePos) {
                    if (cell[JV.PROP_AREA][JV.PROP_LEFT] === hPosArr[0] && cell[JV.PROP_AREA][JV.PROP_RIGHT] === hPosArr[1]) {
                        const hpStr = '_' + cell[JV.PROP_AREA][JV.PROP_TOP] + '_' + cell[JV.PROP_AREA][JV.PROP_BOTTOM];
                        if (cacheObj.hCacheStr.indexOf(hpStr) < 0) {
                            cacheObj.hCache[hpStr] = [];
                            cacheObj.hCacheStr.push(hpStr);
                        }
                        cacheObj.hCache[hpStr].push(idx);
                    }
                }
            }
            if (verticalCombinePos.length > 0) {
                const preColMergePosArr = []; // 见上面备注描述，纪录当前列的分割坐标集合情况
                const private_chk_in_pre_merge = function(preIdx, newCell) {
                    let rst = true;
                    if (preIdx >= 0 && preIdx < preColMergePosArr.length) {
                        for (const mergeArea of preColMergePosArr[preIdx]) {
                            if (newCell[JV.PROP_AREA][JV.PROP_TOP] >= mergeArea[0] && newCell[JV.PROP_AREA][JV.PROP_TOP] < mergeArea[1]) {
                                rst = (newCell[JV.PROP_AREA][JV.PROP_BOTTOM] <= mergeArea[1]);
                                break;
                            }
                        }
                    }
                    return rst;
                };
                for (let vidx = 0; vidx < verticalCombinePos.length; vidx++) {
                    const vPosArr = verticalCombinePos[vidx];
                    const pStr = '_' + vPosArr[0] + '_' + vPosArr[1];
                    // rstPageCells的结果已经是按顺序排列了，这里不用再排序
                    if (cacheObj.vCache[pStr] && cacheObj.vCache[pStr].length > 0) {
                        let preCell = rstPageCells[cacheObj.vCache[pStr][0]];
                        if (vidx === 0) {
                            // 这里要处理下
                            let minY = 10000;
                            let maxY = 0;
                            for (let preCIdx = 0; preCIdx < cacheObj.vCache[pStr].length; preCIdx++) {
                                if (minY > rstPageCells[cacheObj.vCache[pStr][preCIdx]][JV.PROP_AREA][JV.PROP_TOP]) minY = rstPageCells[cacheObj.vCache[pStr][preCIdx]][JV.PROP_AREA][JV.PROP_TOP];
                                if (maxY < rstPageCells[cacheObj.vCache[pStr][preCIdx]][JV.PROP_AREA][JV.PROP_BOTTOM]) maxY = rstPageCells[cacheObj.vCache[pStr][preCIdx]][JV.PROP_AREA][JV.PROP_BOTTOM];
                            }
                            preColMergePosArr.push([[minY, maxY]]);
                        }
                        const dtlColMergePosArr = [];
                        preColMergePosArr.push(dtlColMergePosArr);
                        for (let cIdx = 1; cIdx < cacheObj.vCache[pStr].length; cIdx++) {
                            if (preCell.Value === '') {
                                dtlColMergePosArr.push([preCell[JV.PROP_AREA][JV.PROP_TOP], preCell[JV.PROP_AREA][JV.PROP_BOTTOM]]);
                                preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                            } else {
                                if (preCell.Value === rstPageCells[cacheObj.vCache[pStr][cIdx]].Value) {
                                    const bkBottom = preCell[JV.PROP_AREA][JV.PROP_BOTTOM];
                                    preCell[JV.PROP_AREA][JV.PROP_BOTTOM] = rstPageCells[cacheObj.vCache[pStr][cIdx]][JV.PROP_AREA][JV.PROP_BOTTOM];
                                    if (reservedCells.indexOf(preCell) < 0) {
                                        reservedCells.push(preCell);
                                    }
                                    if (private_chk_in_pre_merge(vidx, preCell)) {
                                        removeCellIds.push(cacheObj.vCache[pStr][cIdx]);
                                        if (cIdx === cacheObj.vCache[pStr].length - 1) {
                                            dtlColMergePosArr.push([preCell[JV.PROP_AREA][JV.PROP_TOP], preCell[JV.PROP_AREA][JV.PROP_BOTTOM]]);
                                        }
                                    } else {
                                        preCell[JV.PROP_AREA][JV.PROP_BOTTOM] = bkBottom;
                                        dtlColMergePosArr.push([preCell[JV.PROP_AREA][JV.PROP_TOP], preCell[JV.PROP_AREA][JV.PROP_BOTTOM]]);
                                        preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                                    }
                                } else {
                                    dtlColMergePosArr.push([preCell[JV.PROP_AREA][JV.PROP_TOP], preCell[JV.PROP_AREA][JV.PROP_BOTTOM]]);
                                    preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                                }
                            }
                        }
                    }
                }
            }
            if (horizonCombinePos.length > 1) {
                if (cacheObj.hCacheStr.length > 0) {
                    for (const hStr of cacheObj.hCacheStr) {
                        let preCell = rstPageCells[cacheObj.hCache[hStr][0]];
                        for (let cIdx = 1; cIdx < cacheObj.hCache[hStr].length; cIdx++) {
                            if (preCell.Value === '') {
                                preCell = rstPageCells[cacheObj.hCache[hStr][cIdx]];
                            } else {
                                if (preCell.Value === rstPageCells[cacheObj.hCache[hStr][cIdx]].Value) {
                                    if (preCell[JV.PROP_AREA][JV.PROP_RIGHT] < rstPageCells[cacheObj.hCache[hStr][cIdx]][JV.PROP_AREA][JV.PROP_RIGHT]) {
                                        preCell[JV.PROP_AREA][JV.PROP_RIGHT] = rstPageCells[cacheObj.hCache[hStr][cIdx]][JV.PROP_AREA][JV.PROP_RIGHT];
                                    } else {
                                        preCell[JV.PROP_AREA][JV.PROP_LEFT] = rstPageCells[cacheObj.hCache[hStr][cIdx]][JV.PROP_AREA][JV.PROP_LEFT];
                                    }
                                    removeCellIds.push(cacheObj.hCache[hStr][cIdx]);
                                } else {
                                    preCell = rstPageCells[cacheObj.hCache[hStr][cIdx]];
                                }
                            }
                        }
                    }
                }
            }
            if (removeCellIds.length > 0) {
                // 排序，保证一定的顺序，不能用默认的方式(默认方式是针对字符串的简单排序)
                removeCellIds.sort(function(idx1, idx2) {
                    return idx1 - idx2;
                });
                for (let idx = removeCellIds.length - 1; idx >= 0; idx--) {
                    rstPageCells.splice(removeCellIds[idx], 1);
                }
            }
            if (reservedCells.length > 0) {
                for (const rCell of reservedCells) {
                    // 要拆分下数据
                    _splitValues(rCell);
                    setupControl(rCell, controls, true);
                }
            }
        }
    };
    JpcFlowTabResult.outputPreviewContent = function(rptTpl, bands, unitFactor, controls, pageStatus, maxRec) {
        const me = this;
        const rst = [];
        const tab = rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_CONTENT];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                const tab_fields = tab[JV.PROP_FLOW_FIELDS];
                for (let rowIdx = 0; rowIdx < maxRec; rowIdx++) {
                    for (let i = 0; i < tab_fields.length; i++) {
                        const tab_field = tab_fields[i];
                        if (!(tab_field[JV.PROP_HIDDEN])) {
                            rst.push(me.outputTabField(band, tab_field, null, -1, -1, maxRec, rowIdx, 1, 0, unitFactor, false, controls, 0));
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputContent = function(rptTpl, dataObj, page, bands, unitFactor, controls, fonts, multiColIdx, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const prepareObj = {};
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        const tab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_CONTENT];
        const tabEx = (rptTpl[JV.NODE_FLOW_INFO_EX]) ? rptTpl[JV.NODE_FLOW_INFO_EX][JV.NODE_FLOW_CONTENT] : null;
        const verticalCombinePos = [];
        const horizonCombinePos = []; // 合并特性用
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                const tab_fields = tab[JV.PROP_FLOW_FIELDS];
                const tab_fields_ex = tabEx ? tabEx[JV.PROP_FLOW_FIELDS] : null;
                const data_details = me.isEx ? dataObj[JV.DATA_DETAIL_DATA_EX] : dataObj[JV.DATA_DETAIL_DATA];
                const data_details_ex = $CURRENT_RPT.isFollowMode ? dataObj[JV.DATA_DETAIL_DATA_EX] : null;
                const contentValuesIdx = me.dispValueIdxLst[page - 1];
                const page_sum_data_fields = [];
                for (let i = 0; i < me.page_sum_fields_idx.length; i++) {
                    if (typeof (me.page_sum_fields_idx[i]) === 'object') {
                        const exField = JE.F(me.page_sum_fields_idx[i][JV.PROP_ID], $CURRENT_RPT);
                        if (exField) {
                            page_sum_data_fields.push(exField[JV.PROP_AD_HOC_DATA]);
                        } else {
                            page_sum_data_fields.push(null);
                        }
                    } else {
                        const data_field = data_details[me.page_sum_fields_idx[i]];
                        page_sum_data_fields.push(data_field);
                    }
                }
                const rowGrandTotal = [];
                for (let di = 0; di < page_sum_data_fields.length; di++) {
                    rowGrandTotal.push(0.0);
                }
                // normal content
                let flexiblePrecisionRefObj = null;
                let flexibleRefField = null;
                let precision_ref_data = null;
                for (let rowIdx = 0; rowIdx < contentValuesIdx.length; rowIdx++) {
                    for (let fieldIdx = 0; fieldIdx < tab_fields.length; fieldIdx++) {
                        const tab_field = tab_fields[fieldIdx];
                        let data_field = null;
                        const map_data_field = JE.F(tab_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                        if (me.disp_fields_idx[fieldIdx] !== JV.BLANK_FIELD_INDEX && (typeof me.disp_fields_idx[fieldIdx] !== 'object')) {
                            data_field = data_details[me.disp_fields_idx[fieldIdx]];
                        } else {
                            if (map_data_field) {
                                data_field = map_data_field[JV.PROP_AD_HOC_DATA];
                            }
                        }
                        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][2], customizeCfg);
                        } else {
                            if (rowIdx === 0) JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                        }
                        if (!(tab_field[JV.PROP_HIDDEN])) {
                            if (contentValuesIdx[rowIdx][0] !== JV.TYPE_FOLLOW_MODE && contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_NORMAL) {
                                rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                            } else if (contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_AUTO_HEIGHT) {
                                if (contentValuesIdx[rowIdx][4] === 1) {
                                    // 等效于普通输出
                                    rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                                } else {
                                    // 这里需要做些style调整(中间的那些横杠线去掉)
                                    const cellItem = me.outputAutoHeightTabField(band, tab_field, data_field, contentValuesIdx[rowIdx], contentValuesIdx.length, rowIdx, 1, 0, unitFactor, true, controls, multiColIdx);
                                    rst.push(cellItem);
                                    if (contentValuesIdx[rowIdx][3] === 0 || rowIdx === 0) {
                                        cellItem[JV.PROP_STYLE] = cellItem[JV.PROP_STYLE] + '_AutoHeightMerge_Top';
                                    } else if (contentValuesIdx[rowIdx][3] === contentValuesIdx[rowIdx][4] - 1) {
                                        cellItem[JV.PROP_STYLE] = cellItem[JV.PROP_STYLE] + '_AutoHeightMerge_Bottom';
                                    } else {
                                        cellItem[JV.PROP_STYLE] = cellItem[JV.PROP_STYLE] + '_AutoHeightMerge_Middle';
                                    }
                                    prepareAutoHeightCells(prepareObj, cellItem, rst.length - 1, rst);
                                }
                            }
                        }
                        if (rowIdx === 0 && tab_field[JV.PROP_COMBINE_TYPE] !== undefined && tab_field[JV.PROP_COMBINE_TYPE] !== null) {
                            const rstCellItem = rst[rst.length - 1];
                            const cbfPos = [];
                            cbfPos.push(rstCellItem[JV.PROP_AREA][JV.PROP_LEFT]);
                            cbfPos.push(rstCellItem[JV.PROP_AREA][JV.PROP_RIGHT]);
                            if (tab_field[JV.PROP_COMBINE_TYPE] === 'vertical') {
                                verticalCombinePos.push(cbfPos);
                            } else if (tab_field[JV.PROP_COMBINE_TYPE] === 'horizon') {
                                horizonCombinePos.push(cbfPos);
                            }
                        }
                    }
                    if (contentValuesIdx[rowIdx][0] === JV.TYPE_FOLLOW_MODE) {
                        for (let idx_ex = 0; idx_ex < tab_fields_ex.length; idx_ex++) {
                            const tab_fieldex = tab_fields_ex[idx_ex];
                            let data_fieldex = null;
                            const map_data_fieldex = JE.F(tab_fieldex[JV.PROP_FIELD_ID], $CURRENT_RPT);
                            if (me.disp_fields_ex_idx[idx_ex] !== JV.BLANK_FIELD_INDEX && (typeof me.disp_fields_ex_idx[idx_ex] !== 'object')) {
                                data_fieldex = data_details_ex[me.disp_fields_ex_idx[idx_ex]];
                            } else {
                                if (map_data_fieldex) {
                                    data_fieldex = map_data_fieldex[JV.PROP_AD_HOC_DATA];
                                }
                            }
                            if (map_data_fieldex && map_data_fieldex[JV.PROP_PRECISION] && map_data_fieldex.flexiblePrecisionRefObj) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    flexibleRefField = JE.F(map_data_fieldex[JV.PROP_PRECISION][JV.PROP_FLEXIBLE_REF_FILED_ID], $CURRENT_RPT);
                                    for (const decimalObj of map_data_fieldex.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj['refUnit_' + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_fieldex, flexibleRefField, flexiblePrecisionRefObj, contentValuesIdx[rowIdx][2], customizeCfg);
                            } else {
                                if (rowIdx === 0) JpcFieldHelper.resetFormat(tab_fieldex, map_data_fieldex, customizeCfg);
                            }
                            if (!(tab_fieldex[JV.PROP_HIDDEN])) {
                                if (contentValuesIdx[rowIdx][0] === JV.TYPE_FOLLOW_MODE && contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_NORMAL) {
                                    rst.push(me.outputTabField(band, tab_fieldex, data_fieldex, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                                }
                            }
                        }
                    }
                    // page sum content
                    for (let di = 0; di < page_sum_data_fields.length; di++) {
                        if (contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_NORMAL ||
                            contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_AUTO_HEIGHT && contentValuesIdx[rowIdx][3] === 0) {
                            let precisionAmt = 4;
                            const sum_field = JE.F(me.page_sum_tab_fields[di][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            if (sum_field[JV.PROP_PRECISION] && sum_field[JV.PROP_PRECISION].type === 'fixed') {
                                precisionAmt = sum_field[JV.PROP_FIXED_PRECISION_AMT];
                            } else {
                                const flowF = me.page_sum_tab_fields[di];
                                if (flowF && !strUtil.isEmptyString(flowF[JV.PROP_FORMAT])) {
                                    const idx = flowF[JV.PROP_FORMAT].indexOf('.');
                                    if (idx >= 0) {
                                        precisionAmt = flowF[JV.PROP_FORMAT].length - idx - 1;
                                    }
                                }
                            }
                            // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(page_sum_data_fields[di], contentValuesIdx[rowIdx][2]);
                            if (contentValuesIdx[rowIdx][2] >= 0) {
                                const psv = JpcFieldHelper.getValue(page_sum_data_fields[di], contentValuesIdx[rowIdx][2]);
                                if (psv) {
                                    rowGrandTotal[di] = bc.add(rowGrandTotal[di] ? rowGrandTotal[di] : 0, parseFloat(psv));
                                    // rowGrandTotal[di] = rowGrandTotal[di] + parseFloat(parseFloat(psv).toFixed(precisionAmt));
                                }
                            }
                        }
                    }
                }
                me.pageSumValLst.push(rowGrandTotal);
                // grouping content
                let grpCntIdx = 0;
                for (let rowIdx = 0; rowIdx < contentValuesIdx.length; rowIdx++) {
                    if (contentValuesIdx[rowIdx][1] === JV.DISPLAY_VAL_TYPE_GROUP) {
                        for (let grpIdx = 0; grpIdx < rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_LINES].length; grpIdx++) {
                            if (contentValuesIdx[rowIdx][3] === grpIdx) {
                                const grp_line = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_GROUP][JV.PROP_GROUP_LINES][grpIdx];
                                if (page === 1) {
                                    if (grp_line[JV.PROP_GROUP_SUM_KEYS] && grp_line[JV.PROP_GROUP_SUM_KEYS].length > 0) {
                                        for (const grp_sum_field of grp_line[JV.PROP_GROUP_SUM_KEYS]) {
                                            if (grp_sum_field[JV.PROP_FIELD_ID]) {
                                                const map_field = JE.F(grp_sum_field[JV.PROP_FIELD_ID], $CURRENT_RPT);
                                                JpcFieldHelper.resetFormat(grp_sum_field, map_field, customizeCfg);
                                            }
                                        }
                                    }
                                }
                                const lineRst = me.outputTabGrpLine(band, grp_line, page, contentValuesIdx[rowIdx], contentValuesIdx.length, rowIdx, 1, 0, unitFactor, true, controls, multiColIdx, grpCntIdx, $CURRENT_RPT, dataObj);
                                rst = rst.concat(lineRst);
                            }
                        }
                        grpCntIdx++;
                    }
                }
            }
        }
        const eliminateCells = combineAutoHeightCells(prepareObj, page, controls);
        for (let idIdx = eliminateCells.length - 1; idIdx >= 0; idIdx--) {
            rst.splice(eliminateCells[idIdx], 1);
        }
        me.checkCombineEvent(JV.RUN_TYPE_BEFORE_COMBINE, verticalCombinePos, horizonCombinePos, rst, $CURRENT_RPT, dataObj, me, page);
        me.combinePageCells(rst, verticalCombinePos, horizonCombinePos, controls, fonts);
        me.checkCombineEvent(JV.RUN_TYPE_AFTER_COMBINE, verticalCombinePos, horizonCombinePos, rst, $CURRENT_RPT, dataObj, me, page);
        return rst;
    };
    JpcFlowTabResult.checkCombineEvent = function($RUN_TYPE, $VER_COMB_ARRAY, $HOR_COMB_ARRAY, $CURRENT_CELL_ITEMS, $CURRENT_RPT, $CURRENT_DATA, $PARENT, $PAGE) {
        if ($CURRENT_RPT.formulas) {
            const $JE = JE;
            const $JV = JV;
            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];
                        try {
                            eval(expression);
                        } catch (ex) {
                            console.log(ex);
                        }
                    }
                }
            }
        }
    };
    JpcFlowTabResult.outputColumn = function(rptTpl, dataObj, page, segIdx, segPageIdx, bands, unitFactor, multiColIdx, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        const tab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_COLUMN];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, segPageIdx, bands, band, unitFactor, tab, multiColIdx, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputPreviewSegSum = function(rptTpl, bands, unitFactor, controls, pageStatus) {
        let rst = [];
        const tab = rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_SEG_SUM];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                rst = rst.concat(JpcDiscreteHelper.outputPreviewSumInfoOutput(band, unitFactor, tab));
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputPreviewPageSum = function(rptTpl, bands, unitFactor, controls, pageStatus) {
        let rst = [];
        const tab = rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_PAGE_SUM];
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                rst = rst.concat(JpcDiscreteHelper.outputPreviewSumInfoOutput(band, unitFactor, tab));
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputSegSum = function(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        const tab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_SEG_SUM];
        const refTab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_CONTENT];
        const refTabEx = (rptTpl[JV.NODE_FLOW_INFO_EX]) ? rptTpl[JV.NODE_FLOW_INFO_EX][JV.NODE_FLOW_CONTENT] : null;
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                const ref_tab_fields = refTab[JV.PROP_FLOW_FIELDS];
                const ref_tab_fields_ex = refTabEx ? refTabEx[JV.PROP_FLOW_FIELDS] : null;
                const tab_fields = me.seg_sum_tab_fields;
                for (let i = 0; i < tab_fields.length; i++) {
                    if (!JpcFieldHelper.resetSumFormat(ref_tab_fields, tab_fields[i])) {
                        if (!JpcFieldHelper.resetSumFormat(ref_tab_fields_ex, tab_fields[i])) {
                            const map_data_field = JE.F(tab_fields[i][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[i], map_data_field, customizeCfg);
                            // 如果都找不到，就得靠自己的Format属性了
                        }
                    }
                    let sumVal = 0;
                    if (me.segSumValLst[segIdx] && me.segSumValLst[segIdx].length > i) {
                        sumVal = me.segSumValLst[segIdx][i];
                    }
                    // 备注：考虑到有时候会出现没有数据可合计的scenario,得有容错处理
                    const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_fields[i], sumVal, controls);
                    cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_fields[i][JV.PROP_AREA], band, unitFactor, 1, 0, 1, 0, me.multiCols, 0, false, false);
                    rst.push(cellItem);
                }
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, 0, bands, band, unitFactor, tab, 0, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputPageSum = function(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        const FLOW_NODE_STR = me.isEx ? JV.NODE_FLOW_INFO_EX : JV.NODE_FLOW_INFO;
        const tab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_PAGE_SUM];
        const refTab = rptTpl[FLOW_NODE_STR][JV.NODE_FLOW_CONTENT];
        const refTabEx = (rptTpl[JV.NODE_FLOW_INFO_EX]) ? rptTpl[JV.NODE_FLOW_INFO_EX][JV.NODE_FLOW_CONTENT] : null;
        const band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            const pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]]) {
                const ref_tab_fields = refTab[JV.PROP_FLOW_FIELDS];
                const ref_tab_fields_ex = refTabEx ? refTabEx[JV.PROP_FLOW_FIELDS] : null;
                const tab_fields = me.page_sum_tab_fields;
                for (let i = 0; i < tab_fields.length; i++) {
                    if (!JpcFieldHelper.resetSumFormat(ref_tab_fields, tab_fields[i])) {
                        if (!JpcFieldHelper.resetSumFormat(ref_tab_fields_ex, tab_fields[i])) {
                            const map_data_field = JE.F(tab_fields[i][JV.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[i], map_data_field, customizeCfg);
                            // 如果都找不到，就得靠自己的Format属性了
                        }
                    }
                    const cellItem = JpcCommonOutputHelper.createCommonOutput(tab_fields[i], me.pageSumValLst[page - 1][i], controls);
                    cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_fields[i][JV.PROP_AREA], band, unitFactor, 1, 0, 1, 0, me.multiCols, 0, false, false);
                    rst.push(cellItem);
                }
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, 0, bands, band, unitFactor, tab, 0, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    };
    JpcFlowTabResult.outputTabField = function(band, tab_field, data_field, valueIdx, serialIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx) {
        const me = this;
        const rst = JpcCommonOutputHelper.createCommonOutput(tab_field, JpcFieldHelper.getValue(data_field, valueIdx), controls);
        rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, isRow, false);
        return rst;
    };
    JpcFlowTabResult.outputAutoHeightTabField = function(band, tab_field, data_field, contentValInfo, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx) {
        const me = this;
        let rst = null;
        let showText = JpcFieldHelper.getValue(data_field, contentValInfo[2]);
        if (tab_field[JV.PROP_IS_AUTO_HEIGHT]) {
            let textArr = [];
            if (showText) {
                textArr = textArr.concat(showText.split('|'));
            }
            /*
            if (contentValInfo[3] < textArr.length && contentValInfo[3] >= 0) {
                showText = textArr[contentValInfo[3]];
            } else {
                showText = '';
            }
            /*/
            // 因新逻辑要优化自动行高，不再是一个折行占用1row，而是:
            // a. 根据实际情况，设置了一个实际的行数值(比如共有10行，根据行高情况，可能只设置了6行的高度，在setupAutoHeightData方法里处理)
            // b. 这里最大的难题在于跨页分配(预估会有来回调整，目前采用按比例分配原则)
            // c. 还有个问题就是多个自动行高指标的问题
            const ACT_ROWS = contentValInfo[4]; // 经实际计算，能容纳所有数据的实际行数
            const CURRENT_ROW = contentValInfo[3]; // 从0开始
            const QUOTA_Rate = textArr.length / ACT_ROWS; // 每行显示的加权系数(超过2的话，表示给的行高太多了，需要另外一些特殊处理，后期有需要再加)
            if (textArr.length <= 3 || ACT_ROWS > textArr.length) {
                // 表示这个一定是附属的autoheight指标，或者数据就只有3行(假如数据3行精简成2行，但刚好处于分页状态，那么无论是前一页或后一页，显示上都很纠结(多出来的一行放哪好？)，所以新逻辑的起点要3行以上，少了就不折腾了，老老实实地一个萝卜一个坑)
                if (CURRENT_ROW < textArr.length && CURRENT_ROW >= 0) {
                    showText = textArr[CURRENT_ROW];
                } else {
                    showText = '';
                }
            } else {
                // 这里不管是不是附属autoheight指标,有足够的条件单独处理
                if (QUOTA_Rate >= 2) {
                    // 压缩超过一半空间的话，说明给的行高度太高了，需要另外一些特殊处理，后期有需要再加
                    console.log('压缩率异常！！！！！');
                } else {
                    // 正常的压缩比例
                    let startIdx = 0,
                        endIdx = 0;
                    if (CURRENT_ROW > 0) {
                        endIdx = Math.round((CURRENT_ROW + 1) * QUOTA_Rate) - 1;
                        let preEndIdx = 0;
                        if (CURRENT_ROW > 1) {
                            // 重定位 preEndIdx
                            preEndIdx = Math.round(CURRENT_ROW * QUOTA_Rate) - 1;
                        }
                        startIdx = preEndIdx + 1;
                    }
                    // 按比例分配
                    showText = textArr[startIdx];
                    for (let idx = startIdx + 1; idx <= endIdx; idx++) {
                        showText += `|${textArr[idx]}`;
                    }
                }
            }
            // */
            rst = JpcCommonOutputHelper.createCommonOutput(tab_field, showText, controls);
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, true, false);
            rst[JV.PROP_IS_AUTO_HEIGHT] = true;
        } else {
            if (contentValInfo[3] > 0) showText = '';
            rst = JpcCommonOutputHelper.createCommonOutput(tab_field, showText, controls);
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, true, false);
            rst[JV.PROP_IS_AUTO_HEIGHT] = false;
        }
        return rst;
    };
    JpcFlowTabResult.outputTabGrpLine = function(band, grp_line, page, grpValueIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx, grpCntIdx, $CURRENT_RPT, $CURRENT_DATA) {
        const me = this;
        const rst = [];
        if (grp_line[JV.PROP_GROUP_SUM_KEYS]) {
            const segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            const curSegGrpSum = me.group_sum_values[segIdx];
            for (const sumFieldNode of grp_line[JV.PROP_GROUP_SUM_KEYS]) {
                // let value = curSegGrpSum[sumFieldNode[JV.PROP_SUM_KEY]][grpValueIdx[2]];
                const value = curSegGrpSum['grp_sum_key_' + sumFieldNode[JV.PROP_FIELD_ID]][grpValueIdx[2]];
                const sumFldRst = JpcTextHelper.outputDirectValue(sumFieldNode, value, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx);
                rst.push(sumFldRst);
            }
        }
        if (grp_line[JV.PROP_TEXTS]) {
            for (const txt of grp_line[JV.PROP_TEXTS]) {
                me.checkGrpTxtOutEvent(JV.RUN_TYPE_BEFORE_GROUP_TEXT_OUT, txt, grpCntIdx, $CURRENT_RPT, $CURRENT_DATA);
                rst.push(JpcTextHelper.outputText(txt, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx));
                // me.combinePageCells(rst, verticalCombinePos, horizonCombinePos, controls);
                // 可能会有一个After，但意义不大，用不着
            }
        }
        if (grp_line[JV.PROP_DISCRETE_FIELDS]) {
            // 暂时不支持
        }
        if (grp_line[JV.PROP_PARAMS]) {
            // 暂时不支持
        }
        // console.log(rst);
        return rst;
    };

    JpcFlowTabResult.checkGrpTxtOutEvent = function($RUN_TYPE, $TEXT, $TIMES, $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);
                        }
                    }
                }
            }
        }
    };

    JpcFlowTabResult.commonTabRestOutput = function(dataObj, page, segIdx, segPageIdx, bands, band, unitFactor, tab, multiColIdx, $CURRENT_RPT, customizeCfg) {
        const me = this;
        let rst = [];
        if (tab[JV.PROP_TEXT]) {
            rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, 1, 0, me.multiCols, multiColIdx));
        }
        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, me.multiCols, multiColIdx));
            }
        }
        if (tab[JV.NODE_DISCRETE_INFO]) {
            rst = rst.concat(JpcDiscreteHelper.outputDiscreteInfo(tab[JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, segPageIdx, 1, 0, $CURRENT_RPT, customizeCfg, me.signatureRst, me.signatureDateRst, me.signatureAuditRst, me.interactRst));
        }
        return rst;
    };

    return JpcFlowTabResult;
};

function push_cell(pageCellObj, cell, cellIdx) {
    const key = cell[JV.PROP_AREA][JV.PROP_LEFT] + '_' + cell[JV.PROP_AREA][JV.PROP_RIGHT];
    if (!pageCellObj[key]) {
        pageCellObj[key] = [];
    }
    const cellArr = pageCellObj[key];
    cellArr.push({ cellIdx, cell });
}

function prepareAutoHeightCells(prepareObj, cellItem, cellIdx, cellsArr) {
    if (prepareObj) {
        if (prepareObj.cellsArr === undefined) {
            prepareObj.cellsArr = cellsArr;
            prepareObj.pageCellObj = {};
        }
        push_cell(prepareObj.pageCellObj, cellItem, cellIdx);
    }
}

function setupControl(mergeCell, controls, isCombine = false) {
    let orgCtrl = null;
    if (typeof mergeCell[JV.PROP_CONTROL] === 'string') {
        orgCtrl = controls[mergeCell[JV.PROP_CONTROL]];
        mergeCell[JV.PROP_CONTROL] = {
            Shrink: 'T',
            ShrinkFirst: orgCtrl.ShrinkFirst,
            CloseOutput: orgCtrl.CloseOutput,
            ShowZero: orgCtrl.ShowZero,
            Horizon: orgCtrl.Horizon,
            Vertical: orgCtrl.Vertical,
            Wrap: (mergeCell[JV.PROP_IS_AUTO_HEIGHT]) ? 'T' : 'F',
            VerticalForExcel: 'center',
        };
    } else {
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_SHRINK]] = 'T';
        // mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL]] = 'top';
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_WRAP]] = (mergeCell[JV.PROP_IS_AUTO_HEIGHT]) ? 'T' : 'F';
        // mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'center';
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL]];
        orgCtrl = mergeCell[JV.PROP_CONTROL];
    }
    if (mergeCell[JV.PROP_IS_AUTO_HEIGHT]) {
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'justify';
        // mergeCell[JV.PROP_CONTROL]['Vertical'] = 'center';
    } else if (isCombine && orgCtrl.CloseOutput === 'T') {
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_WRAP]] = 'T';
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'justify';
    } else {
        mergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'center';
        // mergeCell[JV.PR OP_CONTROL]['Vertical'] = 'top';
    }
    return orgCtrl;
}

function combineAutoHeightCells(prepareObj, page, controls) {
    const rst = [];
    if (prepareObj.cellsArr) {
        // merge cells' value and area
        // 备注： 系统逻辑已经把Cell的顺序放好，无需再做排序。
        for (const mergeKey in prepareObj.pageCellObj) {
            const sameColCells = prepareObj.pageCellObj[mergeKey]; // 左右位置相同的Cell先放在一起，统一处理
            if (sameColCells.length > 1) {
                let firstMergeCell = sameColCells[0].cell;
                firstMergeCell[JV.PROP_STYLE] = firstMergeCell[JV.PROP_STYLE].slice(0, firstMergeCell[JV.PROP_STYLE].indexOf('_AutoHeightMerge')); // 首先还原original style
                let orgCtrl = setupControl(firstMergeCell, controls);
                let validValueAmt = 0;
                let fullValidValueAmt = 0;
                for (let i = 1; i < sameColCells.length; i++) {
                    const mergeCell = sameColCells[i].cell;
                    if (mergeCell[JV.PROP_STYLE].indexOf('_AutoHeightMerge_Top') < 0) {
                        fullValidValueAmt++;
                        // merge into the firstMergeCell! position & value
                        firstMergeCell[JV.PROP_AREA][JV.PROP_BOTTOM] = mergeCell[JV.PROP_AREA][JV.PROP_BOTTOM];
                        if (mergeCell[JV.PROP_VALUE]) {
                            firstMergeCell[JV.PROP_VALUE] = firstMergeCell[JV.PROP_VALUE] + '|' + mergeCell[JV.PROP_VALUE];
                            validValueAmt++;
                        }
                        rst.push(sameColCells[i].cellIdx); // 记下Cell的位置，在函数外消除
                        // 如果到了最后一条数据，得判断firstMergeCell是否满格（即数据是满的，有可能有些格数据也有折行但不是自动行高判断指标）
                        // 不满格的cell的Vertical强制设置为 'center'
                        if (i === sameColCells.length - 1 && validValueAmt !== fullValidValueAmt && (fullValidValueAmt / validValueAmt > 2.5)) {
                            firstMergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'center';
                        }
                    } else {
                        // 碰到新开始的自动行高行，判断原先的firstMergeCell是否满格（即数据是满的，有可能有些格数据也有折行但不是自动行高判断指标）
                        // 不满格的cell的Vertical强制设置为 'center'
                        if (validValueAmt !== fullValidValueAmt && (fullValidValueAmt / validValueAmt > 2.5)) {
                            firstMergeCell[JV.PROP_CONTROL][JV.CONTROL_PROPS[JV.CONTROL_PROP_IDX_VERTICAL_EXCEL]] = 'center';
                        }
                        firstMergeCell = sameColCells[i].cell;
                        firstMergeCell[JV.PROP_STYLE] = firstMergeCell[JV.PROP_STYLE].slice(0, firstMergeCell[JV.PROP_STYLE].indexOf('_AutoHeightMerge'));
                        orgCtrl = setupControl(firstMergeCell, controls);
                        validValueAmt = 0;
                        fullValidValueAmt = 0;
                    }
                }
            }
        }
        rst.sort(function(i1, i2) {
            return (i1 > i2) ? 1 : -1;
        });
    }
    return rst;
}

module.exports = new JpcFlowTabSrv();