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 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, "该单据已校验完成");
        }

        //判断
        CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
        collectOrderBizRequest.setOrderIdFk(filterCodeRequest.getBillNo());
        List<CollectOrderBizResponse> collectOrderBizResponses = ioCollectOrderBizBackupService.filterList(collectOrderBizRequest);

        if (StrUtil.isNotEmpty(filterCodeRequest.getCode())) {
            IoCollectOrderCheckCode one = ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, filterCodeRequest.getCode()));
            if (one != null) {
                return ResultVOUtils.error(500, "该追溯码已被其他单据校验");
            }
            for (CollectOrderBizResponse collectOrderBizResponse : collectOrderBizResponses) {
                UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(collectOrderBizResponse.getNameCode());
                Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
                if (checkCount == collectOrderBizResponse.getScanActCount()) {
                    BaseResponse response = new BaseResponse();
                    response.setData(filterCodeRequest.getCode());
                    response.setCode(500);
                    response.setMessage("追溯码校验校验超出");
                    return response;
                }
            }
            //校验是否本单产品
            UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeRequest.getCode());
            IoCollectOrderBizBackup collectOrderBizBackup = checkProduct(filterCodeRequest.getBillNo(), udiEntity);
            if (collectOrderBizBackup == null) {
                BaseResponse response = new BaseResponse();
                response.setData(filterCodeRequest.getCode());
                response.setCode(500);
                response.setMessage("非此单产品");
                return response;
            }
            IoCollectCodeBackup ioCollectCodeBackup = ioCollectCodeBackMapper.selectOne(new LambdaQueryWrapper<IoCollectCodeBackup>()
                    .eq(IoCollectCodeBackup::getBillNo, filterCodeRequest.getBillNo())
                    .eq(IoCollectCodeBackup::getCode, filterCodeRequest.getCode()));
            if (ioCollectCodeBackup == null) {
                BaseResponse response = new BaseResponse();
                response.setData(filterCodeRequest.getCode());
                response.setCode(503);
                response.setMessage("追溯码不存在");
                return response;
            }


            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
            udiEntity.setCode(filterCodeRequest.getCode());
            AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, udiRelevanceResponse);
            setOrderCheckStatus(ioCollectCodeBackup);
            return ResultVOUtils.success(addEnterCodeResponse);
        } else {
            List<VailCodeResultResponse> vailCodeResultResponses = new ArrayList<>();
            for (String code : filterCodeRequest.getCodeList()) {
                VailCodeResultResponse vailCodeResultResponse = new VailCodeResultResponse();
                IoCollectOrderCheckCode one = ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, code));
                if (one != null) {
                    vailCodeResultResponse.setStatus(2);
                    vailCodeResultResponse.setCode(code);
                    vailCodeResultResponse.setErrMsg("该追溯码已被单据校验");
                    vailCodeResultResponses.add(vailCodeResultResponse);
                    continue;
                }
                boolean shouldContinue = false;

                //todo 扫码超出 没有校验到..
                for (CollectOrderBizResponse collectOrderBizResponse : collectOrderBizResponses) {
                    UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(collectOrderBizResponse.getNameCode());
                    Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
                    if (checkCount == collectOrderBizResponse.getScanActCount()) {
                        vailCodeResultResponse.setStatus(3);
                        vailCodeResultResponse.setCode(code);
                        vailCodeResultResponse.setErrMsg("追溯码校验校验超出");
                        vailCodeResultResponses.add(vailCodeResultResponse);
                        shouldContinue = true;
                        break; // 跳出内部循环
                    }
                }
                if (shouldContinue) {
                    continue;
                }
                //校验是否本单产品
                UdiEntity udiEntity = FilterUdiUtils.getUdi(code);
                IoCollectOrderBizBackup collectOrderBizBackup = checkProduct(filterCodeRequest.getBillNo(), udiEntity);
                if (collectOrderBizBackup == null) {
                    vailCodeResultResponse.setStatus(4);
                    vailCodeResultResponse.setCode(code);
                    vailCodeResultResponse.setErrMsg("非此单产品");
                    vailCodeResultResponses.add(vailCodeResultResponse);
                    continue;
                }
                IoCollectCodeBackup ioCollectCodeBackup = ioCollectCodeBackMapper.selectOne(new LambdaQueryWrapper<IoCollectCodeBackup>()
                        .eq(IoCollectCodeBackup::getBillNo, filterCodeRequest.getBillNo())
                        .eq(IoCollectCodeBackup::getCode, code));
                if (ioCollectCodeBackup != null) {
                    vailCodeResultResponse.setStatus(1);
                    vailCodeResultResponse.setCode(code);
                    vailCodeResultResponse.setSucMsg("校验成功");
                    vailCodeResultResponses.add(vailCodeResultResponse);
                    //校验成功 加入校验表
                    //todo 更改完成之后 需要放开注释
                    setOrderCheckStatus(ioCollectCodeBackup);
                } else {
                    vailCodeResultResponse.setStatus(5);
                    vailCodeResultResponse.setCode(code);
                    vailCodeResultResponse.setErrMsg("追溯码不存在");
                    vailCodeResultResponses.add(vailCodeResultResponse);
                }
            }
            return ResultVOUtils.success(vailCodeResultResponses);
        }

    }



    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);
        for (CollectOrderBizResponse collectOrderBizResponse : list) {
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(collectOrderBizResponse.getNameCode());
            Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
            if (checkCount < collectOrderBizResponse.getScanCount()) {
                return ResultVOUtils.error(500, udiRelevanceResponse.getCpmctymc() + "追溯码未校验完成");
            }
        }



        //校验处方码表与校验码表是否多出或者缺少
        // 使用流过滤出只在ioCollectCodeBackups中存在的code
        List<String> uniqueBackupsCodes = ioCollectCodeBackups.stream()
                .map(IoCollectCodeBackup::getCode)
                .filter(code -> !ioCollectOrderCheckCodes.stream()
                        .map(IoCollectOrderCheckCode::getCode)
                        .anyMatch(code::equals))
                .collect(Collectors.toList());
        //uniqueBackupsCodes 校验码表中不存在的码

        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(ioCollectCodeBackups);
        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);
        });
    }
}