import moment from 'moment'
import { handleExpiredDays } from "../script/lineHandleLogic";
import { postVaildate } from "../api";

export let validateModule = {

    // data(){
    //     return {

    //     };
    // },

    methods: {

        validateCaseOrPiece(params) {
            return params.list.every((tt) => {
                if (tt.isCaseOrPiece == '1' && tt.oddCaseQty > 0 && tt.oddPieceQty > 0) {
                    this.$message.warning(this.$lang(tt.itemName + ' 需要整散分离'))
                    return false
                }
                return true
            })
        },

        validateStockStatus(params) {
            return params.list.every((tt, index) => {
                if (tt.stockStatus == '2' && (!tt.rcvReason1 || (!tt.rcvReason2 && !tt.rcvrEason3))) {
                    this.$message.warning(this.$lang('第' + (index + 1) + '收货结论为待处理，需要填写处理原因、不足原因'));
                    return false;
                }
                if (tt.stockStatus == '3' && (!tt.rcvReason1 || (!tt.rcvReason2 && !tt.rcvrEason3))) {
                    this.$message.warning(this.$lang('第' + (index + 1) + '收货结论为拒收，需要填写处理原因、不足原因'));
                    return false;
                }
                return true;
            })
        },

        validateExpiredDays(params) {
            let isErr = false;
            // 判断拦截  移库入库4只提示不拦截
            params.list.forEach((tt, index) => {
                let code = handleExpiredDays(tt.batchExpiredDate, this.expiredDays)
                if (code == 1) {
                    this.$message.warning(`第${index + 1}行, 有效期至${tt.batchExpiredDate}, 近效期${this.expiredDays.alert}, 警告`);
                }
                if (code == 2) {
                    let t = params.main.rcvType == '4' ? '警告' : '拦截';
                    this.$message.error(`第${index + 1}行, 有效期至${tt.batchExpiredDate}, 近效期${this.expiredDays.intercept}, ${t}`);
                    if (params.main.rcvType != '4') isErr = true;
                }
            });
            if (isErr) {
                return false;
            }
            params.main.status = 1;
            return true;
        },

        validateStoreTemperature(params) {
            return params.list.every((tt, index) => {
                if (tt.stockStatus === '3') { // 拒收不需要上传图片
                    return true;
                }
                if (tt.storeTemperature.indexOf('冷') >= 0 && !tt.rcvLinesPicDTOList) {
                    this.$message.warning(`第${index + 1}行为${tt.storeTemperature},需要进行上传`);
                    return false;
                }
                return true;
            })
        },

        validateExtract(data) {
            return new Promise((resolve, reject) => {
                // 订单有效期
                let headDate = data.mainlist[0];
                let now = new Date();
                now.setHours(23, 59, 59);
                var x = new moment(now);
                var y = new moment(headDate.expirationdate)
                let isExpirationdate = y.diff(x) > 0;
                if (!isExpirationdate) {
                    this.$message.warning('订单超过有效期');
                    resolve(false);
                    return;
                }
                let p = [
                    {
                        refId: headDate.billid,
                        mtlOwnerId: headDate.mtlOwnerId,
                        vendorId: headDate.vendorId,
                    }
                ];
                // postVaildate(p).then(res => {
                //     if (!res.success) {
                //         this.$exception(res)
                //         resolve(false);
                //         return;
                //     }
                //     if (!res.data[headDate.billid]) {
                //         this.$message.warning('货主、供应商经营资质过期');
                //         resolve(false);
                //         return;
                //     }
                resolve(true);
                // });
            });
        },


        // 有效期至 格式判断
        validateBatchExpiredDate(params) {

            return params.list.every((tt, index) => {
                if (tt.stockStatus === '3') return true
                let warnText = '第 ' + (index + 1) + ' 明细的 有效期至 格式不正确';
                if (tt.batchExpiredDate.length != 10 || Number.isNaN(+(new Date(tt.batchExpiredDate)))) {
                    this.$message.warning(warnText);
                    return false;
                }
                return true;
            });
        },

        //容器校验
        // 不同药品大类、不同存储分类（常温,阴凉）、不同收货结论（合格、不合格,拒收,待处理）、整件和散件等容器需要分开
        container(params) {
            return this.isBusiness('int').then(bool => {
                if (!bool) return true
                if (params.list.length === 1) return true
                return params.list.every((t, j) => {
                    if (!t.containerCode) return true;
                    for (let i = j + 1; i < params.list.length; i++) {
                        if (t.containerCode === params.list[i].containerCode) {
                            if (t.categoryName != params.list[i].categoryName) {
                                this.$message.warning(`容器编号${t.containerCode},中的商品大类不同，不能选择同一容器编码`);
                                return false;
                            }
                            if (t.storeTemperature != params.list[i].storeTemperature) {
                                this.$message.warning(`容器编号${t.containerCode},中的存储条件不同，不能选择同一容器编码`);
                                return false;
                            }
                            if (!t.oddCaseQty != !params.list[i].oddCaseQty || !t.oddPieceQty != !params.list[i].oddPieceQty) {
                                this.$message.warning(`容器编号${t.containerCode},中的整、散件不同，不能选择同一容器编码`);
                                return false;
                            }
                        }
                    }
                    return true;
                });
            })

        },

        // 收货结论 冷藏品 温度 判断
        validateStockStatusTemperature(params) {
            if (params.list.filter(t => !!t.tempControlScope) == 0) {
                return true;
            }
            let vals = params.extend;
            let temperature = null;
            if (!vals.shipDate) {
                this.$message.warning('请输入启运时间');
                return false;
            }
            if (typeof vals.shipTemPerature == 'number') temperature = vals.shipTemPerature;
            if (typeof vals.shipTemPerature == 'string' && vals.shipTemPerature !== '') temperature = +vals.shipTemPerature;
            if (typeof temperature !== 'number' || Number.isNaN(temperature)) {
                this.$message.warning('请输入正确启运温度');
                return false;
            }
            let arriveTem = null;
            if (!vals.shipArriveTime) {
                this.$message.warning('请输入到货时间');
                return false;
            }
            if (typeof vals.shipArriveTemPerature == 'number') arriveTem = vals.shipArriveTemPerature;
            if (typeof vals.shipArriveTemPerature == 'string' && vals.shipArriveTemPerature !== '') arriveTem = +vals.shipArriveTemPerature;
            if (typeof arriveTem !== 'number' || Number.isNaN(arriveTem)) {
                this.$message.warning('请输入正确到货温度');
                return false;
            }
            if (!vals.deviceNo) {
                this.$message.warning('请输入到货温度设备号');
                return false;
            }
            if (!vals.tempcontrolMode) {
                this.$message.warning('请输入温控方式');
                return false;
            }
            if (!vals.tempcontrolStatus) {
                this.$message.warning('请输入温控状态');
                return false;
            }
            return params.list.every((tt, index) => {
                if (!tt.tempControlScope || tt.stockStatus != '0') {
                    return true;
                }
                let scope = tt.tempControlScope.split('~').map(t => +t);
                if (temperature < scope[0] || temperature > scope[1]) {
                    this.$message.warning('第' + (index + 1) + '行，存储条件为' + tt.storeTemperature + ',启运温度为' + temperature + '不在' + tt.tempControlScope + ',收货结论不允许为收货');
                    return false;
                }
                if (arriveTem < scope[0] || arriveTem > scope[1]) {
                    this.$message.warning('第' + (index + 1) + '行，存储条件为' + tt.storeTemperature + ',到货温度为' + arriveTem + '不在' + tt.tempControlScope + ',收货结论不允许为收货');
                    return false;
                }
                return true;
            });

        },

        // 明细 不同结论 容器号不能相同
        validateStockStatusContainer(params) {
            return params.list.every((tt, ii) => {
                if (!tt.containerCode) return true;
                for (let i = ii; i < params.list.length; i++) {
                    if (tt.containerCode === params.list[i].containerCode && tt.stockStatus != params.list[i].stockStatus) {
                        this.$message.warning(`商品明细第${ii + 1}行与第${i + 1}行收货结论不同，不能选择同一容器编码`);
                        return false;
                    }
                }
                return true;
            });
        },

        // 起运时间、在途时长、现在时间 判断
        validateShipFromDate(params, fun) {
            let n = new Date();
            let s = new Date(params.rcvHeadersProfilesDTO.shipFromDate);
            s.setDate(s.getDate() + (+params.rcvHeadersProfilesDTO.onPassageDays || 0));
            // 该单据已超在途时限，是否继续操作（是/否）
            if (+n > +s) {
                this.$confirm({
                    content: '该单据已超在途时限，是否继续操作',
                    okText: '是',
                    cancelText: '否',
                    onOk: () => {
                        return fun(params)
                    }
                })
            } else {
                fun(params);
            }
        },


        // 新旧批号  生产日期   有效期至  之间判断
        validateManufacturerLotNum(params, fun) {
            let arr = [];
            params.rcvLinesDTOList.forEach((tt, ii) => {
                // 3.当前录入界面批号与历史批号表存在同批号不同生产日期有效期至情况：应该提示“XX（商品编号+名称）批号XX以往入库生产日期XX,有效期至XXX，请核对是否正确”，然后有2个选项：①核对正确（选择该项后生成不同的批号ID，存储同批号不同生产日期/有效期至的情况）②返回修改（选择该项后返回录入界面）
                if (tt.manufacturerLotNumOld == tt.manufacturerLotNum && (tt.showProductionDateOld != tt.showProductionDate || tt.showExpiredDateOld != tt.showExpiredDate)) {
                    arr.push({ obj: tt, ii: ii, text: `${tt.itemNum}${tt.itemName}，批号${tt.manufacturerLotNum},以往入库生产日期${tt.batchProductionDateOld},有效期至${tt.batchExpiredDateOld}，请核对是否正确` });
                }
                // 2.当前录入界面存在同批号不同生产日期有效期至情况：应该提示“XX（商品编号+名称）批号XX存在不同生产日期和有效期至，请核对是否正确”，然后有2个选项：①核对正确（选择该项后生成不同的批号ID，存储同批号不同生产日期/有效期至的情况）②返回修改（选择该项后返回录入界面）
                for (let i = ii; i < params.rcvLinesDTOList.length; i++) {
                    if (tt.itemId !== params.rcvLinesDTOList[i].itemId || tt.manufacturerLotNum !== params.rcvLinesDTOList[i].manufacturerLotNum) { continue; }
                    if (tt.batchProductionDate != params.rcvLinesDTOList[i].batchProductionDate || tt.batchExpiredDate != params.rcvLinesDTOList[i].batchExpiredDate) {
                        arr.push({ obj: tt, ii: ii, text: `${tt.itemNum}${tt.itemName}，批号${tt.manufacturerLotNum},存在不同生产日期和有效期至，请核对是否正确` });
                    }
                }
                if (!tt.manufacturerLotNumOld) {
                    tt.editFlag = 0; // 新增
                } else {
                    tt.editFlag = 2; // 不变
                }
            });
            if (arr.length === 0) {
                fun(params);
            } else {
                const h = this.$createElement;
                this.$confirm({
                    content: h('div', { style: { paddingLeft: '45px' } }, arr.map(item => h('div', item.text))),
                    okText: '核对正确',
                    cancelText: '返回修改',
                    width: 900,
                    onOk: () => {
                        arr.forEach(item => {
                            params.rcvLinesDTOList[item.ii].editFlag = 0;
                            params.rcvLinesDTOList[item.ii].batchNum = null;
                            params.rcvLinesDTOList[item.ii].batchId = null;
                            // item.obj.editFlag = 0;// 新增
                            // item.obj.batchNum = null;
                            // item.obj.batchId = null;
                        }) // 新增
                        return fun(params);
                    }
                })
            }
        },







    }

};