package com.glxp.api.service.collect;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.dao.collect.IoCollectCodeBackMapper;
import com.glxp.api.entity.basic.BasicSkPrescribeItemCode;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.req.collect.IoCollectCodeRequest;
import com.glxp.api.req.inout.FilterCodeRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectCodeResponse;
import com.glxp.api.res.inout.AddEnterCodeResponse;
import com.glxp.api.res.inout.VailCodeResultResponse;
import com.glxp.api.service.basic.UdiProductService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.inout.IoSplitFifoCodeService;
import com.glxp.api.util.udi.FilterUdiUtils;
import org.apache.bcel.classfile.Code;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class IoCollectCodeBackService extends ServiceImpl<IoCollectCodeBackMapper, IoCollectCodeBackup> {

    @Resource
    IoCollectCodeBackMapper ioCollectCodeBackMapper;

    @Resource
    IoCollectOrderBackupService ioCollectOrderBackupService;

    @Resource
    UdiRelevanceService udiRelevanceService;

    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;

    @Resource
    IoCollectOrderCheckCodeService ioCollectOrderCheckCodeService;

    @Resource
    IoSplitFifoCodeService ioSplitFifoCodeService;


    /**
     * 追溯码查询
     *
     * @param ioCollectCodeRequest
     * @return
     */
    public List<IoCollectCodeResponse> filterList(IoCollectCodeRequest ioCollectCodeRequest) {
        if (ioCollectCodeRequest == null) {
            return Collections.emptyList();
        }
        if (ioCollectCodeRequest.getPage() != null) {
            int offset = (ioCollectCodeRequest.getPage() - 1) * ioCollectCodeRequest.getLimit();
            PageHelper.offsetPage(offset, ioCollectCodeRequest.getLimit());
        }
        return super.baseMapper.filterList(ioCollectCodeRequest);
    }


    public BaseResponse scanCheckCode(IoCollectCodeRequest filterCodeRequest) {
        // 先根据单据编号获取订单备份信息
        IoCollectOrderBackup orderBackup = ioCollectOrderBackupService.getByBillNo(filterCodeRequest.getBillNo());
        if (orderBackup == null) {
            return ResultVOUtils.error(500, "订单不存在");
        }
        if (orderBackup.getCheckCodeStatus() == 1) {
            return ResultVOUtils.error(500, "该单据已校验完成");
        }

        // 判断传入的校验码情况
        if (StringUtils.hasText(filterCodeRequest.getCode())) {
            return handleSingleCode(filterCodeRequest);
        } else {
            return handleCodeList(filterCodeRequest);
        }
    }




    private BaseResponse handleSingleCode(IoCollectCodeRequest filterCodeRequest) {
        // 检查校验码是否已被其他单据校验
        IoCollectOrderCheckCode existingCode = getExistingCheckCode(filterCodeRequest.getCode());
        if (existingCode!= null) {
            return ResultVOUtils.error(500, "该追溯码已被其他单据校验");
        }

        // 校验是否本单产品
        UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeRequest.getCode());
        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
        IoCollectOrderBizBackup collectOrderBizBackup = checkProduct(filterCodeRequest.getBillNo(), udiEntity);
        if (collectOrderBizBackup == null) {
            BaseResponse response = new BaseResponse();
            response.setData(filterCodeRequest.getCode());
            response.setCode(500);
            response.setMessage("非此单产品");
            return response;
        }

        // 校验扫码次数是否超出
        Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
        if (checkCount >= collectOrderBizBackup.getScanCount()) {
            return ResultVOUtils.error(500, "追溯码数量超出");
        }
        IoCollectCodeBackup ioCollectCodeBackup = getIoCollectCodeBackup(filterCodeRequest.getBillNo(), filterCodeRequest.getCode());
        if (ioCollectCodeBackup == null) {
            BaseResponse response = new BaseResponse();
            response.setData(filterCodeRequest.getCode());
            response.setCode(503);
            response.setMessage("追溯码不存在");
            return response;
        }

        udiEntity.setCode(filterCodeRequest.getCode());
        AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, udiRelevanceResponse);
        setOrderCheckStatus(ioCollectCodeBackup);
        return ResultVOUtils.success(addEnterCodeResponse);
    }

    private BaseResponse handleCodeList(IoCollectCodeRequest filterCodeRequest) {
        List<VailCodeResultResponse> vailCodeResultResponses = new ArrayList<>();
        for (String code : filterCodeRequest.getCodeList()) {
            VailCodeResultResponse vailCodeResultResponse = new VailCodeResultResponse();
            vailCodeResultResponse.setCode(code);
            // 检查校验码是否已被其他单据校验
            IoCollectOrderCheckCode existingCode = getExistingCheckCode(code);
            if (existingCode!= null) {
                vailCodeResultResponse.setStatus(2);
                vailCodeResultResponse.setErrMsg("该追溯码已被单据校验");
                vailCodeResultResponses.add(vailCodeResultResponse);
                continue;
            }

            UdiEntity udiEntity = FilterUdiUtils.getUdi(code);
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
            // 校验是否本单产品
            IoCollectOrderBizBackup collectOrderBizBackup = checkProduct(filterCodeRequest.getBillNo(), udiEntity);
            if (collectOrderBizBackup == null) {
                vailCodeResultResponse.setStatus(4);
                vailCodeResultResponse.setErrMsg("非此单产品");
                vailCodeResultResponses.add(vailCodeResultResponse);
                continue;
            }

            // 校验扫码次数相关逻辑
            boolean isScanCountExceeded = checkScanCountExceeded(filterCodeRequest, udiRelevanceResponse, code);
            if (isScanCountExceeded) {
                vailCodeResultResponse.setStatus(3);
                vailCodeResultResponse.setErrMsg("追溯码校验校验超出");
                vailCodeResultResponses.add(vailCodeResultResponse);
                continue;
            }

            IoCollectCodeBackup ioCollectCodeBackup = getIoCollectCodeBackup(filterCodeRequest.getBillNo(), code);
            if (ioCollectCodeBackup!= null) {
                vailCodeResultResponse.setStatus(1);
                vailCodeResultResponse.setSucMsg("校验成功");
                vailCodeResultResponses.add(vailCodeResultResponse);
                // 校验成功 加入校验表
                setOrderCheckStatus(ioCollectCodeBackup);
            } else {
                vailCodeResultResponse.setStatus(5);
                vailCodeResultResponse.setErrMsg("追溯码不存在");
                vailCodeResultResponses.add(vailCodeResultResponse);
            }
        }
        return ResultVOUtils.success(vailCodeResultResponses);
    }


    private IoCollectOrderCheckCode getExistingCheckCode(String code) {
        return ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, code));
    }

    private IoCollectCodeBackup getIoCollectCodeBackup(String billNo, String code) {
        return ioCollectCodeBackMapper.selectOne(new LambdaQueryWrapper<IoCollectCodeBackup>()
                .eq(IoCollectCodeBackup::getBillNo, billNo)
                .eq(IoCollectCodeBackup::getCode, code));
    }

    private boolean checkScanCountExceeded(IoCollectCodeRequest filterCodeRequest, UdiRelevanceResponse udiRelevanceResponse, String code) {
        CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
        collectOrderBizRequest.setOrderIdFk(filterCodeRequest.getBillNo());
        collectOrderBizRequest.setRelId(udiRelevanceResponse.getId());
        List<CollectOrderBizResponse> collectOrderBizResponses = ioCollectOrderBizBackupService.filterList(collectOrderBizRequest);
        if (collectOrderBizResponses.isEmpty()) {
            return false;
        }
        CollectOrderBizResponse collectOrderBizResponse = collectOrderBizResponses.get(0);
        if (udiRelevanceResponse.getId().equals(collectOrderBizResponse.getRelId())){
            if ( filterCodeRequest.getCodeList().size() > collectOrderBizResponse.getScanCount()){
               throw new JsonException(500,"追溯码数量超出");
            }
        }
        Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
        return checkCount == collectOrderBizResponse.getScanCount();
    }
    public AddEnterCodeResponse setAddEnterCodeResponse(UdiEntity udiEntity, UdiRelevanceResponse checkUdi) {
        AddEnterCodeResponse addEnterCodeResponse = new AddEnterCodeResponse();
        BeanUtils.copyProperties(udiEntity, addEnterCodeResponse);
        addEnterCodeResponse.setBzgg(checkUdi.getBzgg());
        addEnterCodeResponse.setCpmctymc(checkUdi.getCpmctymc());
        addEnterCodeResponse.setPrepnSpec(checkUdi.getPrepnSpec());
        addEnterCodeResponse.setPrepnUnit(checkUdi.getPrepnUnit());
        addEnterCodeResponse.setPackUnit(checkUdi.getPackUnit());
        addEnterCodeResponse.setGgxh(checkUdi.getGgxh());
        return addEnterCodeResponse;
    }


    public IoCollectOrderBizBackup vailByBatchNo(List<UdiRelevanceResponse> udiRelevanceResponses, List<IoCollectOrderBizBackup> collectOrderBizBackups, UdiEntity udiEntity) {
        for (UdiRelevanceResponse udiRelevanceResponse : udiRelevanceResponses) {
            for (IoCollectOrderBizBackup collectOrderBizBackup : collectOrderBizBackups) {
                if (udiRelevanceResponse.getId().equals(collectOrderBizBackup.getRelId()) && (StrUtil.emptyIfNull(collectOrderBizBackup.getBatchNo()).equals(StrUtil.emptyIfNull(udiEntity.getBatchNo())))) {
                    return collectOrderBizBackup;
                }
            }
        }
        return null;
    }


    public BaseResponse replaceScanCode(IoCollectCodeRequest filterCodeRequest) {
        IoCollectOrderBackup orderBackup = ioCollectOrderBackupService.getByBillNo(filterCodeRequest.getBillNo());
        if (orderBackup.getCheckCodeConfirm() == 0 || orderBackup.getCheckCodeConfirm() == null) {
            orderBackup.setCheckCodeConfirm(1);
            ioCollectOrderBackupService.updateByBillNo(orderBackup);
        }

        if (StrUtil.isNotEmpty(filterCodeRequest.getCode())) {
            insert(filterCodeRequest, orderBackup);
        } else {
            List<String> codeList = filterCodeRequest.getCodeList();
            for (String code : codeList) {
                filterCodeRequest.setCode(code);
                insert(filterCodeRequest, orderBackup);
            }
        }
        return ResultVOUtils.success(orderBackup);
    }

    public void insert(IoCollectCodeRequest filterCodeRequest, IoCollectOrderBackup orderBackup) {
        IoCollectOrderCheckCode one = ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, filterCodeRequest.getCode()));
        if (one != null) {
            throw new JsonException(500, "该追溯码已被其他单据校验");
        }
        if (orderBackup == null) {
            throw new JsonException(500, "订单不存在");
        }
        UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeRequest.getCode());
        if (udiEntity == null) {
            throw new JsonException(500, "产品不存在");
        }
        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
        //吗替换的接口 替换哪个码
        IoCollectOrderCheckCode ioCollectOrderCheckCode =
                IoCollectOrderCheckCode.builder()
                        .code(filterCodeRequest.getCode())
                        .fifoSplit(3)
                        .relId(udiRelevanceResponse.getId())
                        .operUser(orderBackup.getCreateUser())
                        .busType(orderBackup.getBusType())
                        .billNo(orderBackup.getBillNo())
                        .fromType(orderBackup.getFromType())
                        .fromCorp(orderBackup.getFromCorp())
                        .workPlaceCode(orderBackup.getWorkPlaceCode())
                        .operTime(new Date())
                        .build();
        ioCollectOrderCheckCodeService.save(ioCollectOrderCheckCode);
        IoCollectCodeBackup ioCollectCodeBackup = new IoCollectCodeBackup();
        BeanUtils.copyProperties(ioCollectOrderCheckCode, ioCollectCodeBackup);
        ioCollectCodeBackup.setScanCodeCheckStatus(3);
        ioCollectCodeBackup.setId(null);
        save(ioCollectCodeBackup);
    }

    public BaseResponse commitCheckCodeOrder(IoCollectCodeRequest filterCodeRequest) {
        IoCollectOrderBackup orderBackup = ioCollectOrderBackupService.getByBillNo(filterCodeRequest.getBillNo());
        if (orderBackup.getCheckCodeStatus() == 1) {
            return ResultVOUtils.error(500, "该单据已校验完成");
        }
        //已经完成单据码表
        List<IoCollectCodeBackup> ioCollectCodeBackups = list(new LambdaQueryWrapper<IoCollectCodeBackup>().eq(IoCollectCodeBackup::getBillNo, filterCodeRequest.getBillNo()));
        //已经校验码表
        List<IoCollectOrderCheckCode> ioCollectOrderCheckCodes = ioCollectOrderCheckCodeService.list(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getBillNo, filterCodeRequest.getBillNo()));
        List<IoCollectOrderBizBackup> ioCollectOrderBizBackups = ioCollectOrderBizBackupService.listByBillNo(filterCodeRequest.getBillNo());
        CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
        collectOrderBizRequest.setOrderIdFk(filterCodeRequest.getBillNo());
        List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.filterList(collectOrderBizRequest);

        //
        List<IoCollectCodeBackup> uniqueBackupsCodes  = new ArrayList<>();
        for (CollectOrderBizResponse collectOrderBizResponse : list) {
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(collectOrderBizResponse.getNameCode());
            //先根据产品 和订单号搜索当前产品码是否包含有替换码
            List<IoCollectCodeBackup> ioCollectCodeBackups1 = list(new LambdaQueryWrapper<IoCollectCodeBackup>()
                    .eq(IoCollectCodeBackup::getBillNo, filterCodeRequest.getBillNo())
                    .eq(IoCollectCodeBackup::getRelId, udiRelevanceResponse.getId()));
            List<IoCollectCodeBackup> collects = ioCollectCodeBackups1.stream()
                    .filter(backup -> backup.getScanCodeCheckStatus() != null)
                    .filter(backup -> backup.getScanCodeCheckStatus() == 3)
                    .collect(Collectors.toList());
            if (collects.size() > 0) {
                uniqueBackupsCodes.addAll(ioCollectCodeBackups1);
                //如果有数据说明改产品已经 替换过码了需要全部校验
                Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
                if (checkCount < collectOrderBizResponse.getScanCount()) {
                    return ResultVOUtils.error(500, udiRelevanceResponse.getCpmctymc() + "追溯码未校验完成");
                }
            }
        }


        //校验处方码表与校验码表是否多出或者缺少
        List<String> uniqueCodes = uniqueBackupsCodes.stream()
                .map(IoCollectCodeBackup::getCode)
                .filter(code -> !ioCollectOrderCheckCodes.stream()
                        .map(IoCollectOrderCheckCode::getCode)
                        .anyMatch(code::equals))
                .collect(Collectors.toList());
        //uniqueCodes 替换掉的码

        System.out.println(uniqueCodes);
        List<String> checkCodeList = ioCollectOrderCheckCodes.stream()
                .map(IoCollectOrderCheckCode::getCode)
                .filter(code -> !ioCollectCodeBackups.stream()
                        .map(IoCollectCodeBackup::getCode)
                        .anyMatch(code::equals))
                .collect(Collectors.toList());
        // 对比原始码表多出来的码 checkCodeList

        //检查码是否存在队列如果存在移除
        for (String code : checkCodeList) {
            IoSplitFifoCodeEntity ioSplitFifoCodeEntity = ioSplitFifoCodeService.getOne(new LambdaQueryWrapper<IoSplitFifoCodeEntity>().eq(IoSplitFifoCodeEntity::getCode, code));
            if (ioSplitFifoCodeEntity != null) {
                ioSplitFifoCodeService.removeById(ioSplitFifoCodeEntity);
            }
        }

        boolean b = removeBatchByIds(uniqueBackupsCodes);
        ArrayList<IoCollectCodeBackup> collectCodeBackups = new ArrayList<>();
        for (IoCollectOrderCheckCode ioCollectOrderCheckCode : ioCollectOrderCheckCodes) {
            IoCollectCodeBackup ioCollectCodeBackup = new IoCollectCodeBackup();
            BeanUtils.copyProperties(ioCollectOrderCheckCode, ioCollectCodeBackup);
            ioCollectCodeBackup.setScanCodeCheckStatus(1);
            collectCodeBackups.add(ioCollectCodeBackup);
        }
        saveBatch(collectCodeBackups);
        orderBackup.setCheckCodeStatus(1);
        ioCollectOrderBackupService.updateByBillNo(orderBackup);
        return ResultVOUtils.success();
    }

    public List<IoCollectCodeBackup> listByBillNo(String billNo) {
        return ioCollectCodeBackMapper.selectList(new LambdaQueryWrapper<IoCollectCodeBackup>()
                .eq(IoCollectCodeBackup::getBillNo, billNo));
    }

    public IoCollectOrderBizBackup checkProduct(String billNo, UdiEntity udiEntity) {
        List<IoCollectOrderBizBackup> ioCollectOrderBizBackups = ioCollectOrderBizBackupService.listByBillNo(billNo);
        List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.selectGroupByNameCode(udiEntity.getUdi(), null);
        if (CollUtil.isEmpty(udiRelevanceResponses)) throw new JsonException(500, "字典不存在此产品！");
        //校验是否本单产品
        IoCollectOrderBizBackup collectOrderBizBackup = vailByBatchNo(udiRelevanceResponses, ioCollectOrderBizBackups, udiEntity);
        return collectOrderBizBackup;
    }

    private void setOrderCheckStatus(IoCollectCodeBackup ioCollectCodeBackup) {
        IoCollectOrderCheckCode ioCollectOrderCheckCode = new IoCollectOrderCheckCode();
        BeanUtils.copyProperties(ioCollectCodeBackup, ioCollectOrderCheckCode);
        ioCollectCodeBackup.setScanCodeCheckStatus(1);
        updateById(ioCollectCodeBackup);
//            orderBackup.setCheckCodeStatus(1);
        ThreadUtil.execAsync(() -> {
            ioCollectOrderCheckCodeService.save(ioCollectOrderCheckCode);
//                ioCollectOrderBackupService.updateByBillNo(orderBackup);
        });
    }
}