package com.zy.asrs.wms.asrs.manage;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.dto.*;
import com.zy.asrs.wms.asrs.entity.dto.OrderOutMergeDto;
import com.zy.asrs.wms.asrs.entity.enums.*;
import com.zy.asrs.wms.asrs.entity.param.*;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.service.*;
import com.zy.asrs.wms.utils.OrderUtils;
import com.zy.asrs.wms.utils.OutUtils;
import com.zy.asrs.wms.utils.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 出库管理
 */
@Service
public class OutManage {

    private static Logger logger = LoggerFactory.getLogger(LocManage.class);

    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskDetlService taskDetlService;
    @Autowired
    private TaskDetlFieldService taskDetlFieldService;
    @Autowired
    private LocService locService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private LocDetlFieldService locDetlFieldService;
    @Autowired
    private WorkService workService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private OutUtils outUtils;
    @Autowired
    private OperationPortService operationPortService;
    @Autowired
    private OrderUtils orderUtils;
    @Autowired
    private OrderNoRuleService orderNoRuleService;
    @Autowired
    private WaveService waveService;
    @Autowired
    private WaveDetlService waveDetlService;
    @Autowired
    private CacheSiteService cacheSiteService;
    @Autowired
    private WaveSeedService waveSeedService;

    /**
     * 出库
     */
    @Transactional
    public void out(OutParam outParam) {
        if (outParam.getOperationPort() == null) {
            throw new CoolException("作业口不存在");
        }

        List<OutLocDto> list = outUtils.merge(outParam);
        processTask(list);
    }

    private void processTask(List<OutLocDto> list) {
        for (OutLocDto locDto : list) {
            long taskType = locDto.getAll() ? 101L : 103L;

            Loc loc = locService.getById(locDto.getLocId());
            if(loc == null) {
                throw new CoolException("库位不存在");
            }

            if (!loc.getLocStsId().equals(LocStsType.F.val())) {
                throw new CoolException("库位状态不在库");
            }

            Task task = new Task();
            task.setTaskNo(workService.generateTaskNo(1L));
            task.setTaskSts(TaskStsType.GENERATE_OUT.id);
            task.setTaskType(taskType);
            task.setIoPri(workService.generateIoPri(taskType));
            task.setOriginLoc(loc.getLocNo());
            task.setTargetSite(locDto.getOperationPort());
            task.setBarcode(loc.getBarcode());
            boolean res = taskService.save(task);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }
            // 工作档明细保存
            for (OutDetlDto detl : locDto.getDetls()) {
                LocDetl locDetl = locDetlService.getById(detl.getDetlId());
                if(locDetl == null) {
                    throw new CoolException("明细不存在");
                }

                TaskDetl taskDetl = new TaskDetl();
                taskDetl.sync(locDetl);
                taskDetl.setTaskId(task.getId());
                taskDetl.setTaskNo(task.getTaskNo());
                taskDetl.setAnfme(detl.getAnfme());
                taskDetl.setStock(detl.getStock());
                taskDetl.setOrderId(null);
                taskDetl.setOrderNo(null);
                if (!taskDetlService.save(taskDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }

                List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
                for (LocDetlField locDetlField : locDetlFields) {
                    TaskDetlField taskDetlField = new TaskDetlField();
                    taskDetlField.sync(locDetlField);
                    taskDetlField.setDetlId(taskDetl.getId());
                    boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
                    if(!taskDetlFieldSave){
                        throw new CoolException("明细扩展生成失败");
                    }
                }
            }

            //库位F => R
            loc.setLocStsId(LocStsType.R.val());
            loc.setUpdateTime(new Date());
            boolean locUpdate = locService.updateById(loc);
            if(!locUpdate){
                throw new CoolException("库位状态更新失败");
            }
        }
    }

    public List<OrderOutBatchPreviewDto> orderOutBatchPreview(OrderOutBatchPreviewParam param) {
        List<Long> orderDetlIds = param.getOrderDetlIds();
        if (orderDetlIds.isEmpty()) {
            throw new CoolException("订单明细不能为空");
        }

        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getId, orderDetlIds).orderByAsc(OrderDetl::getOrderNo, OrderDetl::getCreateTime));
        if (orderDetls.isEmpty()) {
            throw new CoolException("订单明细不存在");
        }
        orderDetls = orderDetlService.parseDetl(orderDetls);

        HashMap<Long, List<LocDetl>> orderDetlLocMap = new HashMap<>();
        List<OutDetlDto> detlDtos = new ArrayList<>();

        for (OrderDetl orderDetl : orderDetls) {
            double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
            if (issued <= 0.0D) { continue; }
            List<LocDetl> locDetls = locDetlService.queryStock(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
            orderDetlLocMap.put(orderDetl.getId(), locDetls);
            for (LocDetl locDetl : locDetls) {
                if (issued > 0) {
                    OutDetlDto outDetlDto = new OutDetlDto();
                    outDetlDto.setDetlId(locDetl.getId());
                    outDetlDto.setAnfme(issued >= locDetl.getAnfme() ? locDetl.getAnfme() : issued);
                    outDetlDto.setStock(locDetl.getAnfme());
                    outDetlDto.setOrderDetlId(orderDetl.getId());
                    detlDtos.add(outDetlDto);
                    issued = issued - outDetlDto.getAnfme();
                }else {
                    break;
                }
            }
        }

        HashMap<Long, List<OutDetlDto>> map = new HashMap<>();
        for (OutDetlDto detlDto : detlDtos) {
            LocDetl locDetl = locDetlService.getById(detlDto.getDetlId());
            List<OutDetlDto> dtos = map.get(locDetl.getLocId());
            if (dtos == null) {
                dtos = new ArrayList<>();
                dtos.add(detlDto);
            }else {
                dtos.add(detlDto);
            }
            map.put(locDetl.getLocId(), dtos);
        }

        List<Long> orderDetlIdsTmp = param.getOrderDetlIds();
        List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
        for (Map.Entry<Long, List<OutDetlDto>> entry : map.entrySet()) {
            Long locId = entry.getKey();
            Loc loc = locService.getById(locId);

            List<OutDetlDto> outDetlDtos = entry.getValue();
            for (OutDetlDto outDetlDto : outDetlDtos) {
                orderDetlIdsTmp.remove(outDetlDto.getOrderDetlId());
            }
            Boolean all = outUtils.isAllForOut(locId, outDetlDtos);

            for (OutDetlDto outDetlDto : outDetlDtos) {
                OrderOutBatchPreviewDto previewDto = new OrderOutBatchPreviewDto();
                previewDto.setLocId(locId);
                previewDto.setLocNo(loc.getLocNo());
                previewDto.setLocDetlId(outDetlDto.getDetlId());
                previewDto.setAll(all);
                previewDto.setAnfme(outDetlDto.getAnfme());
                previewDto.setStock(outDetlDto.getStock());
                previewDto.setOrderDetlId(outDetlDto.getOrderDetlId());
                previewDtos.add(previewDto);


                List<BatchPreviewOtherLocDto> otherLocs = new ArrayList<>();
                previewDto.setOtherLoc(otherLocs);

                List<LocDetl> locDetls = orderDetlLocMap.get(outDetlDto.getOrderDetlId());
                for (LocDetl locDetl : locDetls) {
                    BatchPreviewOtherLocDto otherLocDto = new BatchPreviewOtherLocDto();
                    otherLocDto.setLocId(locDetl.getLocId());
                    otherLocDto.setLocNo(locDetl.getLocNo());
                    otherLocDto.setStock(locDetl.getAnfme());
                    otherLocDto.setLocDetlId(locDetl.getId());

                    if (locDetl.getLocId().equals(locId)) {
                        otherLocs.add(0, otherLocDto);
                        continue;
                    }

                    if (otherLocs.isEmpty()) {
                        otherLocs.add(otherLocDto);
                    }

                    for (int i = 0; i < otherLocs.size(); i++) {
                        BatchPreviewOtherLocDto locDto = otherLocs.get(i);
                        if (locDto.getLocId().equals(locDetl.getLocId())) {
                            break;
                        }
                        otherLocs.add(otherLocDto);
                    }
                }
            }

        }

        for (Long id : orderDetlIdsTmp) {
            OrderDetl orderDetl = orderDetlService.getById(id);
            double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);

            OrderOutBatchPreviewDto previewDto = new OrderOutBatchPreviewDto();
            previewDto.setLocId(null);
            previewDto.setLocNo(null);
            previewDto.setLocDetlId(null);
            previewDto.setAll(null);
            previewDto.setAnfme(issued);
            previewDto.setStock(0D);
            previewDto.setOrderDetlId(orderDetl.getId());

            previewDtos.add(previewDto);
        }

        return previewDtos;
    }

    @Transactional
    public void orderOutBatch(List<OrderOutBatchPreviewDto> param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        if (param.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        boolean noStock = true;
        for (OrderOutBatchPreviewDto dto : param) {
            if (dto.getStock() > 0) {
                noStock = false;
                break;
            }
        }
        if (noStock) {
            throw new CoolException("库存不足");
        }


        HashMap<Long, List<OrderOutBatchPreviewDto>> detlMap = new HashMap<>();
        for (OrderOutBatchPreviewDto previewDto : param) {
            if (previewDto.getLocId() == null) {
                continue;
            }

            if(detlMap.containsKey(previewDto.getLocDetlId())) {
                List<OrderOutBatchPreviewDto> previewDtos = detlMap.get(previewDto.getLocDetlId());
                previewDtos.add(previewDto);
                detlMap.put(previewDto.getLocDetlId(), previewDtos);
            }else {
                List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
                previewDtos.add(previewDto);
                detlMap.put(previewDto.getLocDetlId(), previewDtos);
            }
        }

        List<OrderOutBatchPreviewDto> dtos = new ArrayList<>();
        for (Map.Entry<Long, List<OrderOutBatchPreviewDto>> entry : detlMap.entrySet()) {
            Long locDetlId = entry.getKey();
            LocDetl locDetl = locDetlService.getById(locDetlId);
            if (locDetl == null) {
                continue;
            }

            Double stock = locDetl.getAnfme();
            for (OrderOutBatchPreviewDto dto : entry.getValue()) {
                stock = stock - dto.getAnfme();
                if (stock >= 0) {
                    dtos.add(dto);
                }
            }
        }


        HashMap<Long, List<OrderOutBatchPreviewDto>> map = new HashMap<>();

        for (OrderOutBatchPreviewDto previewDto : dtos) {
            if(map.containsKey(previewDto.getLocId())) {
                List<OrderOutBatchPreviewDto> previewDtos = map.get(previewDto.getLocId());
                previewDtos.add(previewDto);
                map.put(previewDto.getLocId(), previewDtos);
            }else {
                List<OrderOutBatchPreviewDto> previewDtos = new ArrayList<>();
                previewDtos.add(previewDto);
                map.put(previewDto.getLocId(), previewDtos);
            }
        }

        for (Map.Entry<Long, List<OrderOutBatchPreviewDto>> entry : map.entrySet()) {
            Long locId = entry.getKey();
            List<OrderOutBatchPreviewDto> previewDtos = entry.getValue();
            Boolean all = outUtils.isAllForPreview(locId, previewDtos);
            OrderOutBatchPreviewDto previewDto = previewDtos.get(0);
            Long operationPortId = previewDto.getOperationPort();

            Loc loc = locService.getById(locId);
            if (loc == null) {
                continue;
            }

            if (!loc.getLocStsId().equals(LocStsType.F.val())) {
                continue;
            }

            OperationPort operationPort = operationPortService.getById(operationPortId);
            if (operationPort == null) {
                throw new CoolException("作业口不存在");
            }


            long taskType = all ? 101L : 103L;

            Task task = new Task();
            task.setTaskNo(workService.generateTaskNo(taskType));
            task.setTaskSts(TaskStsType.GENERATE_OUT.id);
            task.setTaskType(taskType);
            task.setIoPri(workService.generateIoPri(taskType));
            task.setOriginLoc(loc.getLocNo());
            task.setTargetSite(operationPort.getFlag());
            task.setBarcode(loc.getBarcode());
            boolean res = taskService.save(task);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }

            for (OrderOutBatchPreviewDto dto : previewDtos) {
                LocDetl locDetl = locDetlService.getById(dto.getLocDetlId());
                if(locDetl == null) {
                    throw new CoolException("明细不存在");
                }

                OrderDetl orderDetl = orderDetlService.getById(dto.getOrderDetlId());
                if(orderDetl == null) {
                    throw new CoolException("订单明细不存在");
                }
                orderUtils.updateWorkQty(dto.getOrderDetlId(), dto.getAnfme());

                TaskDetl taskDetl = new TaskDetl();
                taskDetl.sync(locDetl);
                taskDetl.setId(null);
                taskDetl.setTaskId(task.getId());
                taskDetl.setTaskNo(task.getTaskNo());
                taskDetl.setAnfme(dto.getAnfme());
                taskDetl.setStock(locDetl.getAnfme());
                taskDetl.setOrderId(orderDetl.getOrderId());
                taskDetl.setOrderNo(orderDetl.getOrderNo());
                taskDetl.setDetlId(orderDetl.getId());
                if (!taskDetlService.save(taskDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }

                List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
                for (LocDetlField locDetlField : locDetlFields) {
                    TaskDetlField taskDetlField = new TaskDetlField();
                    taskDetlField.sync(locDetlField);
                    taskDetlField.setId(null);
                    taskDetlField.setDetlId(taskDetl.getId());
                    boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
                    if(!taskDetlFieldSave){
                        throw new CoolException("明细扩展生成失败");
                    }
                }
            }

            //库位F => R
            loc.setLocStsId(LocStsType.R.val());
            loc.setUpdateTime(new Date());
            boolean locUpdate = locService.updateById(loc);
            if(!locUpdate){
                throw new CoolException("库位状态更新失败");
            }

        }

    }

    @Transactional
    public List<MergePreviewDto> orderOutMergePreview(OrderOutMergePreviewParam param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        List<Long> orderIds = param.getOrderIds();
        if (orderIds.isEmpty()) {
            throw new CoolException("订单不能为空");
        }

        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getId, orderIds));
        if (orders.isEmpty()) {
            throw new CoolException("订单不存在");
        }

        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, orderIds));
        if(orderDetls.isEmpty()){
            throw new CoolException("订单明细不存在");
        }
        orderDetls = orderDetlService.parseDetl(orderDetls);

        HashMap<String, Double> locDetlStockMap = new HashMap<>();
        for (OrderDetl orderDetl : orderDetls) {
            String matUniqueKey = Utils.getMatUniqueKey(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
            double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
            if (locDetlStockMap.containsKey(matUniqueKey)) {
                Double anfme = locDetlStockMap.get(matUniqueKey);
                anfme += issued;
                locDetlStockMap.put(matUniqueKey, anfme);
            }else {
                locDetlStockMap.put(matUniqueKey, issued);
            }
        }

        List<MergePreviewDto> mergePreviewDtos = new ArrayList<>();
        for (Map.Entry<String, Double> entry : locDetlStockMap.entrySet()) {
            String matUniqueKey = entry.getKey();
            Double anfme = entry.getValue();

            MatUniqueObjDto matUniqueObj = Utils.getMatUniqueObj(matUniqueKey);
            HashMap<String, Object> dynamicFields = new HashMap<>();
            for (FieldParam fieldParam : matUniqueObj.getParams()) {
                dynamicFields.put(fieldParam.getName(), fieldParam.getValue());
            }

            MergePreviewDto dto = new MergePreviewDto();
            dto.setMatnr(matUniqueObj.getMatnr());
            dto.setBatch(matUniqueObj.getBatch());
            dto.setAnfme(anfme);
            dto.setOrderIds(orderIds);
            dto.setFieldParamsEncode(JSON.toJSONString(matUniqueObj.getParams()));
            dto.setDynamicFields(dynamicFields);
            mergePreviewDtos.add(dto);
        }


        return mergePreviewDtos;
    }

    @Transactional
    public List<MergePreviewResultDto> orderOutMergeLocPreview(List<MergePreviewDto> param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        if (param.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        for (MergePreviewDto dto : param) {
            List<FieldParam> fieldParams = JSON.parseArray(dto.getFieldParamsEncode(), FieldParam.class);
            dto.setFieldParams(fieldParams);
        }

        FieldSortParam sortParam = new FieldSortParam("anfme","desc");
        List<FieldSortParam> sortParams = new ArrayList<>();
        sortParams.add(sortParam);

        List<MergePreviewResultDto> resultDtos = new ArrayList<>();
        for (MergePreviewDto dto : param) {
            List<LocDetl> locDetls = locDetlService.queryStock(dto.getMatnr(), dto.getBatch(), dto.getFieldParams(), sortParams);
            if(locDetls.isEmpty()){
                MergePreviewResultDto resultDto = new MergePreviewResultDto();
                resultDto.sync(dto);
                resultDto.setLocs(new ArrayList<>());
                resultDto.setOrderIds(dto.getOrderIds());
                resultDto.setAnfme(dto.getAnfme());
                resultDtos.add(resultDto);
                continue;
            }

            List<MergePreviewResultLocDto> locDtos = new ArrayList<>();

            MergePreviewResultDto resultDto = new MergePreviewResultDto();
            resultDto.sync(dto);
            resultDto.setLocs(locDtos);
            resultDto.setOrderIds(dto.getOrderIds());

            Double anfme = dto.getAnfme();
            for (LocDetl locDetl : locDetls) {
                Loc loc = locService.getById(locDetl.getLocId());
                if (loc == null) {
                    throw new CoolException("库位数据不存在");
                }

                if (loc.getLocStsId() != LocStsType.F.val()) {
                    continue;
                }

                MergePreviewResultLocDto locDto = new MergePreviewResultLocDto();
                locDto.setLocId(locDetl.getLocId());
                locDto.setLocNo(locDetl.getLocNo());
                locDto.setLocDetlId(locDetl.getId());

                locDtos.add(locDto);
                if (anfme - locDetl.getAnfme() < 0) {
                    locDto.setAnfme(anfme);
                    break;
                }
                locDto.setAnfme(locDetl.getAnfme());
                anfme -= locDetl.getAnfme();
            }

            List<MergePreviewResultLocDto> otherLocDtos = new ArrayList<>();
            for (LocDetl locDetl : locDetls) {
                Loc loc = locService.getById(locDetl.getLocId());
                if (loc == null) {
                    throw new CoolException("库位数据不存在");
                }

                if (loc.getLocStsId() != LocStsType.F.val()) {
                    continue;
                }

                MergePreviewResultLocDto locDto = new MergePreviewResultLocDto();
                locDto.setLocId(locDetl.getLocId());
                locDto.setLocNo(locDetl.getLocNo());
                locDto.setLocDetlId(locDetl.getId());
                locDto.setAnfme(locDetl.getAnfme());
                otherLocDtos.add(locDto);
            }
            resultDto.setOtherLocs(otherLocDtos);

            resultDto.setAnfme(dto.getAnfme());

            resultDtos.add(resultDto);
        }

        return resultDtos;
    }

    @Transactional
    public void orderOutMerge(OrderOutMergeParamDto dto) {
        if(dto == null){
            throw new CoolException("参数不能为空");
        }

        List<OrderOutMergeParam> params = dto.getList();

        if (params.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        List<Long> orderIds = null;

        List<OrderOutMergeParam> filterParam = new ArrayList<>();
        HashMap<String, OrderOutMergeParam> paramMap = new HashMap<>();
        for (OrderOutMergeParam param : params) {
            if (param.getLocId() == null) {
                continue;
            }

            filterParam.add(param);

            String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
            paramMap.put(matUniqueKey, param);

            if (orderIds == null) {
                orderIds = param.getOrderIds();
            }
        }

        if (orderIds == null) {
            throw new CoolException("订单不存在");
        }

        List<Order> orderList = orderService.listByIds(orderIds);
        if (orderList.isEmpty()) {
            throw new CoolException("订单不存在");
        }

        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, orderIds));
        if (orderDetls.isEmpty()) {
            throw new CoolException("订单明细不存在");
        }

        HashMap<String, List<OrderDetl>> detlMap = new HashMap<>();
        for (OrderDetl orderDetl : orderDetls) {
            String matUniqueKey = Utils.getMatUniqueKey(orderDetl.getMat$().getMatnr(), orderDetl.getBatch(), orderDetl.getUniqueField());
            if (detlMap.containsKey(matUniqueKey)) {
                List<OrderDetl> detls = detlMap.get(matUniqueKey);
                detls.add(orderDetl);
                detlMap.put(matUniqueKey, detls);
            }else {
                List<OrderDetl> detls = new ArrayList<>();
                detls.add(orderDetl);
                detlMap.put(matUniqueKey, detls);
            }
        }

        List<OrderOutMergeDto> orderOutMergeDtos = new ArrayList<>();
        for (OrderOutMergeParam param : filterParam) {
            String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
            if (!detlMap.containsKey(matUniqueKey)) {
                continue;
            }

            Double requireAnfme = param.getAnfme();

            List<OrderDetl> orderDetlList = detlMap.get(matUniqueKey);
            for (OrderDetl orderDetl : orderDetlList) {
                orderDetl = orderDetlService.getById(orderDetl);
                double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty()).orElse(0.0D);
                if (issued <= 0D) {
                    continue;
                }

                OrderOutMergeDto orderOutMergeDto = new OrderOutMergeDto();
                orderOutMergeDto.sync(param);
                orderOutMergeDto.setOrderDetlId(orderDetl.getId());

                Double updateWorkQty = null;

                if (requireAnfme > issued) {
                    orderOutMergeDto.setAnfme(issued);
                    updateWorkQty = issued;
                    requireAnfme -= issued;
                }else {
                    orderOutMergeDto.setAnfme(requireAnfme);
                    updateWorkQty = requireAnfme;
                    requireAnfme -= requireAnfme;
                }

                orderOutMergeDtos.add(orderOutMergeDto);

                orderUtils.updateWorkQty(orderDetl.getId(), updateWorkQty);
                if (requireAnfme <= 0) {
                    break;
                }
            }
        }

        HashMap<Long, List<OrderOutMergeDto>> map = new HashMap<>();
        for (OrderOutMergeDto orderOutMergeDto : orderOutMergeDtos) {
            List<OrderOutMergeDto> list = null;
            if (map.containsKey(orderOutMergeDto.getLocId())) {
                list = map.get(orderOutMergeDto.getLocId());
            }else {
                list = new ArrayList<>();
            }
            list.add(orderOutMergeDto);
            map.put(orderOutMergeDto.getLocId(), list);
        }

        List<TaskDetl> taskDetls = new ArrayList<>();
        for (Map.Entry<Long, List<OrderOutMergeDto>> entry : map.entrySet()) {
            Long locId = entry.getKey();
            List<OrderOutMergeDto> list = entry.getValue();
            Boolean all = outUtils.isAllForMerge(locId, list);
            OrderOutMergeDto param = list.get(0);
            Long operationPortId = param.getOperationPort();

            Loc loc = locService.getById(locId);
            if (loc == null) {
                throw new CoolException("库位不存在");
            }

            if (!loc.getLocStsId().equals(LocStsType.F.val())) {
                throw new CoolException(loc.getLocNo() + "库位状态异常");
            }

            OperationPort operationPort = operationPortService.getById(operationPortId);
            if (operationPort == null) {
                throw new CoolException("作业口不存在");
            }

            long taskType = all ? 101L : 103L;

            Task task = new Task();
            task.setTaskNo(workService.generateTaskNo(taskType));
            task.setTaskSts(TaskStsType.GENERATE_OUT.id);
            task.setTaskType(taskType);
            task.setIoPri(workService.generateIoPri(taskType));
            task.setOriginLoc(loc.getLocNo());
            task.setTargetSite(operationPort.getFlag());
            task.setBarcode(loc.getBarcode());
            boolean res = taskService.save(task);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }

            for (OrderOutMergeDto merge : list) {
                LocDetl locDetl = locDetlService.getById(merge.getLocDetlId());
                if(locDetl == null) {
                    throw new CoolException("明细不存在");
                }

                OrderDetl orderDetl = orderDetlService.getById(merge.getOrderDetlId());
                if(orderDetl == null) {
                    throw new CoolException("订单明细不存在");
                }

                TaskDetl taskDetl = new TaskDetl();
                taskDetl.sync(locDetl);
                taskDetl.setId(null);
                taskDetl.setTaskId(task.getId());
                taskDetl.setTaskNo(task.getTaskNo());
                taskDetl.setAnfme(merge.getAnfme());
                taskDetl.setStock(locDetl.getAnfme());
                taskDetl.setOrderId(orderDetl.getOrderId());
                taskDetl.setOrderNo(orderDetl.getOrderNo());
                taskDetl.setDetlId(orderDetl.getId());
                if (!taskDetlService.save(taskDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }

                List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
                for (LocDetlField locDetlField : locDetlFields) {
                    TaskDetlField taskDetlField = new TaskDetlField();
                    taskDetlField.sync(locDetlField);
                    taskDetlField.setId(null);
                    taskDetlField.setDetlId(taskDetl.getId());
                    boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
                    if(!taskDetlFieldSave){
                        throw new CoolException("明细扩展生成失败");
                    }
                }

                taskDetls.add(taskDetl);
            }

            //库位F => R
            loc.setLocStsId(LocStsType.R.val());
            loc.setUpdateTime(new Date());
            boolean locUpdate = locService.updateById(loc);
            if(!locUpdate){
                throw new CoolException("库位状态更新失败");
            }

        }

    }

    @Transactional
    public void orderOutMergeWave(OrderOutMergeParamDto dto) {
        if(dto == null){
            throw new CoolException("参数不能为空");
        }

        if (dto.getWaveId() == null) {
            throw new CoolException("未生成波次");
        }

        List<OrderOutMergeParam> params = dto.getList();

        if (params.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        Long waveId = dto.getWaveId();

        List<Long> filterParamsList = new ArrayList<>();
        List<OrderOutMergeParam> filterParams = new ArrayList<>();
        for (OrderOutMergeParam param : params) {
            if (param.getLocId() == null) {
                continue;
            }

            if(!filterParamsList.contains(param.getLocId())){
                filterParamsList.add(param.getLocId());
                filterParams.add(param);
            }
        }

        HashMap<String, Double> stockMap = new HashMap<>();
        for (OrderOutMergeParam param : filterParams) {
            String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
            WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));
            if(waveDetl == null){
                throw new CoolException("波次数据不存在");
            }

            double issued = Optional.of(waveDetl.getAnfme() - waveDetl.getWorkQty()).orElse(0.0D);
            if(!stockMap.containsKey(matUniqueKey)){
                stockMap.put(matUniqueKey, issued);
            }
        }

        HashMap<Long, List<OrderOutMergeDto>> map = new HashMap<>();
        for (OrderOutMergeParam param : filterParams) {
            LocDetl locDetl = locDetlService.getById(param.getLocDetlId());
            if(locDetl == null) {
                continue;
            }

            if (locDetl.getAnfme() - param.getAnfme() < 0) {
                continue;
            }

            OrderOutMergeDto orderOutMergeDto = new OrderOutMergeDto();
            orderOutMergeDto.sync(param);

            String matUniqueKey = Utils.getMatUniqueKey(param.getMatnr(), param.getBatch(), param.getFieldParams());
            Double issued = stockMap.get(matUniqueKey);
            if (issued - orderOutMergeDto.getAnfme() < 0) {
                orderOutMergeDto.setAnfme(issued);
                issued = 0D;
            }else {
                issued -= orderOutMergeDto.getAnfme();
            }
            stockMap.put(matUniqueKey, issued);

            List<OrderOutMergeDto> list = null;
            if (map.containsKey(orderOutMergeDto.getLocId())) {
                list = map.get(orderOutMergeDto.getLocId());
            }else {
                list = new ArrayList<>();
            }
            list.add(orderOutMergeDto);
            map.put(orderOutMergeDto.getLocId(), list);
        }

        if (map.isEmpty()) {
            throw new CoolException("库存不足");
        }

        for (Map.Entry<Long, List<OrderOutMergeDto>> entry : map.entrySet()) {
            Long locId = entry.getKey();
            List<OrderOutMergeDto> list = entry.getValue();
            Boolean all = outUtils.isAllForMerge(locId, list);
            OrderOutMergeDto param = list.get(0);
            Long operationPortId = param.getOperationPort();

            Loc loc = locService.getById(locId);
            if (loc == null) {
                throw new CoolException("库位不存在");
            }

            if (!loc.getLocStsId().equals(LocStsType.F.val())) {
                throw new CoolException(loc.getLocNo() + "库位状态异常");
            }

            OperationPort operationPort = operationPortService.getById(operationPortId);
            if (operationPort == null) {
                throw new CoolException("作业口不存在");
            }

            long taskType = all ? 101L : 103L;

            Task task = new Task();
            task.setTaskNo(workService.generateTaskNo(taskType));
            task.setTaskSts(TaskStsType.GENERATE_OUT.id);
            task.setTaskType(taskType);
            task.setIoPri(workService.generateIoPri(taskType));
            task.setOriginLoc(loc.getLocNo());
            task.setTargetSite(operationPort.getFlag());
            task.setBarcode(loc.getBarcode());
            boolean res = taskService.save(task);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }

            for (OrderOutMergeDto merge : list) {
                LocDetl locDetl = locDetlService.getById(merge.getLocDetlId());
                if(locDetl == null) {
                    throw new CoolException("明细不存在");
                }

                TaskDetl taskDetl = new TaskDetl();
                taskDetl.sync(locDetl);
                taskDetl.setId(null);
                taskDetl.setTaskId(task.getId());
                taskDetl.setTaskNo(task.getTaskNo());
                taskDetl.setAnfme(merge.getAnfme());
                taskDetl.setStock(locDetl.getAnfme());
                taskDetl.setWaveId(waveId);
                taskDetl.setOrderId(null);
                taskDetl.setOrderNo(null);
                if (!taskDetlService.save(taskDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }

                List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
                for (LocDetlField locDetlField : locDetlFields) {
                    TaskDetlField taskDetlField = new TaskDetlField();
                    taskDetlField.sync(locDetlField);
                    taskDetlField.setId(null);
                    taskDetlField.setDetlId(taskDetl.getId());
                    boolean taskDetlFieldSave = taskDetlFieldService.save(taskDetlField);
                    if(!taskDetlFieldSave){
                        throw new CoolException("明细扩展生成失败");
                    }
                }

                String matUniqueKey = Utils.getMatUniqueKey(taskDetl.getMatnr(), taskDetl.getBatch(), taskDetl.getUniqueField());
                WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));
                if (waveDetl == null) {
                    throw new CoolException("波次数据不存在");
                }
                waveDetl.setWorkQty(waveDetl.getWorkQty() + taskDetl.getAnfme());
                waveDetl.setUpdateTime(new Date());
                if (!waveDetlService.updateById(waveDetl)) {
                    throw new CoolException("波次数据更新失败");
                }

            }

            //库位F => R
            loc.setLocStsId(LocStsType.R.val());
            loc.setUpdateTime(new Date());
            boolean locUpdate = locService.updateById(loc);
            if(!locUpdate){
                throw new CoolException("库位状态更新失败");
            }

        }

        Wave wave = waveService.getById(waveId);
        if (wave == null) {
            throw new CoolException("波次不存在");
        }

        wave.setWaveStatus(WaveStatusType.GENERATE.id);
        wave.setUpdateTime(new Date());
        if (!waveService.updateById(wave)) {
            throw new CoolException("波次更新失败");
        }
    }

    @Transactional
    public void generateWave(GenerateWaveParam param) {
        if (param == null) {
            throw new CoolException("参数不能为空");
        }

        List<String> channels = param.getChannels();
        if (channels == null) {
            throw new CoolException("通道参数不能为空");
        }

        if (channels.isEmpty()) {
            throw new CoolException("通道参数不能为空");
        }

        for (String channel : channels) {
            long count = cacheSiteService.count(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getChannel, channel).ne(CacheSite::getSiteStatus, 0));
            if (count > 0) {
                throw new CoolException(channel + "通道已经分配波次");
            }
        }


        List<Long> orderIds = param.getOrderIds();
        if (orderIds == null) {
            throw new CoolException("订单参数不能为空");
        }

        if (orderIds.isEmpty()) {
            throw new CoolException("订单参数不能为空");
        }

        List<Order> orderList = orderService.listByIds(orderIds);
        if (orderList.isEmpty()) {
            throw new CoolException("订单不存在");
        }

        for (Order order : orderList) {
            if (order.getWaveId() != null) {
                throw new CoolException("当前订单中已经生成波次");
            }
        }

        String waveNo = orderNoRuleService.getOrderNo(3);
        Wave wave = new Wave();
        wave.setWaveNo(waveNo);
        wave.setWaveType(0);
        wave.setWaveStatus(WaveStatusType.INIT.id);
        if (!waveService.save(wave)) {
            throw new CoolException("波次生成失败");
        }

        HashMap<String, List<OrderDetl>> map = new HashMap<>();
        for (Order order : orderList) {
            List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, order.getId()));
            for (OrderDetl orderDetl : orderDetls) {
                List<OrderDetl> list = map.get(orderDetl.getStockIndex());
                if (list == null) {
                    list = new ArrayList<>();
                }
                list.add(orderDetl);
                map.put(orderDetl.getStockIndex(), list);
            }

            order.setOrderSettle(OrderSettleType.WAVE.val());
            order.setWaveId(wave.getId());
            order.setWaveNo(waveNo);
            order.setHasWave(1);
            order.setUpdateTime(new Date());
            if (!orderService.updateById(order)) {
                throw new CoolException("订单反写波次失败");
            }

            List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getSiteStatus, CacheSiteStatusType.O.id).in(CacheSite::getChannel, channels).orderBy(true, true, CacheSite::getChannel));
            if (cacheSites.isEmpty()) {
                throw new CoolException("缓存站空间不足，请稍后再试");
            }

            CacheSite cacheSite = cacheSites.get(0);
            cacheSite.setOrderId(order.getId());
            cacheSite.setOrderNo(order.getOrderNo());
            cacheSite.setSiteStatus(CacheSiteStatusType.R.id);
            cacheSite.setUpdateTime(new Date());
            if (!cacheSiteService.updateById(cacheSite)) {
                throw new CoolException("缓存站更新失败");
            }
        }

        for (Map.Entry<String, List<OrderDetl>> entry : map.entrySet()) {
            String stockIndex = entry.getKey();
            List<OrderDetl> orderDetls = entry.getValue();
            Double anfme = 0D;
            Long matId = null;
            String matnr = null;
            String batch = null;
            List<FieldParam> uniqueField = null;
            for (OrderDetl orderDetl : orderDetls) {
                anfme += orderDetl.getAnfme();
                matId = orderDetl.getMatId();
                matnr = orderDetl.getMat$().getMatnr();
                batch = orderDetl.getBatch();
                uniqueField = orderDetl.getUniqueField();
            }

            WaveDetl waveDetl = new WaveDetl();
            waveDetl.setWaveNo(waveNo);
            waveDetl.setWaveId(wave.getId());
            waveDetl.setStockIndex(stockIndex);
            waveDetl.setMatId(matId);
            waveDetl.setMatnr(matnr);
            waveDetl.setBatch(batch);
            waveDetl.setAnfme(anfme);
            waveDetl.setWorkQty(0D);
            waveDetl.setFieldParams(JSON.toJSONString(uniqueField));
            if (!waveDetlService.save(waveDetl)) {
                throw new CoolException("波次明细生成失败");
            }

        }

    }

    @Transactional
    public void cancelWave(List<Long> waveIds) {
        if (waveIds == null) {
            throw new CoolException("参数不能为空");
        }

        if (waveIds.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        List<Wave> waves = waveService.listByIds(waveIds);
        if (waves.isEmpty()) {
            throw new CoolException("波次不存在");
        }

        for (Wave wave : waves) {
            List<WaveDetl> waveDetls = waveDetlService.list(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, wave.getId()));
            for (WaveDetl waveDetl : waveDetls) {
                long count = taskDetlService.count(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getWaveId, wave.getId()));
                if (count > 0) {
                    throw new CoolException("已存在任务，禁止取消波次");
                }

                List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().eq(Order::getWaveId, wave.getId()));
                for (Order order : orders) {
                    order.setWaveId(null);
                    order.setWaveNo(null);
                    order.setHasWave(0);
                    if(order.getOrderSettle().equals(OrderSettleType.WAVE.val())){
                        order.setOrderSettle(OrderSettleType.WAIT.val());
                    }
                    if (!orderService.updateById(order)) {
                        throw new CoolException("订单反写失败");
                    }

                    CacheSite cacheSite = cacheSiteService.getOne(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderId, order.getId()));
                    if (cacheSite == null) {
                        throw new CoolException("缓存站不存在");
                    }
                    cacheSite.setSiteStatus(CacheSiteStatusType.O.id);
                    cacheSite.setOrderId(null);
                    cacheSite.setOrderNo(null);
                    cacheSite.setUpdateTime(new Date());
                    if (!cacheSiteService.updateById(cacheSite)) {
                        throw new CoolException("缓存站清空失败");
                    }
                }

                waveDetlService.removeById(waveDetl.getId());
            }

            waveService.removeById(wave.getId());
        }

    }

}