package com.vincent.rsf.server.manager.schedules;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.common.utils.QuantityUtils;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
import com.vincent.rsf.server.manager.service.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Component
public class PakinSchedules {

    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private WaitPakinItemService waitPakinItemService;
    @Autowired
    private WaitPakinLogService waitPakinLogService;
    @Autowired
    private WaitPakinItemLogService waitPakinItemLogService;
    @Autowired
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;

    /**
     * @param
     * @return
     * @author Ryan
     * @description 组拖历史档
     * @time 2025/3/29 12:36
     */
    @Scheduled(cron = "0/25 * * * * ?")
    @Transactional(rollbackFor = Exception.class)
    public void pakinLog() {
        List<WaitPakin> pakinIds = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>()
                .eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_TASK_DONE.val)
                .select(WaitPakin::getId));
        if (pakinIds.isEmpty()) {
            return;
        }
        List<Long> list = pakinIds.stream().map(WaitPakin::getId).collect(Collectors.toList());
        List<WaitPakin> pakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().in(WaitPakin::getId, list));
        if (pakins.isEmpty()) {
            throw new CoolException("组拖单为空！！");
        }
        pakins.forEach(pakin -> {
            WaitPakinLog log = new WaitPakinLog();
            BeanUtils.copyProperties(pakin, log);
            log.setPakinId(pakin.getId()).setIoStatus(PakinIOStatus.PAKIN_IO_STATUS_TASK_DONE.val);

            if (!waitPakinLogService.save(log)) {
                throw new CoolException("组托日志保存失败！！");
            }
            List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().in(WaitPakinItem::getPakinId, pakin.getId()));
            if (pakinItems.isEmpty()) {
                throw new CoolException("组拖明细为空！！");
            }
            // 过滤掉asnCode为null或空字符串的情况（无ASN单号的组托明细不需要处理单据状态）
            List<String> pkinItems = pakinItems.stream()
                    .map(WaitPakinItem::getAsnCode)
                    .filter(Objects::nonNull)
                    .filter(code -> !code.trim().isEmpty())
                    .distinct()
                    .collect(Collectors.toList());

            pkinItems.forEach(asnCode -> {
                List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, asnCode));
                if (orderItems.isEmpty()) {
                    throw new CoolException("数据错误，原单据不存在或已丢失！！");
                }
                Set<Long> orderIds = orderItems.stream().map(WkOrderItem::getOrderId).collect(Collectors.toSet());
                // 该订单下按明细汇总的已组托数量（所有组托档中 asnCode 对应的 anfme 按 asnItemId 汇总）
                List<WaitPakinItem> allPakinItemsForOrder = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                        .eq(WaitPakinItem::getAsnCode, asnCode));
                Map<Long, Double> palletizedByItemId = allPakinItemsForOrder.stream()
                        .filter(p -> p.getAsnItemId() != null)
                        .collect(Collectors.groupingBy(WaitPakinItem::getAsnItemId,
                                Collectors.summingDouble(p -> p.getAnfme() != null ? p.getAnfme() : 0.0)));

                orderIds.forEach(orderId -> {
                    WkOrder wkOrder = asnOrderService.getById(orderId);
                    if (Objects.isNull(wkOrder)) {
                        throw new CoolException("数据错误，原单据不存在或已丢失！！");
                    }
                    List<WkOrderItem> items = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orderId));
                    if (items.isEmpty()) {
                        return;
                    }
                    // 仅当全部明细均已组托完毕且已入库完成（qty>=计划），才将入库单置为已完成
                    boolean allLinesDone = items.stream().allMatch(oi -> {
                        double plan = oi.getAnfme() != null ? oi.getAnfme() : 0.0;
                        if (QuantityUtils.compare(plan, 0.0) <= 0) {
                            return true;
                        }
                        double palletized = palletizedByItemId.getOrDefault(oi.getId(), 0.0);
                        double received = oi.getQty() != null ? oi.getQty() : 0.0;
                        return QuantityUtils.compare(palletized, plan) >= 0 && QuantityUtils.compare(received, plan) >= 0;
                    });
                    if (allLinesDone && !asnOrderService.update(new LambdaUpdateWrapper<WkOrder>()
                            .eq(WkOrder::getId, orderId)
                            .set(WkOrder::getExceStatus, AsnExceStatus.ASN_EXCE_STATUS_TASK_DONE.val))) {
                        throw new CoolException("单据修改失败！！");
                    }
                });

//                Double sum = wkOrders.stream().mapToDouble(WkOrderItem::getAnfme).sum();
//                List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getAsnCode, item));
//                if (waitPakinItems.isEmpty()) {
//                    throw new CoolException("数据错误，组托明细不存在！！");
//                }
//                Double sum1 = waitPakinItems.stream().mapToDouble(WaitPakinItem::getAnfme).sum();
//                if (sum.compareTo(sum1) == 0) {
//                    if (!asnOrderService.update(new LambdaUpdateWrapper<WkOrder>()
//                            .eq(WkOrder::getCode, item)
//                            .set(WkOrder::getExceStatus, AsnExceStatus.ASN_EXCE_STATUS_TASK_DONE.val))) {
//                        throw new CoolException("单据修改失败！！");
//                    }
//                }
            });

            List<WaitPakinItemLog> itemLogs = new ArrayList<>();

            pakinItems.forEach(item -> {
                WaitPakinItemLog itemLog = new WaitPakinItemLog();
                BeanUtils.copyProperties(item, itemLog);
                itemLog.setPakinItemId(item.getId())
                        .setLogId(log.getId())
                        .setQty(item.getWorkQty())
                        .setWorkQty(0.0)
                        .setPakinId(item.getPakinId());
                itemLogs.add(itemLog);
            });

            if (!waitPakinItemLogService.saveBatch(itemLogs)) {
                throw new CoolException("历史明细档保存失败！！");
            }
        });

        if (!waitPakinService.removeByIds(list)) {
            throw new CoolException("原单据删除失败！！");
        }
        if (!waitPakinItemService.remove(new LambdaQueryWrapper<WaitPakinItem>().in(WaitPakinItem::getPakinId, list))) {
            throw new CoolException("原单据明细删除失败！！");
        }
    }
}