// import service from '../services'
import CryptoJS from 'crypto-js'
import moment from 'moment'
console.log(moment().startOf('day'), moment().endOf('day'))
let isDebug = process.env.NODE_ENV !== 'production' ? true : false


const util = {
    log: (mes, ...params) => {
        if (isDebug) {
            console.log(mes, ...params);
        }
    },
    /** 下载文件
     * @param data {blob} 文件流
     * @param filename {String} 文件名称
     */
    downloadFileByBlob: (data, filename) => {
        // console.log(111111)
        if (!data) {
            // console.log(123)
            return false;
        }
        if (!!window.ActiveXObject || "ActiveXObject" in window) {
            window.navigator.msSaveOrOpenBlob(new Blob([data]), filename);
            console.log(22222)
        } else {
            console.log(33333)
            const url = window.URL.createObjectURL(new Blob([data]));
            // console.log('下载',url)
            const link = document.createElement("a");
            link.style.display = "none";
            link.href = url;
            link.setAttribute("download", filename);
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    },

    /** 下载文件
     * @param url {String} 文件下载地址
     * @param filename {String} 文件名称
     */
    downloadFileByUrl: (url, filename) => {
        if (!!window.ActiveXObject || "ActiveXObject" in window) {
            window.navigator.msSaveOrOpenBlob(url, filename);
        } else {
            const link = document.createElement("a");
            link.style.display = "none";
            link.href = url;
            link.setAttribute("download", filename);
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    },
    // 处理base64数据
    dealBase64ToBlob(base64Url) {
        // 截取base64的数据内容（去掉前面的描述信息，类似这样的一段：data:image/png;base64,）并解码为2进制数据
        let bstr = atob(base64Url.split(",")[1]);
        // 获取解码后的二进制数据的长度，用于后面创建二进制数据容器
        let olength = bstr.length;
        // 创建一个Uint8Array类型的数组以存放二进制数据
        var u8arr = new Uint8Array(olength);
        // 将二进制数据存入Uint8Array类型的数组中
        while (olength--) {
            u8arr[olength] = bstr.charCodeAt(olength);
        }
        // 创建blob对象
        let blob = new Blob([u8arr]);
        return blob;
    },

    // 获取文件扩展名
    getFileExtension: (fileName) => {
        const fileNameSplited = fileName.split(".");
        return fileNameSplited[fileNameSplited.length - 1].toLowerCase();
    },
    // 获取文件名
    getFileName: (fileName) => {
        return fileName.substring(0, fileName.lastIndexOf("."));
    },
     /**
     * 判断文件类型
     */
      getFileType(fileName) {
        // 获取文件拓展名,统一取小写判断
        const fileExtension = this.getFileExtension(fileName)
        // 通过文件拓展名判断文件类型
        switch (fileExtension) {
            case 'jpg':
            case 'jpeg':
            case 'png':
            case 'bmp':
                return 'image'
            case 'mp4':
            case 'avi':
            case 'm3u8':
                return 'video'
            case 'mp3':
            case 'amr':
            case 'm4a':
                return 'audio'
            case 'doc':
            case 'docx':
            case 'xls':
            case 'xlsx':
            case 'ppt':
            case 'pptx':
            case 'pdf':
                return 'pdf'
            case 'txt':
                return 'txt'
            case 'zip':
            case 'rar':
                return 'zip'
            default:
                return ''
        }
    },
    /* 常用方法 */
    isEmptyObject(value) {
        if (!value) {
            return true;
        }
        if (!(value instanceof Object)) {
            return true;
        }
        return Object.keys(value).length < 1;
    },
    isEmptyString(string) {
        if (!string) {
            return true;
        }
        if (!(string instanceof String)) {
            return true;
        }
        return string.length < 1;
    },
    isEmptyArray(array) {
        if (!array) {
            return true;
        }
        if (!(array instanceof Array)) {
            return true;
        }
        return array.length < 1;
    },
    // DES加密
    encryptByDES(key, message) {
        let keyHex = CryptoJS.enc.Utf8.parse(key);
        let encrypted = CryptoJS.DES.encrypt(message, keyHex, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        });
        return encrypted.toString();
    },
    //DES 解密
    decryptByDES(ciphertext, key) {
        let keyHex = CryptoJS.enc.Utf8.parse(key);
        // direct decrypt ciphertext
        let decrypted = CryptoJS.DES.decrypt({
            ciphertext: CryptoJS.enc.Base64.parse(ciphertext)
        }, keyHex, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        });
        return decrypted.toString(CryptoJS.enc.Utf8);
    },
    // 验证图片类型
    reg_img(fileUrl) {
        console.log(fileUrl,'---fileUrl')
        if(fileUrl==null||fileUrl=='') {
            // return fileUrl
            return require('../assets/image/util/word_img.jpg')
        }
        if(/.(pdf)$/.test(fileUrl.toLowerCase())) {
            return require('../assets/image/util/pdf_img.jpg')
        }
        else if(/.(xls|xlsx)$/.test(fileUrl.toLowerCase())) {
            return require('../assets/image/util/excel_img.jpg')
        }
        else if(/.(doc|docx)$/.test(fileUrl.toLowerCase())) {
            return require('../assets/image/util/word_img.jpg')
        }
        else if(/.(zip|rar)$/.test(fileUrl.toLowerCase())) {
            return require('../assets/image/util/yswj.jpg')
        }
        else {
            // return service.service.serviceurl+fileUrl
            return fileUrl
        }
    },
    /**
     * 根据不同的数据返回相关的icon-目前返回图片
     */
     getIcon(data) {
        switch (data.fileType) {
            case 'jpg':
            case 'jpeg':
            case 'png':
            case 'bmp':
                return require('../assets/image/util/pdf_img.jpg');
            case 'pdf':
                return require('../assets/image/util/pdf_img.jpg');
            case 'doc':
            case 'docx':
                return require('../assets/image/util/word_img.jpg');
            case 'xls':
            case 'xlsx':
                return require('../assets/image/util/excel_img.jpg');   
            case 'mp3': 
            case 'm3u8':
            case 'mp4':
                return require('../assets/image/util/video_img.jpg');
            default:
                return require('../assets/image/util/pdf_img.jpg')
        }
    },
    /**
     * 格式化日期/时间
     * type: YYYY-MM-DD / YYYY-MM-DD HH:mm:ss /  HH:mm:ss / hh:mm:ss am / hh:mm:ss pm（12小时制下午） 等
     * time: 时间
     * */
    formatDate(time, type) {
        return time ? moment(time).format(type) : ''
    },
    // 将日期/时间转换为时间戳，ms
    formatDateToTimestamp(time) {
        return time ? moment(time).valueOf() : ''
    },
    // 获取时间戳
    getTimestamp() {
        let timestamp = Date.parse(new Date());
        return timestamp
    },
    // 获取昨日
    getYesterday(){
        let beginTime = moment().subtract(1, "days").format("YYYY-MM-DD 00:00:00");
        let endTime = moment().subtract(1, "days").format("YYYY-MM-DD 23:59:59");
        return {beginTime, endTime}
    },
    // 获取当天日期/时间
    getToday() {
        let todayStart = moment().startOf('day').format('YYYY-MM-DD HH:mm:ss')
        let todayEnd = moment().endOf('day').format('YYYY-MM-DD HH:mm:ss')
        let todayDate = moment().format('YYYY-MM-DD')
        return {todayStart, todayEnd, todayDate}
    },
    /**
     * 获取本月， 日期/时间范围
     * @param type {String} 格式化时间的类型  YYYY-MM-DD/ YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getCurrentMonth(type='YYYY-MM-DD HH:mm:ss') {
        let monthStart = moment().startOf('month').format(type)
        let monthEnd = moment().endOf('month').format(type)
        // console.log('monthStart:', monthStart, 'monthEnd:', monthEnd)
        return {monthStart, monthEnd}
    },
    /**
     * 获取近几周， 日期/时间范围
     * @param num {Number} 数量，默认值为1，取近1周的时间。 如果需要近2周，则num = 2
     * @param type {String} 格式化时间的类型  YYYY-MM-DD/ YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getRecentWeeks(num = 1, type= 'YYYY-MM-DD HH:mm:ss') {
        let amount = 7 * num
        // 近几周的开始时间
        let recentWeekStart = moment().subtract(amount, 'days').startOf('day').format(type)
        // 获取当天结束时间
        let todayEnd = moment().endOf('day').format(type)
        return {recentWeekStart, todayEnd}
    },

    /**
     * 获取近几月， 日期/时间范围
     * @param num {Number} 数量，默认值为1，取近1月的时间。如果需要近3月，则num = 3，近半年，则num = 6
     * @param type {String} 格式化时间的类型  YYYY-MM-DD/ YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getRecentMonths(num = 1, type= 'YYYY-MM-DD HH:mm:ss') {
        // 近几月的开始时间
        let recentMonthStart = moment().subtract(num, 'months').startOf('day').format(type)
        // 获取当天结束时间
        let todayEnd = moment().endOf('day').format(type)
        console.log(recentMonthStart, todayEnd)
        // console.log('近1月', recentMonthStart, todayEnd)
        return {recentMonthStart, todayEnd}
    },

    /**
     * 获取近几年， 日期/时间范围
     * @param num {Number} 数量，默认值为1，取近1年的时间。如果需要近3年，则num = 3
     * @param type {String} 格式化时间的类型  YYYY-MM-DD / YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getRecentYears(num = 1, type= 'YYYY-MM-DD HH:mm:ss') {
        // 近几月的开始时间
        let recentYearStart = moment().subtract(num, 'years').startOf('day').format(type)
        // 获取当天结束时间
        let todayEnd = moment().endOf('day').format(type)
        // console.log('近1年', recentYearStart, todayEnd)
        return {recentYearStart, todayEnd}
    },
    /**
     * 处理日期， 获取某天的开始时间
     * @param time {String, Number} 传入的时间
     * @param type {String} 格式化时间的类型  YYYY-MM-DD / YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getDayStart(time, type = 'YYYY-MM-DD HH:mm:ss') {
        return time ? moment(time).startOf('day').format(type) : ''
    },
    /**
     * 处理日期， 获取某天的结束时间
     * @param time {String, Number} 传入的时间
     * @param type {String} 格式化时间的类型  YYYY-MM-DD / YYYY-MM-DD HH:mm:ss等
     * x-格式化为时间戳ms， X-格式化为时间戳，单位s
     */
    getDayEnd(time, type = 'YYYY-MM-DD HH:mm:ss') {
        return time ? moment(time).endOf('day').format(type) : ''
    },
    /*
    * 点击按钮后，去掉按钮的焦点
    * @param evt 事件
    * */
    removeButtonFocus(evt) {
        let target = evt.target;
        if(target.nodeName.toLocaleLowerCase() == "span"){
            target = evt.target.parentNode;
        }
        target.blur();
    },
    getDatetimeValue(){
        // 获取当前时间
        const now = new Date();
        // 格式化时间
        const year = now.getFullYear();
        const month = now.getMonth() + 1;
        const day = now.getDate();
        const hour = now.getHours();
        const minute = now.getMinutes();
        const second = now.getSeconds();
        const currentTime = `${year}-${month >= 10 ? month : '0' + month}-${day >= 10 ? day : '0' + day} ${hour >= 10 ? hour : '0' + hour}:${minute >= 10 ? minute : '0' + minute}:${second >= 10 ? second : '0' + second}`;
        // 将格式化后的时间存入 data 中
        return currentTime;
    },
     
    //获取本月天数
    mGetDate(){
        var date = new Date();
        var year = date.getFullYear();
        var month = date.getMonth()+1;
        var d = new Date(year, month, 0);
        return d.getDate();
   },
   // 获取当前年
   getToyear() {
        const time = new Date();
        const toyearStart = time.getFullYear();
        return toyearStart
    },
    // 获取当前年月日
    getTimesDate() {
        const date = new Date();
        const year = date.getFullYear();
        const month = (date.getMonth() + 1).toString().padStart(2, '0'); // 月份前面补0
        const day = date.getDate().toString().padStart(2, '0'); // 日期前面补0
        return `${year}-${month}-${day}`;
    },

    // 和当前时间对比，判断是否大于当前时间
    getTimeContrast(timeString) {
        const timedate = moment(timeString);
        console.log(timedate > new Date(),'timedate > new Date()')
        return timedate > new Date()
    },

    // {{scope.row.linkedSituation == 2 ?'':''}}
    // {{scope.row.linkedSituation == 3 ?'':''}}
    // {{scope.row.linkedSituation == 4 ?'':''}}
    // {{scope.row.linkedSituation == 5 ?'':''}}
    // {{scope.row.linkedSituation == 8 ?'':''}}
    // {{scope.row.linkedSituation == 9 ?'':''}}
    // {{scope.row.linkedSituation == 10 ?'':''}} -->
    /**
     * 电话情况
     */
    getTelephoneType() {
        return [{label:'已接',value:0},{label:'未接',value:1},{label:'拒接',value:2},
            {label:'关机',value:3},{label:'停机',value:4},{label:'暂时无法接通',value:5},
            {label:'空号',value:7},{label:'设置',value:8},{label:'正在通话中',value:9}]
    },
    /**
     * 根据不同的类型返回不同的电话情况 this.$util.getTelephoneTypeData
     */
    getTelephoneTypeData(value) {
        switch (value) {
            case 0:
                // 常规
                return {key:0,label:this.getTelephoneType().find(item => item.value == value).label};
            case 1:
            case 2:
            case 3:
            case 5:
            case 10:
                // 预警
                return {key:2,label:this.getTelephoneType().find(item => item.value == value).label};
            case 4:
            case 8:
            case 9:
                // 高预警
                return {key:1,label:this.getTelephoneType().find(item => item.value == value).label};  
            // case 5:
            //     // 成功
            //     return {key:3,label:this.getMediationType().find(item => item.value == value).label};  
            default:
                return {key:0,label:''};
        }
    },

    /**
     * 调解状态
     */
    getMediationType() {
        return [{label:'未触达',value:0},{label:'调解中',value:1},{label:'已达成方案',value:2},
            {label:'已签署协议',value:3},{label:'调解失败',value:4},{label:'调解成功',value:5}]
    },
    /**
     * 根据不同的类型返回不同的调解状态 this.$util.getMediationprogressData
     */
    getMediationTypeData(value) {
        switch (value) {
            case 1:
            case 2:
            case 3:
                // 常规
                return {key:0,label:this.getMediationType().find(item => item.value == value).label};
            case 0:
                // 预警
                return {key:2,label:this.getMediationType().find(item => item.value == value).label};
            case 4:
                // 高预警
                return {key:1,label:this.getMediationType().find(item => item.value == value).label};  
            case 5:
                // 成功
                return {key:3,label:this.getMediationType().find(item => item.value == value).label};  
            default:
                return {key:0,label:this.getMediationType().find(item => item.value == value).label};
        }
    },
    /**
     * 调解进度枚举 
     */
    getMediationprogress() {
        return [
            {label:'承诺账户',value:1},{label:'重点账户',value:2},{label:'拒联账户',value:3},{label:'已结清客户',value:4},
            {label:'疑难账户',value:5},{label:'失联账户',value:6},{label:'半失联账户',value:7},{label:'部分还款账户',value:8},
            {label:'适诉案件',value:9},{label:'可联账户',value:10},{label:'投诉倾向客户',value:11},{label:'分期客户',value:12},
            {label:'其他/无标签',value:13}
          ]
    },
    /**
     * 根据不同的类型返回不同的调解进度 this.$util.getMediationprogressData
     */
    getMediationprogressData(value) {
        switch (value) {
            case 1:
            case 2:
            case 4:
            case 8:
            case 12:
                // 常规
                return {key:0,label:this.getMediationprogress().find(item => item.value == value).label};
            case 7:
            case 9:
            case 10:
            case 13:
                // 预警
                return {key:2,label:this.getMediationprogress().find(item => item.value == value).label};
            case 3:
            case 5:
            case 6:
            case 11:
                // 高预警
                return {key:1,label:this.getMediationprogress().find(item => item.value == value).label};  
            default:
                return {key:0,label:this.getMediationprogress().find(item => item.value == value).label};
        }
        
    },
    // 阿拉伯转中文
    changeNumToHan(num) {
        var arr1 = new Array('零', '一', '二', '三', '四', '五', '六', '七', '八', '九');
        var arr2 = new Array('', '十', '百', '千', '万', '十', '百', '千', '亿', '十', '百', '千','万', '十', '百', '千','亿');//可继续追加更高位转换值
            if(!num || isNaN(num)){
              return "零";
            }
        var english = num.toString().split("")
        var result = "";
        for (var i = 0; i < english.length; i++) {
            var des_i = english.length - 1 - i;//倒序排列设值
            result = arr2[i] + result;
            var arr1_index = english[des_i];
            result = arr1[arr1_index] + result;
         }
         //将【零千、零百】换成【零】 【十零】换成【十】
         result = result.replace(/零(千|百|十)/g, '零').replace(/十零/g, '十');
         //合并中间多个零为一个零
         result = result.replace(/零+/g, '零');
         //将【零亿】换成【亿】【零万】换成【万】
         result = result.replace(/零亿/g, '亿').replace(/零万/g, '万');
         //将【亿万】换成【亿】
         result = result.replace(/亿万/g, '亿');
         //移除末尾的零
         result = result.replace(/零+$/, '')
         //将【零一十】换成【零十】
         //result = result.replace(/零一十/g, '零十');//貌似正规读法是零一十
         //将【一十】换成【十】
         result = result.replace(/^一十/g, '十')
         return result;
    },

}
export default util;
