import {BARCODE_CAIGOU,
BARCODE_FINISHEDGOOD,
BARCODE_PRODUCE,
BARCODE_PROCESS,
BARCODE_JOBCENTER,
BARCODE_TARE,
BARCODE_CAIGOU_KEY,
BARCODE_FINISHEDGOOD_KEY,
BARCODE_PRODUCE_KEY,
BARCODE_PROCESS_KEY,
BARCODE_JOBCENTER_KEY,
BARCODE_TARE_KEY,
BARCODE_MAP_OBJECT,
BARCODE_OUTSOURCE,
BARCODE_OUTSOURCE_KEY,
}  from "./barCode.js"
	const BigNumber = require('bignumber.js');
	
	
// px 转rpx，
export const px2upx=(height,baseWidth=375)=>{
	const systeminfo=uni.getSystemInfoSync()
	const _baseWidth=systeminfo.windowWidth
	const heightRpx=(750 * height)/baseWidth   //750 是uni-app 的基准宽度，baseWidth 是设计稿的基准宽度,如果没有传值进来默认375
	return heightRpx
}

// 条码类型错误提示，key:条形码类型(字符串或者数组)，value:条形码，如果key 传入null或者空字符串，直接发返回
export const onErrorBarCodeType=(key,value,showToast=false)=>{
	let ok=true
	let msg=""
	if(key==="" || key===null) {
		return {ok,msg}
	}
	// key 是字符串，转成数组
	let keyArr=[]
	if (typeof key==='string') {
		keyArr=new Array (key)
	}else if (typeof key ==="object") {
		keyArr=key
	}
	if (typeof value!=="string" && typeof value!=="number") {
		throw new Error ("common.js:onErrorBarCodeType():value must be String or Number")
	}
	const barCodeType=value.slice(0,1)  // 条码类型
	const barCodeLen=value.length  // 条形码长度
	const num=Number(barCodeType)  // 转成数字
	const lenErrMsg='扫描错误,请扫描完整的条形码'
	const typeErrMsg=`条形码类型错误:扫描的不是${keyArr.join('或')}`
	 
	/*
	如果条码扫描不完整，要进行提示,每个条形码都有最少的位数
	扫描类型不对，要进行提示
	*/
	// 要取得键名对应的键值，键值是数字
	let numarr=[]
	keyArr.forEach((item)=>{
		if (item.indexOf('条形码') <0) {
			item=item+"条形码"
		}
		numarr.push(BARCODE_MAP_OBJECT[item])
	})
	if (numarr.indexOf(num)<0) {
		ok=false
		msg=typeErrMsg
		return {ok,msg}
	} 
	// 长度错误提示
	switch (keyArr) {
		case keyArr.indexOf (BARCODE_CAIGOU_KEY) >=0:  // 采购件条形码  至少15位
		case keyArr.indexOf(BARCODE_FINISHEDGOOD_KEY) >=0:  // 产成品条形码  15
			if (barCodeLen <15) {
				msg=lenErrMsg
			}
			break;
		case keyArr.indexOf(BARCODE_PROCESS_KEY) >=0:   // 工艺流程卡条形码 20
			if (barCodeLen <20) {
				msg=lenErrMsg
			}
			break;
		case keyArr.indexOf(BARCODE_JOBCENTER_KEY) >=0:  // 工作中心条形码
			if (barCodeLen < 2) {
				msg=lenErrMsg
			}
			break;
		case keyArr.indexOf(BARCODE_TARE_KEY) >=0 :   // 标准容器重量条形码 2
		  if (barCodeLen < 2) {
				msg=lenErrMsg
			}
			break;
		case keyArr.indexOf(BARCODE_OUTSOURCE_KEY) >=0 :   // 委外订单条形码 
		  if (barCodeLen < 16) {
				msg=lenErrMsg
			}
			break;
	}
	
	// 如果要直接提示
	if (showToast) {
		if (!ok) {
			uni.showToast({
				title:msg,
				icon:"none",
			})
		}
	}
	return {ok,msg}
}

// 扫码获取物品号，数量等数据,value:条形码,
export const formateScanData=(value)=>{
	if (typeof value != "string") {
		throw new Error ('common.js:formateScanData():value must be String')
	}
	const barCodeType=value.slice(0,1)  // 条码类型
	const num=Number(barCodeType)  // 转成数字
	let itemno=null, // 物品号
	itemnum=null,  // 物品数量
	itemcode=null,  // 物品识别码
	itemid=null; //物品身份证
	
	let orderno=null,  // 订单号
	pageTotal=null, // 共几张
	pageNumber=null;  //第几张
	
	let tare=null ; // 重量
	
	switch (num) {
		case BARCODE_CAIGOU:
		case BARCODE_FINISHEDGOOD:
	  	//，采购件和产成品规则一样，只是条形码类型不一样，编码规则（1位数）+9位物品号+4位识别码+数量
			itemno=value.slice(1,10)  // 物品号
			itemcode=value.slice(10,14)  // 识别码
			itemnum=value.slice(14)  // 数量
			itemid=num+""+itemno+""+itemcode  // 一个物品（条形码类型+物品号+识别码）
		break;
		case BARCODE_PRODUCE:
		orderno=value.slice(1,16)
		break;
		case BARCODE_PROCESS:
		//条码类型4，编码规则为4+15位生产订单号-共几张/第几张）  4888888888888888-100/22
		 orderno=value.slice(1,16)
		 let index=value.indexOf("-")
		 let index2=value.indexOf("/")
		 pageTotal=value.slice(index+1,index2)
		 pageNumber=value.slice(index2+1)
		break;
		case BARCODE_JOBCENTER:
		break;
		case BARCODE_TARE:
		//编码规则为6+标准容器重量
		 tare=value.slice(1)
		break;
		case BARCODE_OUTSOURCE:
		//编码规则为7+15位订单号
		 orderno=value.slice(1,16)
		break;
	}
	return {
		barCodeType:num,
		itemno,
		itemcode,
		itemid,
		itemnum,
		orderno,
		pageTotal,
		pageNumber,
		tare,
	}
}
// 当前页面错误，执行退出到上一级面的提示
export const showBackToast=(msg,delay=2000)=>{
	uni.showToast({
		title:msg,
		icon:"none",
		duration:delay
	})
	setTimeout(()=>{
		return uni.navigateBack({
			delta:1
		})
	},delay)
}
// 应入数量和实际数量的比较合并(比如清点单)
/*两个数组A=[{id:1,amount:10},{id:2,amount:1}],B=[{id:1,itemnum:5},{id:3,itemnum:6}]依据某个key，进行合并，得到的最后的数组是包含了AB的所有数据,且数组里的每一项的字段是AB字段的集合：
[{id:1,amount:10,itemnum:null},
{id:2,amount:1,itemnum:null},
{id:1,itemnum:5,amount:null},
{id:3,itemnum:6,amount:null}]
思路：直接用一个循环，因为项目里面的功能很相似，。虽然用两次循环，一次先合并数组，一次过滤数组也可以，但是这次用一次循环

originArr：源数组（后台返回的真实数据）
otherArr：外来数组（扫码得到的数组）
originKey:源数组含有的key，需要并入到
otherKey
*/
export const mergeArray=(originArr,originKey,otherArr,otherKey,id)=>{
	if ( typeof originArr!="object" || typeof otherArr!="object" ) {
		throw new Error("common.js:mergeArray():originArr , otherArr must be Array")
	}else if ( typeof originKey !="string" || typeof otherKey !="string") {
		throw new Error("common.js:mergeArray():originKey , otherKey must be String")
	}else if (typeof id !="string" && typeof id !="number" ) {
		throw new Error("common.js:mergeArray():id must be String or NUmber")
	}
			
	let arr=[]
	originArr.forEach((item,index,array)=>{
		otherArr.forEach((item2,index2,array2)=>{
			// 两个数据源都有的项
			if (item[id]===item2[id]) {
				const obj={...item,...item2}
				// obj.difAmount=item[originKey]-item2[otherKey]
				obj.difAmount=BigNumber(item[originKey]).minus(item2[otherKey]).toNumber()
				obj.highlight=obj.difAmount == 0 ? false : true
				array[index]=obj
			}else {
				/*外来数组有，源数组没有,把外来数组多余的项，处理，加入到源数组里面
				*/ 
				let i=array.findIndex(v=>{
					return v[id]===item2[id]
				})
				if (i<0) {
					const obj=item2
					obj[originKey]='--'  // 外来数组项补充源数组项字段
					// obj.difAmount=(obj[originKey]==="--" ? 0 : obj[originKey]) - obj[otherKey]
					const x=obj[originKey]==="--" ? 0 : obj[originKey]
					obj.difAmount=BigNumber(x).minus(obj[otherKey]).toNumber()
					obj.highlight=obj.difAmount == 0 ? false : true
					array.push(obj)
				}
				// 源数组（后台）有 ，外来数组（扫码）没有找到，修改源数组
				let i2=array2.findIndex(v=>{
					return v[id]===item[id]
				})
				if (i2<0) {
					const obj=item
					obj[otherKey]='--'  // 源数组项补充外来数组项字段
					const x=obj[otherKey]==="--" ? 0 : obj[otherKey]
					obj.difAmount=BigNumber(obj[originKey]).minus(x).toNumber()
					obj.highlight=obj.difAmount == 0 ? false : true
					array[index]=obj
				}
			}
		})
	})
	return originArr.slice(0)
}