package com.vincent.rsf.server.api.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
import com.vincent.rsf.server.api.entity.params.CallForEmptyContainersParam;
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
import com.vincent.rsf.server.api.entity.params.PdaGeneralParam;
import com.vincent.rsf.server.api.service.PdaOutStockService;
import com.vincent.rsf.server.common.constant.Constants;
import com.vincent.rsf.server.manager.controller.params.LocToTaskParams;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.BasContainerServiceImpl;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class PdaOutStockServiceImpl implements PdaOutStockService {

    @Resource
    private TaskService taskService;
    @Resource
    private TaskItemService taskItemService;
    @Autowired
    private WaveService waveService;
    @Autowired
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;
    @Autowired
    private WaveOrderRelaService waveOrderRelaService;
    @Autowired
    private BasStationService basStationService;
    @Autowired
    private LocService locService;
    @Autowired
    private BasContainerServiceImpl basContainerService;
    @Autowired
    private LocItemService locItemService;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private WaitPakinItemService waitPakinItemService;

    @Override
    public R getOutStockTaskItem(String barcode) {
        LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Task::getBarcode, barcode);
        Task task = taskService.getOne(lambdaQueryWrapper.last("limit 1"));
        if (null == task) {
            return R.error("未查询到相关任务");
        }
        List<TaskItem> taskItems = taskItemService
                .list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (null == taskItems || taskItems.size() <= 0) {
            return R.error("任务出错，未查询到相关任务明细");
        }

        return R.ok(taskItems);
    }

    @Override
    public R saveOutTaskSts(String barcode) {
        LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Task::getBarcode, barcode);
        Task task = taskService.getOne(lambdaQueryWrapper.last("limit 1"));
        if (null == task) {
            throw new CoolException("未找到容器号对应任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }
        List<TaskItem> taskItems = taskItemService
                .list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
        maps.keySet().forEach(key -> {
            WkOrderItem orderItem = asnOrderItemService.getById(key);
            if (Objects.isNull(orderItem)) {
                throw new CoolException("单据明细不存在！！");
            }
        });
        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
        if (!taskService.updateById(task)) {
            return R.error("更新任务状态失败");
        }

        return R.ok("确认成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R containerRebinding(PdaGeneralParam param, Long userId) {
        if (Cools.isEmpty(param.getContainerNo())) {
            throw new CoolException("无容器号");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.getContainerNo()));
        if (null == task) {
            throw new CoolException("未找到任务");
        }
        if (!task.getResource().equals(TaskResouceType.TASK_RESOUCE_STOCK_UP.val)) {
            throw new CoolException("当前托盘不是备货出库任务");
        }
        List<TaskItem> taskItems = taskItemService
                .list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));

        WaitPakin waitPakin = waitPakinService
                .getOne(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, param.getNewContainerNo()));
        if (Cools.isEmpty(waitPakin)) {
            WaitPakin waitPakin1 = new WaitPakin();
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAIT_PAKIN_CODE, null);
            if (StringUtils.isBlank(ruleCode)) {
                throw new CoolException("编码规则错误： 编码规则「SYS_WAIT_PAKIN_CODE」规则是不存在");
            }
            waitPakin1.setCode(ruleCode)
                    .setIoStatus(PakinIOStatus.PAKIN_IO_STATUS_HOLD.val)
                    .setAnfme(taskItems.stream().map(TaskItem::getAnfme).mapToDouble(Double::doubleValue).sum())
                    .setUpdateBy(userId)
                    .setCreateBy(userId)
                    .setBarcode(param.getNewContainerNo());
            if (!waitPakinService.save(waitPakin1)) {
                throw new CoolException("组托主单保存失败！！");
            }
            List<WaitPakinItem> items = new ArrayList<>();
            for (TaskItem taskItem : taskItems) {
                WaitPakinItem pakinItem = new WaitPakinItem();
                pakinItem.setAnfme(taskItem.getAnfme())
                        .setPakinId(waitPakin1.getId())
                        .setSource(taskItem.getId())
                        .setAsnId(taskItem.getSourceId())
                        .setAsnCode(taskItem.getSourceCode())
                        .setAsnItemId(taskItem.getSource())
                        .setIsptResult(taskItem.getIsptResult())
                        .setPlatItemId(taskItem.getPlatItemId())
                        .setPlatOrderCode(taskItem.getPlatOrderCode())
                        .setPlatWorkCode(taskItem.getPlatWorkCode())
                        .setProjectCode(taskItem.getProjectCode())
                        .setBatch(taskItem.getSplrBatch())
                        .setUnit(taskItem.getUnit())
                        .setFieldsIndex(taskItem.getFieldsIndex())
                        .setMatnrId(taskItem.getMatnrId())
                        .setMaktx(taskItem.getMaktx())
                        .setUpdateBy(userId)
                        .setCreateBy(userId)
                        .setMatnrCode(taskItem.getMatnrCode());
                WkOrder order = asnOrderService.getById(taskItem.getSourceId());
                if (!Objects.isNull(order)) {
                    pakinItem.setType(null == order.getType() ? null : order.getType())
                            .setWkType(null == order.getWkType() ? null : Short.parseShort(order.getWkType()));
                }
                items.add(pakinItem);
            }
            if (!waitPakinItemService.saveBatch(items)) {
                throw new CoolException("组托明细保存失败！！");
            }
        } else {
            double sum = taskItems.stream().map(TaskItem::getAnfme).mapToDouble(Double::doubleValue).sum();
            waitPakin
                    .setAnfme(waitPakin.getAnfme() + sum)
                    .setUpdateBy(userId)
                    .setCreateBy(userId);
            if (!waitPakinService.updateById(waitPakin)) {
                throw new CoolException("组托主单保存失败！！");
            }
            List<WaitPakinItem> existPakinItems = waitPakinItemService
                    .list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
            List<WaitPakinItem> items = new ArrayList<>();
            for (TaskItem taskItem : taskItems) {
                Optional<WaitPakinItem> optionalItem = existPakinItems.stream()
                        .filter(e -> Objects.equals(e.getMatnrCode(), taskItem.getMatnrCode())
                                && Objects.equals(e.getBatch(), taskItem.getSplrBatch())
                                && Objects.equals(e.getPlatWorkCode(), taskItem.getPlatWorkCode())
                                && Objects.equals(e.getPlatItemId(), taskItem.getPlatItemId())
                        )
                        .findFirst();

                if (optionalItem.isPresent()) {
                    WaitPakinItem existItem = optionalItem.get();
                    existItem.setAnfme(existItem.getAnfme() + taskItem.getAnfme())
                            .setUpdateBy(userId);
                    if (!items.contains(existItem)) {
                        items.add(existItem);
                    }
                } else {
                    WaitPakinItem pakinItem = new WaitPakinItem();
                    pakinItem.setAnfme(taskItem.getAnfme())
                            .setPakinId(waitPakin.getId())
                            .setSource(taskItem.getId())
                            .setAsnId(taskItem.getSourceId())
                            .setAsnCode(taskItem.getSourceCode())
                            .setAsnItemId(taskItem.getSource())
                            .setIsptResult(taskItem.getIsptResult())
                            .setPlatItemId(taskItem.getPlatItemId())
                            .setPlatOrderCode(taskItem.getPlatOrderCode())
                            .setPlatWorkCode(taskItem.getPlatWorkCode())
                            .setProjectCode(taskItem.getProjectCode())
                            .setBatch(taskItem.getSplrBatch())
                            .setUnit(taskItem.getUnit())
                            .setFieldsIndex(taskItem.getFieldsIndex())
                            .setMatnrId(taskItem.getMatnrId())
                            .setMaktx(taskItem.getMaktx())
                            .setUpdateBy(userId)
                            .setCreateBy(userId)
                            .setMatnrCode(taskItem.getMatnrCode());
                    WkOrder order = asnOrderService.getById(taskItem.getSourceId());
                    if (!Objects.isNull(order)) {
                        pakinItem.setType(null == order.getType() ? null : order.getType())
                                .setWkType(null == order.getWkType() ? null : Short.parseShort(order.getWkType()));
                    }
                    items.add(pakinItem);
                    existPakinItems.add(pakinItem);
                }
            }
            if (!waitPakinItemService.saveOrUpdateBatch(items)) {
                throw new CoolException("组托明细保存失败！！");
            }
        }

        return R.ok();
    }

    @Override
    public R getWaveListItem(String barcode) {
        LambdaQueryWrapper<Wave> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(!Cools.isEmpty(barcode), Wave::getCode, barcode);
        List<Wave> waveList = waveService.list(lambdaQueryWrapper);
        return R.ok(waveList);
    }

    @Override
    public R getContainerWaveList(Map<String, String> map) {
        String barcode = map.get("barcode");

        if (Cools.isEmpty(barcode)) {
            throw new CoolException("参数有误");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, barcode).last("limit 1"));
        if (null == task) {
            throw new CoolException("未找到容器号对应任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }
        ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
        List<TaskItem> taskItems = taskItemService
                .list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        for (TaskItem taskItem : taskItems) {
            ContainerWaveDto containerWaveDto = new ContainerWaveDto();
            containerWaveDto.setTaskItem(taskItem);
            Wave wave = waveService.getById(taskItem.getSourceId());
            if (null == wave) {
                throw new CoolException("未找到容器号对应波次");
            }
            List<WaveOrderRela> waveOrderRelas = waveOrderRelaService
                    .list(new LambdaQueryWrapper<WaveOrderRela>().eq(WaveOrderRela::getWaveId, wave.getId()));
            if (Cools.isEmpty(waveOrderRelas)) {
                throw new CoolException("波次对应关联单未找到");
            }
            Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
            ArrayList<WkOrderItem> list = new ArrayList<>();
            List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
            for (WkOrder wkOrder : wkOrderList) {
                List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getOrderId, wkOrder.getId())
                        .eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode,
                                taskItem.getMatnrCode())
                // .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch,
                // taskItem.getBatch())
                );
                if (null != orderItem) {
                    list.addAll(orderItem);
                }
            }
            containerWaveDto.setWkOrderItems(list);
            containerWaveDtos.add(containerWaveDto);
        }

        return R.ok(containerWaveDtos);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @Synchronized
    public R saveWavePick(ContainerWaveParam containerWaveParam, Long loginUserId) {
        if (null == containerWaveParam || containerWaveParam.getContainerWaveDtos().size() <= 0) {
            return R.error("参数错误");
        }
        Task task = taskService.getOne(
                new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer()).last("limit 1"));
        if (null == task) {
            return R.error("未找到托盘对应的任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }

        for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
            // 做一次校验，判断前端所有出库数量是否超过本托出库数量
            double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
            BigDecimal total = new BigDecimal(String.valueOf(sum));
            BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
            if (!anfme.equals(total)) {
                throw new CoolException("播种数量不等于容器出库数量，请检查");
            }
            for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
                if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
                    continue;
                }
                WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString())
                        .subtract(new BigDecimal(orderItem.getQty().toString()));
                BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
                if (num.compareTo(orderDemandQty) < 0) {
                    throw new CoolException("播种数量大于单据出库数量，请检查");
                }
                WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
                if (Cools.isEmpty(wkOrder)) {
                    throw new CoolException("出库单主单未找到");
                }
                wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
                if (!asnOrderService.updateById(wkOrder)) {
                    throw new CoolException("出库单更新状态失败");
                }
                orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
                if (!asnOrderItemService.updateById(orderItem)) {
                    throw new CoolException("单据明细更新失败");
                }
                // 检查单据是否完成
                Boolean orderChecked = checkOrderComplete(orderItem);
                if (orderChecked) {
                    wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                    if (!asnOrderService.updateById(wkOrder)) {
                        throw new CoolException("出库单更新状态失败");
                    }
                }
            }
            // 检查波次是否完成
            // Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
            // if (waveChecked){
            // Wave wave =
            // waveService.getById(containerWaveDto.getTaskItem().getSourceId());
            // if (null == wave){
            // throw new CoolException("未找到容器号对应波次");
            // }
            // wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
            // if (!waveService.updateById(wave)){
            // throw new CoolException("波次单更新状态失败");
            // }
            // }

        }

        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
        if (!taskService.updateById(task)) {
            throw new CoolException("任务状态更新失败");
        }

        return R.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @Synchronized
    public R callForEmptyContainers(CallForEmptyContainersParam containerWaveParam, Long loginUserId) {
        // 参数校验
        if (Objects.isNull(containerWaveParam) || StringUtils.isEmpty(containerWaveParam.getStaNo())) {
            throw new CoolException("参数错误，站点号不能为空");
        }
        // 1. 站点信息判断 - 终点
        BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                .eq(BasStation::getStationName, containerWaveParam.getStaNo())
                .orderByDesc(BasStation::getId)
                .last("LIMIT 1"));

        if (Objects.isNull(basStation)) {
            throw new CoolException(containerWaveParam.getStaNo() + "站点不存在！！");
        }
        if (!basStation.getUseStatus().equals("O")) {
            throw new CoolException("站点状态不为空闲");
        }

        List<Long> areaList = basStation.getCrossZoneArea();
        if (Cools.isEmpty(areaList)) {
            throw new CoolException("当前站点库区未配置");
        }

        BasContainer basContainer = basContainerService.getOne(new LambdaQueryWrapper<BasContainer>()
                .in(BasContainer::getContainerType, containerWaveParam.getType(), false).last("limit 1"));
        if (Cools.isEmpty(basContainer)) {
            throw new CoolException("未查询到相关容器规则");
        }
        String barcodeType = "barcode REGEXP '" + basContainer.getCodeType() + "'";
        // 容器类型查询 起点
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
                .apply(barcodeType)
                .eq(Loc::getDeleted, 0)
                .eq(Loc::getStatus, 1)
                .eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type)
                .in(Loc::getAreaId, areaList)
                .orderByDesc(Loc::getId)
                .last("LIMIT 1"),
                false);

        if (Cools.isEmpty(loc)) {
            throw new CoolException("未查询到符合条件的托盘");
        }
        // 生成任务参数
        LocToTaskParams locToTaskParams = new LocToTaskParams();
        locToTaskParams.setType(Constants.TASK_TYPE_OUT_STOCK_EMPTY)
                .setSiteNo(basStation.getStationName())
                .setOrgLoc(loc.getId().toString());
        try {
            locItemService.generateTaskEmpty(TaskResouceType.TASK_RESOUCE_STOCK_TYPE.val, locToTaskParams, loginUserId,
                    containerWaveParam.getTaskNo());
        } catch (Exception e) {
            throw new CoolException(e.getMessage());
        }
        return R.ok();
    }

    private Boolean checkWaveComplete(TaskItem taskItem) {
        Wave wave = waveService.getById(taskItem.getSourceId());
        List<WkOrder> wkOrderList = asnOrderService
                .list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getWaveId, wave.getId()));
        return wkOrderList.stream().allMatch(
                item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }

    private Boolean checkOrderComplete(WkOrderItem orderItem) {
        List<WkOrderItem> wkOrderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, orderItem.getOrderCode()));
        return wkOrderItems.stream().allMatch(
                item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }
}