/**
 * Created by PanJiaChen on 16/11/18.
 */
 import {fileStorage, getPageList } from '@/api/wms-api'
 import store from '@/store'
 import i18n from "@/lang"
 
 /**
 * @param {string} url
 * @returns {Object}
 */
 export function getQueryObject(url) {
   url = url == null ? window.location.href : url
   const search = url.substring(url.lastIndexOf('?') + 1)
   const obj = {}
   const reg = /([^?&=]+)=([^?&=]*)/g
   search.replace(reg, (rs, $1, $2) => {
     const name = decodeURIComponent($1)
     let val = decodeURIComponent($2)
     val = String(val)
     obj[name] = val
     return rs
   })
   return obj
 }
 
 // 返回utf8字符串的字节长度
 /**
 * @param {string} input value
 * @returns {number} output value
 */
 export function byteLength(str) {
   // returns the byte length of an utf8 string
   let s = str.length
   for (var i = str.length - 1; i >= 0; i--) {
     const code = str.charCodeAt(i)
     if (code > 0x7f && code <= 0x7ff) s++
     else if (code > 0x7ff && code <= 0xffff) s += 2
     if (code >= 0xDC00 && code <= 0xDFFF) i--
   }
   return s
 }
 
 /**
 * @param {Array} actual
 * @returns {Array}
 */
 export function cleanArray(actual) {
   const newArray = []
   for (let i = 0; i < actual.length; i++) {
     if (actual[i]) {
       newArray.push(actual[i])
     }
   }
   return newArray
 }
 
 /**
 * @param {Object} json
 * @returns {Array}
 */
 export function param(json) {
   if (!json) return ''
   return cleanArray(
     Object.keys(json).map(key => {
       if (json[key] === undefined) return ''
       return encodeURIComponent(key) + '=' + encodeURIComponent(json[key])
     })
   ).join('&')
 }
 
 /**
 * @param {string} url
 * @returns {Object}
 */
 export function param2Obj(url) {
   const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ')
   if (!search) {
     return {}
   }
   const obj = {}
   const searchArr = search.split('&')
   searchArr.forEach(v => {
     const index = v.indexOf('=')
     if (index !== -1) {
       const name = v.substring(0, index)
       const val = v.substring(index + 1, v.length)
       obj[name] = val
     }
   })
   return obj
 }
 
 /**
 * @param {string} val
 * @returns {string}
 */
 export function html2Text(val) {
   const div = document.createElement('div')
   div.innerHTML = val
   return div.textContent || div.innerText
 }
 
 /**
 * Merges two objects, giving the last one precedence
 * @param {Object} target
 * @param {(Object|Array)} source
 * @returns {Object}
 */
 export function objectMerge(target, source) {
   if (typeof target !== 'object') {
     target = {}
   }
   if (Array.isArray(source)) {
     return source.slice()
   }
   Object.keys(source).forEach(property => {
     const sourceProperty = source[property]
     if (typeof sourceProperty === 'object') {
       target[property] = objectMerge(target[property], sourceProperty)
     } else {
       target[property] = sourceProperty
     }
   })
   return target
 }
 
 /**
 * @param {HTMLElement} element
 * @param {string} className
 */
 // export function toggleClass(element, className) {
 //   if (!element || !className) {
 //     return
 //   }
 //   let classString = element.className
 //   const nameIndex = classString.indexOf(className)
 //   if (nameIndex === -1) {
 //     classString += '' + className
 //   } else {
 //     classString =
 //       classString.substr(0, nameIndex) +
 //       classString.substr(nameIndex + className.length)
 //   }
 //   element.className = classString
 // }
 
 /**
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @return {*}
 */
 export function debounce(func, wait, immediate) {
   let timeout, args, context, timestamp, result
   // console.log('我在防抖函数里面')
   const later = function () {
     // 据上一次触发时间间隔
     const last = +new Date() - timestamp
 
     // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
     if (last < wait && last > 0) {
       timeout = setTimeout(later, wait - last)
     } else {
       timeout = null
       // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
       if (!immediate) {
         result = func.apply(context, args)
         if (!timeout) context = args = null
       }
     }
   }
 
   return function (...args) {
     context = this
     timestamp = +new Date()
     const callNow = immediate && !timeout
     // 如果延时不存在，重新设定延时
     if (!timeout) timeout = setTimeout(later, wait)
     if (callNow) {
       result = func.apply(context, args)
       context = args = null
     }
 
     return result
   }
 }
 
 /**
 * This is just a simple version of deep copy
 * Has a lot of edge cases bug
 * If you want to use a perfect deep copy, use lodash's _.cloneDeep
 * @param {Object} source
 * @returns {Object}
 */
 export function deepClone(source) {
   if (!source && typeof source !== 'object') {
     throw new Error('error arguments', 'deepClone')
   }
   const targetObj = source.constructor === Array ? [] : {}
   Object.keys(source).forEach(keys => {
     if (source[keys] && typeof source[keys] === 'object') {
       targetObj[keys] = deepClone(source[keys])
     } else {
       targetObj[keys] = source[keys]
     }
   })
   return targetObj
 }
 
 /**
 * @param {Array} arr
 * @returns {Array}
 */
 export function uniqueArr(arr) {
   return Array.from(new Set(arr))
 }
 
 /**
 * @returns {string}
 */
 export function createUniqueString() {
   const timestamp = +new Date() + ''
   const randomNum = parseInt((1 + Math.random()) * 65536) + ''
   return (+(randomNum + timestamp)).toString(32)
 }
 
 /**
 * Check if an element has a class
 * @param {HTMLElement} elm
 * @param {string} cls
 * @returns {boolean}
 */
 export function hasClass(ele, cls) {
   return !!ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'))
 }
 
 /**
 * Add class to element
 * @param {HTMLElement} elm
 * @param {string} cls
 */
 export function addClass(ele, cls) {
   if (!hasClass(ele, cls)) ele.className += ' ' + cls
 }
 
 /**
 * Remove class from element
 * @param {HTMLElement} elm
 * @param {string} cls
 */
 export function removeClass(ele, cls) {
   if (hasClass(ele, cls)) {
     const reg = new RegExp('(\\s|^)' + cls + '(\\s|$)')
     ele.className = ele.className.replace(reg, ' ')
   }
 }
 
 //返回
 export function Enum(status, index, prop) {
   let _no_text = '无'
   if(!status)return _no_text
   if (index != undefined) { //如果传入的是index
     if (prop === 'color') {
       const domColor = status[index] ? status[index][prop] : ""
       return 'color:' + domColor
     } else {
       const dom = status[index] ? status[index][prop] : _no_text
       return dom
     }
   } else {
     return prop ? "" : Object.values(status)
   }
 }
 
 // 判断是否存在某个父级元素，层级不定
 /**
 * @param {*} obj 当前节点，如点击事件返回的e.target
 * @param {*} searchName 要查找是否存在的父级节点class
 * @returns 
 */
 export function getParentNode(obj,searchName) {
   let node = obj;
   let ofDiv = true;
   while (ofDiv) {
     if(!node){
       ofDiv = false;
     }
     if (node && node.parentNode && String(node.parentNode.className).includes(searchName)) { 
       node = node.parentNode;
       ofDiv = false;
     }else if (node && String(node.className).includes(searchName)) {
       node = null;
       ofDiv = false;
     } else {
       node = node && node.parentNode ? node.parentNode : null;
     }
   }
   return node
 }
 
 // 获取图片详情弹窗模式的图片数据格式
 export function getImgsDetailPopData(row,sucess,faild) {
   let imgsrcList = []
   JSON.parse(row.inspectPhotoJson).forEach(item => {
     fileStorage({blobName: item.FileKey}).then(res => {
       var byteString = atob(res.bytes)
       var arrayBuffer = new ArrayBuffer(byteString.length) // 创建缓冲数组
       var intArray = new Uint8Array(arrayBuffer) // 创建视图
       for (var i = 0; i < byteString.length; i++) {
         intArray[i] = byteString.charCodeAt(i)
       }
       const blob = new Blob([intArray], { type: '' })
       imgsrcList.push(window.URL.createObjectURL(blob))
       if(sucess)sucess()
     }).catch(err => {
       console.log(err)
       if(faild)faild()
     })
   })
   return imgsrcList
 }
 
 // 匹配正则返回值
 /** 具体参数详细，可参照README.md的[表单组件补充:currenForm]说明
 * @param {*} type      需要匹配的正则类型
 * @param {*} defaultValue     当前传入值（即需要校验值）
 * @param {*} fixedNum  如果type为pointNumber，需要保留小数点后的位数
 * @returns 
 */
 export function getMatchRegConformValue(type,defaultValue,fixedNum){
   let value = defaultValue ? String(defaultValue) : ''
   let _conformValue = ""
   switch(type){
     // 正整数
     case "number":
       _conformValue=value.replace(/[^\d]/g,'');
       break;
 
     // 数字+带小数点，只能输入一个小数点
     case "pointNumber":
       //小数点后保留位数
       let _fixed = fixedNum ? Number(fixedNum) : 100
       let reg = new RegExp(`\\d+\\.?\\d{0,${_fixed}}`);
       let _match = String(value).match(reg)
       _conformValue = _match ? _match[0] : _match
       break;
 
     // 数字+字母
     case "numberLetter":
       _conformValue=value.replace(/[^\a-\z\A-\Z0-9]/g,'');
       break;
       
     // 字母
     case "letter":
       _conformValue=value.replace(/[^a-zA-Z]/g,'');
       break;
 
     // 字母+中文
     case "letterCn":
       _conformValue=value.replace(/[\d]/g,'');
       break;
 
     // 数字+字母+横杠(-)
     case "numberLetterBar":
       _conformValue=value.replace(/[^\a-\z\A-\Z0-9\-]/g,'');
       break;
   }
   return _conformValue
 }
 
 // 字典格式化数据结构
 export function dictFormatData() {
   return new Promise((resolve,reject) => {
     let rs = []
     let childRs = {}
     let param = {
       maxResultCount: 1000,
       condition: {
           filters: []
       },
       sorting: "",
       skipCount: 0
     }
     getPageList(param, 'basedata/dict', true).then(res => {
       res.items.forEach(item => {
         childRs[item.code] = {}
         item.items.forEach( itemValue => {
           childRs[item.code][itemValue.code] = {
             label: itemValue.name,
             value: itemValue.code
           }
         })
         rs.push(childRs)
         childRs = {}
       })
       resolve(rs)
     }).catch(err => {
       console.log(err)
       reject(err)
     })
   })
 }
 
 // 像接口传参时候需要补充.0000000 否则会报错情况下转义
 export function initDataToHttpFormat (date) {
   return date ? date + '.0000000' : undefined
 }
 
 // 新建浏览器标签页面
 export function createNewTabs (url) {
   window.open(url, "_blank")
 }
 
 // faster-new
 // 转义及读取api接口返回的表头信息 
 export function zhApiColumnsLable (data,list) {
   let _list = list ? list : store.getters.columZHList
   return _list ? _list[data] : data
 }
 
 // 首字母转换 type='Lower'(小写，默认) Upper（大写）
 export function firstWordSizeChange (str,type='Lower') {
   switch(type){
     case 'Lower':
       return str.substring(0,1).toLowerCase() + str.substring(1,str.length);
       
     case 'Upper':
       return str.substring(0,1).toUpperCase() + str.substring(1,str.length);
     
   }
 }
 
 //  get-dto-column-type接口表头类型初始化
 export function initApiColumnsForDto (list,titleName,that) {
   let data = that.$store.getters.dtoColumnTypes
   let _coloums = data[titleName].S
   let _Columns_Table = []
   if(_coloums){
     let _data = _coloums.dtoList
     _data.forEach(item=>{
       // 如果list接口存在数据 ，与list接口返回字段比较处理,list接口存在的话则追加
       let _if = firstWordSizeChange(item.name) != 'details'
       if(list){
         _if = firstWordSizeChange(item.name) in list && firstWordSizeChange(item.name) != 'details'
       }
       if(_if){
         _Columns_Table.push(item)
       }
     })
   }
   if(list){
     _Columns_Table = _Columns_Table.concat(specialAddColumns(list,titleName))
   }
   return _Columns_Table
 }
 
 // 特殊字段转义处理（api中没有的字段特殊处理）
 export function specialAddColumns(list,titleName){
   let _apiName = titleName
   let _special_list=[]
   // creationTime
   if('creationTime' in list){
     _special_list.push(
       {
         "name": "CreationTime",
         "apiBaseType": "datetime",
         "baseApiName": _apiName + 'CreationTime',
         "label": zhApiColumnsLable(_apiName + 'CreationTime') || i18n.t('columNames.CreationTime'),
         "prop": "creationTime",
       }
     )
   }
   // creatorId
   if('creatorId' in list){
     _special_list.push(
       {
         "name": "CreatorId",
         "apiBaseType": "string",
         "baseApiName": _apiName + 'CreatorId',
         "label": zhApiColumnsLable(_apiName + 'CreatorId') || i18n.t('columNames.CreatorId'),
         "prop": "creatorId",
       }
     )
   }
   // lastModificationTime
   if('lastModificationTime' in list){
     _special_list.push(
       {
         "name": "LastModificationTime",
         "apiBaseType": "datetime",
         "baseApiName": _apiName + 'LastModificationTime',
         "label": zhApiColumnsLable(_apiName + 'LastModificationTime') || i18n.t('columNames.LastModificationTime'),
         "prop": "lastModificationTime",
       }
     )
   }
   // lastModifierId
   if('lastModifierId' in list){
     _special_list.push(
       {
         "name": "LastModifierId",
         "apiBaseType": "string",
         "baseApiName": _apiName + 'LastModifierId',
         "label": zhApiColumnsLable(_apiName + 'LastModifierId') || i18n.t('columNames.LastModifierId'),
         "prop": "lastModifierId",
       }
     )
   }
   // tenantId
   if('tenantId' in list){
     _special_list.push(
       {
         "name": "TenantId",
         "apiBaseType": "string",
         "baseApiName": _apiName + 'TenantId',
         "label": zhApiColumnsLable(_apiName + 'TenantId') || i18n.t('columNames.TenantId'),
         "prop": "tenantId",
       }
     )
   }
   return _special_list
 }
 
 // 从字段中删除最后某字段
 export function sliceStrEndDelete(str,deleteStr){
   let _d_l = str.length - deleteStr.length
   return str.slice(0,_d_l)
 }