'use strict';

/**
 *
 *
 * @author Zhong
 * @date 2019/6/28
 * @version
 */

const XML_IMPORT_BASE = (() => {
    // 清单类型
    const BILLS_TYPE ={
        DXFY: 1, //大项费用
        FB: 2,   //分部
        FX: 3,   //分项
        BILLS: 4, //清单
        BX: 5    //补项
    };
    // 项目类型
    const PROJECT_TYPE = {
        PROJECT: 'Project',
        ENGINEERING: 'Engineering',
        TENDER: 'Tender'
    };
    // 人材机调整法
    const ADJUST_TYPE = {
        INFO: 'priceInfo',  //造价信息差额调整法
        COE: 'priceCoe'     //价格指数调整法
    };

    const CONFIG = Object.freeze({
        BILLS_TYPE,
        PROJECT_TYPE,
        ADJUST_TYPE
    });

    /*
    * 读取文件转换为utf-8编码的字符串
    * @param {Blob}file
    * @return {Promise}
    * */
    function readAsTextSync(file) {
        return new Promise((resolve, reject) => {
            let fr = new FileReader();
            fr.readAsText(file);    // 默认utf-8，如果出现乱码，得看导入文件是什么编码
            fr.onload = function () {
                resolve(this.result);
            };
            fr.onerror = function () {
                reject('读取文件失败，请重试。');
            }
        });
    }

    /*
     * 根据字段数组获得所要字段的值 eg: 要获取标段下的单项工程： ['标段', '单项工程'];
     * @param {Object}source 源数据
     *        {Array}fields 字段数组
     * @return {String}
     * @example getValue(source, ['标段', '_文件类型'])
     * */
    function getValue(source, fields) {
        let cur = source;
        for (let field of fields) {
            if (!cur[field]) {
                return '';
            }
            cur = cur[field];
        }
        return cur || '';
    }
    // 获取数据类型
    function _plainType(v) {
        return Object.prototype.toString.call(v).slice(8, -1);
    }
    /*
     * 获取某字段的值，强制返回数组
     * @param {Object}source 数据源
     *        {Array}fields 取的字段
     * @return {Array}
     * @example arrayValue(source, ['标段', '单项工程'])
     * */
    function arrayValue(source, fields) {
        let target = getValue(source, fields);
        if (_plainType(target) === 'Object') {
            target = [target];
        } else if (_plainType(target) !== 'Array') {
            target = []
        }
        return target;
    }
    // 获取费用
    function getFee(fees, fields) {
        if (!Array.isArray(fees) || !fees.length) {
            return '0';
        }
        let feeData = fees.find(fee => fee.fieldName === fields[0]);
        return feeData[fields[1]] || '0';
    }
    // 获取固定ID
    function getFlag(data) {
        return data.flags && data.flags[0] && data.flags[0].flag || 0;
    }
    /*
     * 递归获取相关数据，eg：获取组织措施清单下的所有子清单，该子清单们可能由分类及公式措施项各种组合组成。（参考调用处）
     * @param {Object}src(数据源) {Array}fields(二维数组，数组里的成员由需要取的字段组成)
     *         eg: ['组织措施分类'], ['公式计算措施项']，该层数据可能由组织措施分类 或 公式计算措施项组成 (同层不可同时存在)
     *        {Function} 获得源数据后，需要提取的数据方法
     * @return {Array}
     * */
    function getItemsRecur(src, fields, extractFuc) {
        let itemsSrc = [],
            curField = [''];
        for (let field of fields) {
            itemsSrc = arrayValue(src, field);
            if (itemsSrc.length) {
                curField = field;
                break;
            }
        }
        return itemsSrc.map(itemSrc => {
            let obj = extractFuc(itemSrc, curField);
            obj.items = getItemsRecur(itemSrc, fields, extractFuc);
            return obj;
        });
    }
    /*
    * 转换计算基数
    * 1.有子项数据，则清空基数
    * 2.行代号引用转换为ID引用
    * 3.对应字典代号转换，对应字典里找不到则设置成金额
    * @param {Array}billsData 清单数据
    *        {Object}CalcBaseMap 基数映射
    * @return {void}
    * */
    function transformCalcBase(billsData, CalcBaseMap) {
        //行代号 - ID映射
        let rowCodeMap = {};
        billsData.forEach(data => {
            if (data.rowCode) {
                rowCodeMap[data.rowCode] = data.ID;
            }
        });
        for (let bills of billsData) {
            if (!bills.calcBase) {
                continue;
            }
            let sub = billsData.find(data => data.ParentID === bills.ID);
            //有子项数据，则清空基数，费率
            if (sub) {
                bills.calcBase = '';
                bills.feeRate = '';
                continue;
            }
            //提取基数
            bills.calcBase = bills.calcBase.replace(/\s/g, '');
            let bases = bills.calcBase.split(/[\+\-\*\/]/g);
            //提取操作符
            let oprs = bills.calcBase.match(/[\+\-\*\/]/g);
            //转换后的基数
            let newBase = [];
            let illegal = false;    //不合法
            for (let base of bases) {
                if (rowCodeMap[base]) { //行引用
                    newBase.push(`@${rowCodeMap[base]}`);
                } else if (CalcBaseMap[base]) { //基数字典
                    newBase.push(CalcBaseMap[base]);
                } else {    //都没匹配到，说明软件无法识别此基数
                    illegal = true;
                    break;
                }
            };
            if (illegal) {
                let fee = getFee(bills.fees, ['common', 'totalFee']);
                let feeRate = bills.feeRate && parseFloat(bills.feeRate) !== 0 ? parseFloat(bills.feeRate) : 0;
                if (fee && parseFloat(fee) !== 0 && feeRate) {
                    bills.calcBase = scMathUtil.roundForObj(parseFloat(fee) * 100 / feeRate, 2);
                } else {
                    bills.calcBase = fee !== '0' ? fee : '';
                }
            } else {
                let newCalcBase = '';
                for (let i = 0; i < newBase.length; i++) {
                    newCalcBase += newBase[i];
                    if (oprs && oprs[i]) {
                        newCalcBase += oprs[i];
                    }
                }
                bills.calcBase = newCalcBase;
            }
        }
    }
    // 获取必要的清单模板
    async function getNeedfulTemplate(templateLibID) {
        return await ajaxPost('/template/bills/api/getNeedfulTemplate',
            {templateLibID});
    }


    const UTIL = Object.freeze({
        getValue,
        arrayValue,
        getFee,
        transformCalcBase
    });
})();