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.IoCollectCodeRequest;
import com.glxp.api.req.inout.FilterCodeRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
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.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, "订单不存在");
        }
        IoCollectOrderCheckCode one = ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, filterCodeRequest.getCode()));
        if (one != null) {
            return ResultVOUtils.error(500, "该追溯码已被其他单据校验");
        }
        //判断
        if (StrUtil.isNotEmpty(filterCodeRequest.getCode())) {
            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;
            }
            List<IoCollectOrderBizBackup> ioCollectOrderBizBackups = ioCollectOrderBizBackupService.listByBillNo(filterCodeRequest.getBillNo());
            UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeRequest.getCode());
            UdiRelevanceResponse udiRelevanceResponse;
            List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.selectGroupByNameCode(udiEntity.getUdi(), null);
            if (CollUtil.isEmpty(udiRelevanceResponses)) throw new JsonException(500, "字典不存在此产品！");
            else udiRelevanceResponse = udiRelevanceResponses.get(0);
            //校验是否本单产品
            IoCollectOrderBizBackup collectOrderBizBackup = vailByBatchNo(udiRelevanceResponses, ioCollectOrderBizBackups, udiEntity);
            if (collectOrderBizBackup == null) {
                return ResultVOUtils.error(500, "非此单产品");
            }
            udiEntity.setCode(filterCodeRequest.getCode());
            AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, udiRelevanceResponse);
            IoCollectOrderCheckCode ioCollectOrderCheckCode = new IoCollectOrderCheckCode();
            BeanUtils.copyProperties(ioCollectCodeBackup, ioCollectOrderCheckCode);
            orderBackup.setCheckCodeStatus(1);
            ThreadUtil.execAsync(() -> {
                ioCollectOrderCheckCodeService.save(ioCollectOrderCheckCode);
//                ioCollectOrderBackupService.updateByBillNo(orderBackup);
            });
            return ResultVOUtils.success(addEnterCodeResponse);
        } else {
            List<VailCodeResultResponse> vailCodeResultResponses = new ArrayList<>();
            for (String code : filterCodeRequest.getCodeList()) {
                IoCollectCodeBackup ioCollectCodeBackup = ioCollectCodeBackMapper.selectOne(new LambdaQueryWrapper<IoCollectCodeBackup>()
                        .eq(IoCollectCodeBackup::getBillNo, filterCodeRequest.getBillNo())
                        .eq(IoCollectCodeBackup::getCode, code));
                VailCodeResultResponse vailCodeResultResponse = new VailCodeResultResponse();
                if (ioCollectCodeBackup != null) {
                    vailCodeResultResponse.setStatus(1);
                    vailCodeResultResponse.setCode(code);
                    vailCodeResultResponse.setSucMsg("校验成功");
                    vailCodeResultResponses.add(vailCodeResultResponse);
                } else {
                    vailCodeResultResponse.setStatus(2);
                    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) {
        BaseResponse response = null;
        if (StrUtil.isNotEmpty(filterCodeRequest.getCode())) {
            response = insert(filterCodeRequest);
        } else {
            List<String> codeList = filterCodeRequest.getCodeList();
            for (String code : codeList) {
                filterCodeRequest.setCode(code);
                response = insert(filterCodeRequest);
            }
        }
        return response;
    }

    public BaseResponse insert(IoCollectCodeRequest filterCodeRequest) {
        IoCollectOrderBackup orderBackup = ioCollectOrderBackupService.getByBillNo(filterCodeRequest.getBillNo());
        if (orderBackup.getCheckCodeConfirm() == 0 || orderBackup.getCheckCodeConfirm() == null){
            orderBackup.setCheckCodeConfirm(1);
            ioCollectOrderBackupService.updateByBillNo(orderBackup);
        }
        IoCollectOrderCheckCode one = ioCollectOrderCheckCodeService.getOne(new LambdaQueryWrapper<IoCollectOrderCheckCode>().eq(IoCollectOrderCheckCode::getCode, filterCodeRequest.getCode()));
        if (one != null) {
            return ResultVOUtils.error(500, "该追溯码已被其他单据校验");
        }
        if (orderBackup == null) {
            return ResultVOUtils.error(500, "订单不存在");
        }
        UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeRequest.getCode());
        if (udiEntity == null) {
            return ResultVOUtils.error(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);
        return ResultVOUtils.success(orderBackup);
    }

    public BaseResponse commitCheckCodeOrder(IoCollectCodeRequest filterCodeRequest) {
        IoCollectOrderBackup orderBackup = ioCollectOrderBackupService.getByBillNo(filterCodeRequest.getBillNo());
        //已经完成单据码表
        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());
        for (IoCollectOrderBizBackup ioCollectOrderBizBackup : ioCollectOrderBizBackups) {
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(ioCollectOrderBizBackup.getNameCode());
            Integer checkCount = ioCollectOrderCheckCodeService.getCountByRelIdAndBillNo(udiRelevanceResponse.getId(), filterCodeRequest.getBillNo());
            if (checkCount != ioCollectOrderBizBackup.getScanCount()) {
                return ResultVOUtils.error(500, ioCollectOrderBizBackup.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);
            collectCodeBackups.add(ioCollectCodeBackup);
        }
        saveBatch(collectCodeBackups);
        orderBackup.setCheckCodeStatus(1);
        ioCollectOrderBackupService.updateByBillNo(orderBackup);
        return ResultVOUtils.success();
    }
}