/**
 * Created by Tony on 2017/7/14.
 * 报表数据提取class，是协助报表模板里指标字段自主提取数据的工具类
 */
let JV = require('../rpt_component/jpc_value_define');
let $JE = require('../rpt_component/jpc_rte');
let consts = require('../../../modules/main/models/project_consts');

let fsUtil = require("../../../public/fsUtil");

let treeUtil = require('../../../public/treeUtil');
let projectConst = consts.projectConst;
let projectConstList = consts.projectConstList;

class Rpt_Common{
    initialize(Projects) {
        this.Projects = Projects;
    };

    getSerialNo(fieldId, $CURRENT_RPT, $CURRENT_DATA){
        let itemSerialNoRec = $JE.F(fieldId, $CURRENT_RPT);
        if (itemSerialNoRec) {
            itemSerialNoRec[JV.PROP_AD_HOC_DATA] = [];
            for (var innerFmlIdx = 0; innerFmlIdx < $CURRENT_DATA[JV.DATA_DETAIL_DATA][0].length; innerFmlIdx++) {
                itemSerialNoRec[JV.PROP_AD_HOC_DATA][innerFmlIdx] = (innerFmlIdx + 1);
            }
            itemSerialNoRec = null;
        }
    };
}

class Rpt_Data_Extractor {
    constructor () {
        this.COMMON = new Rpt_Common();
    };

    initialize(tpl) {
        this.rptTpl = tpl;
    };

    getDataRequestFilter() {
        let rst = [];
        let tpl = this.rptTpl;
        let pri_func_chk_filter = function (field) {
            for (let key of projectConstList) {
                if (rst.indexOf(key) < 0) {
                    if (field[JV.PROP_FIELD_EXP_MAP]) {
                        if (field[JV.PROP_FIELD_EXP_MAP].indexOf('.' + key + '.') >= 0) {
                            rst.push(key);
                            if (key === projectConst.RATION_GLJ && (rst.indexOf(projectConst.PROJECTGLJ) < 0)) {
                                //rst.push(projectConst.PROJECTGLJ);
                            }
                            if (key === projectConst.PROJECTGLJ && (rst.indexOf(projectConst.RATION_GLJ) < 0)) {
                                rst.push(projectConst.RATION_GLJ);
                            }
                        }
                    }
                }
            }
        };
        if (tpl[JV.NODE_FIELD_MAP][JV.NODE_DISCRETE_FIELDS]) {
            for (let field of tpl[JV.NODE_FIELD_MAP][JV.NODE_DISCRETE_FIELDS]) {
                pri_func_chk_filter(field);
            }
        }
        if (tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS]) {
            for (let field of tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS]) {
                pri_func_chk_filter(field);
            }
        }
        if (tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS]) {
            for (let field of tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS]) {
                pri_func_chk_filter(field);
            }
        }
        if (tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS_EX]) {
            for (let field of tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS_EX]) {
                pri_func_chk_filter(field);
            }
        }
        if (tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS_EX]) {
            for (let field of tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS_EX]) {
                pri_func_chk_filter(field);
            }
        }
        return rst;
    };

    //--- 装配数据(把收集到的数据，依据报表模板的指示，预处理(如：排序、过滤、合计)及装配到相关指标) ---//
    assembleData(rawDataObj) {
        let $PROJECT = {"COMMON": {}, "MAIN": {}, "DETAIL": {}};
        let tpl = this.rptTpl;
        $PROJECT.MAIN["myOwnRawDataObj"] = rawDataObj.prj._doc;
        $PROJECT.MAIN.getProperty = ext_mainGetPropety;
        $PROJECT.MAIN.getFee = ext_mainGetFee;
        $PROJECT.DETAIL.getRationPropertyByID = ext_getRationPropertyByID;
        if (tpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
            for (let preHandle of tpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
                let srcData = getModuleDataByKey(rawDataObj.prjData, preHandle[JV.PROP_DATA_KEY]);
                switch(preHandle[JV.PROP_HANDLE_TYPE]) {
                    case JV.PROP_HANDLE_TYPE_SORT:
                        sortData(srcData, preHandle);
                        break;
                    case JV.PROP_HANDLE_TYPE_FILTER:
                        filterData(srcData, preHandle, rawDataObj.prjData);
                        break;
                    case JV.PROP_HANDLE_TYPE_SUM:
                        summaryData(srcData, preHandle, rawDataObj.prjData);
                        break;
                    default:
                        break;
                }
            }
        }
        for (let item of rawDataObj.prjData) {
            setupFunc($PROJECT.DETAIL, item.moduleName, item);
        }
        let rptDataObj = {};
        rptDataObj[JV.DATA_DISCRETE_DATA] = [];
        rptDataObj[JV.DATA_MASTER_DATA] = [];
        rptDataObj[JV.DATA_DETAIL_DATA] = [];
        rptDataObj[JV.DATA_MASTER_DATA_EX] = [];
        rptDataObj[JV.DATA_DETAIL_DATA_EX] = [];
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DISCRETE_FIELDS], rptDataObj[JV.DATA_DISCRETE_DATA], $PROJECT);
        // console.log(JV.DATA_DISCRETE_DATA);
        // console.log(rptDataObj[JV.DATA_DISCRETE_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS], rptDataObj[JV.DATA_MASTER_DATA], $PROJECT);
        // console.log(JV.DATA_MASTER_DATA);
        // console.log(rptDataObj[JV.DATA_MASTER_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS], rptDataObj[JV.DATA_DETAIL_DATA], $PROJECT);
        // console.log(JV.DATA_DETAIL_DATA);
        // console.log(rptDataObj[JV.DATA_DETAIL_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS_EX], rptDataObj[JV.DATA_MASTER_DATA_EX], $PROJECT);
        // console.log(JV.DATA_MASTER_DATA_EX);
        // console.log(rptDataObj[JV.DATA_MASTER_DATA_EX]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS_EX], rptDataObj[JV.DATA_DETAIL_DATA_EX], $PROJECT);
        // console.log(JV.DATA_DETAIL_DATA_EX);
        // console.log(rptDataObj[JV.DATA_DETAIL_DATA_EX]);
        return rptDataObj;
    };

}

function getModuleDataByKey(prjData, key) {
    let rst = null;
    for (let item of prjData) {
        if (item.moduleName === key) {
            rst = item;
            break;
        }
    }
    return rst;
}

function summaryData(sourceData, handleCfg, prjData){
    let rstArr = [], tempRstArr = [];
    let curParentPrjData = {};
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    let private_get_grp_key = function (item) {
        let keys = [];
        for (let cfg of handleCfg[JV.PROP_SUM_GROUP_KEYS]) {
            if (typeof cfg === "string") {
                keys.push(item[cfg]);
            } else {
                if (!curParentPrjData[cfg["seeking_parent"]]) curParentPrjData[cfg["seeking_parent"]] = getModuleDataByKey(prjData, cfg["seeking_parent"]);
                for (let pDataItem of curParentPrjData[cfg["seeking_parent"]].data) {
                    let data = (pDataItem._doc)?pDataItem._doc:pDataItem;
                    if (item[cfg["seeking_key"]] === data[cfg["parent_key"]]) {
                        keys.push(data[cfg["parent_grp_key"]]);
                        break;
                    }
                }
            }
        }
        return ( "grp_key_" + keys.join('_'));
    }
    let sumObj = {};
    for (let dtl of tempRstArr) {
        let grpKey = private_get_grp_key(dtl);
        if (sumObj[grpKey] === null || sumObj[grpKey] === undefined) {
            sumObj[grpKey] = dtl;
            rstArr.push(dtl);
        } else {
            for (let sumKey of handleCfg[JV.PROP_SUM_SUM_KEYS]) {
                if (dtl[sumKey]) {
                    sumObj[grpKey][sumKey] += dtl[sumKey];
                }
            }
        }
    }
    delete sourceData.data;
    sourceData.data = rstArr;
    // fsUtil.wirteObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/sumRst.js");
}

function filterData(sourceData, handleCfg, prjData) {
    let rstArr = [], tempRstArr = [];
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    let private_chkVal = function (src, dest, compStr) {
        let rst = true;
        switch (compStr) {
            case "==" :
                rst = (src == dest);
                break;
            case "===" :
                rst = (src === dest);
                break;
            case ">" :
                rst = (src > dest);
                break;
            case ">=" :
                rst = (src >= dest);
                break;
            case "<" :
                rst = (src < dest);
                break;
            case "<=" :
                rst = (src <= dest);
                break;
            case "!=" :
                rst = (src != dest);
                break;
            case "!==" :
                rst = (src !== dest);
                break;
            default:
                rst = true;
        }
        return rst;
    }
    for (let item of tempRstArr) {
        let compRst = true;
        let curComparePrjData = null;
        for (let cfg of handleCfg[JV.PROP_FILTER_KEY]) {
            if (cfg[JV.PROP_FILTER_COMPARE_VAL]) {
                //比较key值
                compRst = private_chkVal(item[cfg.key], cfg[JV.PROP_FILTER_COMPARE_VAL], cfg[JV.PROP_FILTER_CONDITION]);
            } else if (cfg[JV.PROP_FILTER_COMPARE_OBJ] && cfg[JV.PROP_FILTER_COMPARE_OBJ_KEY]){
                //通过其他对象来过滤
                if (!curComparePrjData) {
                    curComparePrjData = getModuleDataByKey(prjData, cfg[JV.PROP_FILTER_COMPARE_OBJ]);
                }
                for (let data of curComparePrjData.data) {
                    compRst = private_chkVal(item[cfg.key], data[cfg[JV.PROP_FILTER_COMPARE_OBJ_KEY]], cfg[JV.PROP_FILTER_CONDITION]);
                    if (compRst) break;
                }
            }
        }
        if (compRst) {
            rstArr.push(item);
        }
    }
    delete sourceData.data;
    sourceData.data = rstArr;
    // fsUtil.wirteObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/filteredRst.js");
}

function sortData(sourceData, sortCfg) {
    let rst = sourceData.data, tempRstArr = [];
    let sortType = sortCfg[JV.PROP_SORT_TYPE];
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    switch (sortType) {
        case "tree":
            rst = treeUtil.buildTreeNodeDirectly(tempRstArr);
            let destArr = [];
            treeUtil.getFlatArray(rst, destArr);
            delete sourceData.data;
            sourceData.data = destArr;
            // fsUtil.wirteObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/sortedAndFlattedRst.js");
            break;
        case "normal":
            tempRstArr.sort(function(a, b){
                let compRst = 0;
                for (let comp of sortCfg[JV.PROP_SORT_KEYS]) {
                    let reverse = (comp.order === 'ascend')?1:(-1);
                    if (a[comp.key] > b[comp.key]) {
                        compRst = reverse;
                        break;
                    } else if (a[comp.key] < b[comp.key]) {
                        compRst = -reverse;
                        break;
                    }
                }
                return compRst;
            });
            delete sourceData.data;
            sourceData.data = tempRstArr;
            // fsUtil.wirteObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/normalSortedRst.js");
            break;
        default:
            //
    }
    return rst;
}

function setupFunc(obj, prop, ownRawObj) {
    obj[prop] = {};
    obj[prop]["myOwnRawDataObj"] = ownRawObj;
    obj[prop].getProperty = ext_getPropety;
    obj[prop].getFee = ext_getFee;
}

function assembleFields(fieldList, rstDataArr, $PROJECT) {
    if (fieldList) {
        for (let field of fieldList) {
            shielded_exec_env($PROJECT, field, rstDataArr);
        }
    }
}

function shielded_exec_env($PROJECT, $ME, rptDataItemObj) {
    if ($ME[JV.PROP_FIELD_EXP_MAP]) {
        rptDataItemObj.push(eval($ME[JV.PROP_FIELD_EXP_MAP]));
    }
}

function ext_mainGetPropety(propKey) {
    let rst = [];
    let parentObj = this;
    //console.log(this);
    let dtObj = parentObj["myOwnRawDataObj"];
    if ((dtObj) && (propKey)) {
        if (dtObj.hasOwnProperty("property")) {
            rst.push(dtObj["property"][propKey]);
        } else  {
            rst.push(dtObj[propKey]);
        }
    }
    return rst;
}

function ext_mainGetFee(feeKey, dtlFeeKey) {
    let rst = [];
    let parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if ((dtObj) && (feeKey)) {
        if (dtObj.hasOwnProperty("fees")) {
            for (let fee of dtObj["fees"]) {
                if (fee["fieldName"] === feeKey) {
                    if (dtlFeeKey) {
                        rst.push(fee[dtlFeeKey]);
                    } else {
                        rst.push(fee["unitFee"]);
                    }
                    break;
                }
            }
        } else if (dtObj.hasOwnProperty(feeKey)) {
            rst.push(dtObj[feeKey]);
        } else {
            //
        }
    }
    return rst;
}

function ext_getPropety(propKey) {
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if (propKey && dtObj) {
        for (let dItem of dtObj.data) {
            let doc = (dItem._doc === null || dItem._doc === undefined)?dItem:dItem._doc;
            if (doc.hasOwnProperty("property")) {
                rst.push(doc["property"][propKey]);
            } else if (doc.hasOwnProperty(propKey)) {
                rst.push(doc[propKey]);
            } else {
                rst.push('');
            }
        }
    }
    return rst;
}

function ext_getFee(feeKey, dtlFeeKey) {
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if (feeKey && dtObj) {
        for (let dItem of dtObj.data) {
            let hasValue = false;
            if (dItem.hasOwnProperty("fees")) {
                for (let fee of dItem["fees"]) {
                    if (fee["fieldName"] === feeKey) {
                        if (dtlFeeKey) {
                            rst.push(fee[dtlFeeKey]);
                        } else {
                            rst.push(fee["unitFee"]);
                        }
                        hasValue = true;
                        break;
                    }
                }
            } else if (dItem.hasOwnProperty(feeKey)) {
                hasValue = true;
                rst.push(dItem[feeKey]);
            } else {
                hasValue = true;
                rst.push(0);
            }
            if (!hasValue) {
                rst.push(0);
            }
        }
    }
    return rst;
}

function ext_getRationPropertyByID(IdVal, propKey) {
    let rst = [], me = this;
    if (IdVal !== null && IdVal !== undefined && me[projectConst.RATION]) {
        let isFound = false;
        if (IdVal instanceof Array) {
            for (let id of IdVal) {
                isFound = false;
                for (let item of me[projectConst.RATION]["myOwnRawDataObj"].data) {
                    if (item.ID === id) {
                        rst.push(item[propKey]);
                        isFound = true;
                        break;
                    }
                }
                // if (!isFound) rst.push[null];
            }
        } else {
            for (let item of me[projectConst.RATION]["myOwnRawDataObj"].data) {
                if (item.ID === IdVal) {
                    rst.push(item[propKey]);
                    isFound = true;
                    break;
                }
            }
            // if (!isFound) rst.push[null];
        }
    }
    return rst;
}

export default Rpt_Data_Extractor;