package com.ruoyi.quality.service.impl;

import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.quality.dto.QualityTraceBatchOptionVo;
import com.ruoyi.quality.dto.QualityTraceChainVo;
import com.ruoyi.quality.dto.QualityTraceFinishedBatchVo;
import com.ruoyi.quality.dto.QualityTraceForwardExportVo;
import com.ruoyi.quality.dto.QualityTraceForwardVo;
import com.ruoyi.quality.dto.QualityTraceInputVo;
import com.ruoyi.quality.dto.QualityTraceInspectVo;
import com.ruoyi.quality.dto.QualityTraceMaterialBatchVo;
import com.ruoyi.quality.dto.QualityTraceOutboundVo;
import com.ruoyi.quality.dto.QualityTracePickVo;
import com.ruoyi.quality.dto.QualityTraceReportVo;
import com.ruoyi.quality.dto.QualityTraceReverseExportVo;
import com.ruoyi.quality.dto.QualityTraceReverseOrderVo;
import com.ruoyi.quality.dto.QualityTraceReverseVo;
import com.ruoyi.quality.dto.QualityTraceUnqualifiedVo;
import com.ruoyi.quality.mapper.QualityTraceMapper;
import com.ruoyi.quality.service.QualityTraceService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class QualityTraceServiceImpl implements QualityTraceService {

    private final QualityTraceMapper qualityTraceMapper;

    @Override
    public QualityTraceForwardVo forward(String batchNo) {
        String no = requireBatchNo(batchNo);
        QualityTraceForwardVo result = new QualityTraceForwardVo();
        result.setBatchNo(no);

        //1.批号命中的生产入库记录（报工入库2 / 质检合格入库6）
        List<QualityTraceFinishedBatchVo> inbound = qualityTraceMapper.listInboundByFinishedBatch(no);
        if (inbound.isEmpty()) {
            result.setOutbounds(qualityTraceMapper.listOutboundByBatch(no));
            return result;
        }
        Map<Long, List<QualityTraceFinishedBatchVo>> inboundByOrder = inbound.stream()
                .filter(b -> b.getProductionOrderId() != null)
                .collect(Collectors.groupingBy(QualityTraceFinishedBatchVo::getProductionOrderId,
                        LinkedHashMap::new, Collectors.toList()));
        List<Long> mainIds = distinct(inbound.stream().map(QualityTraceFinishedBatchVo::getProductMainId)
                .filter(Objects::nonNull).collect(Collectors.toList()));

        //2.报工节点（含订单信息）
        List<QualityTraceReportVo> reports = mainIds.isEmpty()
                ? new ArrayList<>() : qualityTraceMapper.listReportsByMainIds(mainIds);
        Map<Long, List<QualityTraceReportVo>> reportsByOrder = reports.stream()
                .filter(r -> r.getProductionOrderId() != null)
                .collect(Collectors.groupingBy(QualityTraceReportVo::getProductionOrderId,
                        LinkedHashMap::new, Collectors.toList()));
        Map<Long, Long> orderOfMain = new LinkedHashMap<>();
        reports.forEach(r -> orderOfMain.putIfAbsent(r.getProductMainId(), r.getProductionOrderId()));

        //3.投入物料（按报工单）
        List<QualityTraceInputVo> inputs = mainIds.isEmpty()
                ? new ArrayList<>() : qualityTraceMapper.listInputsByMainIds(mainIds);

        //4.领料批次（按订单），并用原料批号回溯供应商/采购/检验
        List<Long> orderIds = new ArrayList<>(inboundByOrder.keySet());
        List<QualityTracePickVo> picks = orderIds.isEmpty()
                ? new ArrayList<>() : qualityTraceMapper.listPicksByOrderIds(orderIds);
        fillPickSource(picks);
        Map<Long, List<QualityTracePickVo>> picksByOrder = picks.stream()
                .filter(p -> p.getProductionOrderId() != null)
                .collect(Collectors.groupingBy(QualityTracePickVo::getProductionOrderId,
                        LinkedHashMap::new, Collectors.toList()));

        //5.检验单与不合格处理
        List<QualityTraceInspectVo> inspects = mainIds.isEmpty()
                ? new ArrayList<>() : qualityTraceMapper.listInspectsByMainIds(mainIds);
        List<Long> inspectIds = distinct(inspects.stream().map(QualityTraceInspectVo::getInspectId)
                .filter(Objects::nonNull).collect(Collectors.toList()));
        List<QualityTraceUnqualifiedVo> unqualified = inspectIds.isEmpty()
                ? new ArrayList<>() : qualityTraceMapper.listUnqualifiedByInspectIds(inspectIds);
        Map<Long, List<QualityTraceUnqualifiedVo>> unqualifiedByInspect = unqualified.stream()
                .filter(u -> u.getInspectId() != null)
                .collect(Collectors.groupingBy(QualityTraceUnqualifiedVo::getInspectId));
        inspects.forEach(ins -> ins.setUnqualifiedList(
                unqualifiedByInspect.getOrDefault(ins.getInspectId(), new ArrayList<>())));
        Map<Long, List<QualityTraceInspectVo>> inspectsByOrder = inspects.stream()
                .filter(i -> i.getProductMainId() != null && orderOfMain.get(i.getProductMainId()) != null)
                .collect(Collectors.groupingBy(i -> orderOfMain.get(i.getProductMainId()),
                        LinkedHashMap::new, Collectors.toList()));

        Set<Long> chainOrderIds = new LinkedHashSet<>(inboundByOrder.keySet());
        chainOrderIds.addAll(reportsByOrder.keySet());
        for (Long orderId : chainOrderIds) {
            QualityTraceChainVo chain = new QualityTraceChainVo();
            chain.setProductionOrderId(orderId);
            List<QualityTraceReportVo> orderReports =
                    reportsByOrder.getOrDefault(orderId, new ArrayList<>());
            if (!orderReports.isEmpty()) {
                QualityTraceReportVo first = orderReports.get(0);
                chain.setNpsNo(first.getNpsNo());
                chain.setFinishedProduct(first.getFinishedProduct());
                chain.setUnit(first.getUnit());
                chain.setPlanQty(first.getPlanQty());
                chain.setCompleteQty(first.getCompleteQty());
                chain.setOrderStatus(first.getOrderStatus());
                chain.setOrderCreateTime(first.getOrderCreateTime());
            }
            chain.setBatches(inboundByOrder.getOrDefault(orderId, new ArrayList<>()));
            chain.setReports(orderReports);
            Set<Long> orderMainIds = orderReports.stream()
                    .map(QualityTraceReportVo::getProductMainId).filter(Objects::nonNull)
                    .collect(Collectors.toCollection(LinkedHashSet::new));
            chain.setInputs(inputs.stream()
                    .filter(i -> i.getProductMainId() != null && orderMainIds.contains(i.getProductMainId()))
                    .collect(Collectors.toList()));
            chain.setPicks(picksByOrder.getOrDefault(orderId, new ArrayList<>()));
            chain.setInspects(inspectsByOrder.getOrDefault(orderId, new ArrayList<>()));
            chain.setUnqualifiedList(chain.getInspects().stream()
                    .flatMap(i -> i.getUnqualifiedList().stream()).collect(Collectors.toList()));
            result.getChains().add(chain);
        }
        result.setOutbounds(qualityTraceMapper.listOutboundByBatch(no));
        return result;
    }

    @Override
    public QualityTraceReverseVo reverse(String batchNo) {
        String no = requireBatchNo(batchNo);
        QualityTraceReverseVo result = new QualityTraceReverseVo();
        result.setBatchNo(no);

        //1.批号入库/采购/检验来源
        List<QualityTraceMaterialBatchVo> materialInfo =
                qualityTraceMapper.listMaterialBatchInfoByBatches(Collections.singletonList(no));
        if (!materialInfo.isEmpty()) {
            result.setMaterial(materialInfo.get(0));
        }

        //2.使用该批号的领料明细
        List<QualityTracePickVo> picks = qualityTraceMapper.listPicksByBatchNo(no);
        if (picks.isEmpty()) {
            return result;
        }
        fillPickSource(picks);
        Map<Long, List<QualityTracePickVo>> picksByOrder = picks.stream()
                .filter(p -> p.getProductionOrderId() != null)
                .collect(Collectors.groupingBy(QualityTracePickVo::getProductionOrderId,
                        LinkedHashMap::new, Collectors.toList()));
        List<Long> orderIds = new ArrayList<>(picksByOrder.keySet());

        //3.订单报工节点与产出成品批号
        List<QualityTraceReportVo> reports = qualityTraceMapper.listReportsByOrderIds(orderIds);
        Map<Long, List<QualityTraceReportVo>> reportsByOrder = reports.stream()
                .filter(r -> r.getProductionOrderId() != null)
                .collect(Collectors.groupingBy(QualityTraceReportVo::getProductionOrderId,
                        LinkedHashMap::new, Collectors.toList()));
        Map<Long, List<QualityTraceFinishedBatchVo>> batchesByOrder =
                qualityTraceMapper.listFinishedBatchesByOrderIds(orderIds).stream()
                        .filter(b -> b.getProductionOrderId() != null)
                        .collect(Collectors.groupingBy(QualityTraceFinishedBatchVo::getProductionOrderId,
                                LinkedHashMap::new, Collectors.toList()));

        for (Long orderId : orderIds) {
            QualityTraceReverseOrderVo orderVo = new QualityTraceReverseOrderVo();
            orderVo.setProductionOrderId(orderId);
            List<QualityTraceReportVo> orderReports =
                    reportsByOrder.getOrDefault(orderId, new ArrayList<>());
            if (!orderReports.isEmpty()) {
                QualityTraceReportVo first = orderReports.get(0);
                orderVo.setNpsNo(first.getNpsNo());
                orderVo.setFinishedProduct(first.getFinishedProduct());
                orderVo.setUnit(first.getUnit());
                orderVo.setPlanQty(first.getPlanQty());
                orderVo.setCompleteQty(first.getCompleteQty());
                orderVo.setOrderStatus(first.getOrderStatus());
                orderVo.setOrderCreateTime(first.getOrderCreateTime());
            }
            List<QualityTracePickVo> orderPicks =
                    picksByOrder.getOrDefault(orderId, new ArrayList<>());
            orderVo.setPickedQty(orderPicks.stream().map(p -> nvl(p.getQuantity()))
                    .reduce(BigDecimal.ZERO, BigDecimal::add));
            orderVo.setPicks(orderPicks);
            orderVo.setReports(orderReports);
            orderVo.setFinishedBatches(batchesByOrder.getOrDefault(orderId, new ArrayList<>()));
            result.getOrders().add(orderVo);
        }
        return result;
    }

    @Override
    public List<QualityTraceForwardExportVo> forwardExportRows(String batchNo) {
        QualityTraceForwardVo trace = forward(batchNo);
        List<QualityTraceForwardExportVo> rows = new ArrayList<>();
        for (QualityTraceChainVo chain : trace.getChains()) {
            String operations = chain.getReports().stream()
                    .map(r -> StringUtils.isBlank(r.getOperationName()) ? r.getWorkOrderNo() : r.getOperationName())
                    .filter(StringUtils::isNotBlank).distinct().collect(Collectors.joining("/"));
            String inspectResults = chain.getInspects().stream()
                    .map(i -> (StringUtils.isBlank(i.getInspectTypeName()) ? "" : i.getInspectTypeName() + ":")
                            + (StringUtils.isBlank(i.getCheckResult()) ? "未提交" : i.getCheckResult()))
                    .collect(Collectors.joining("/"));
            String unqualifiedResults = chain.getUnqualifiedList().stream()
                    .map(u -> (StringUtils.isBlank(u.getDealResult()) ? "待处理" : u.getDealResult())
                            + "x" + nvl(u.getQuantity()).stripTrailingZeros().toPlainString())
                    .collect(Collectors.joining("/"));
            if (chain.getPicks().isEmpty()) {
                QualityTraceForwardExportVo row = newForwardRow(trace.getBatchNo(), chain, operations,
                        inspectResults, unqualifiedResults);
                rows.add(row);
                continue;
            }
            for (QualityTracePickVo pick : chain.getPicks()) {
                QualityTraceForwardExportVo row = newForwardRow(trace.getBatchNo(), chain, operations,
                        inspectResults, unqualifiedResults);
                row.setMaterialBatchNo(pick.getBatchNo());
                row.setMaterialName(pick.getMaterialName());
                row.setMaterialModel(pick.getMaterialModel());
                row.setPickQty(pick.getQuantity());
                row.setSupplierName(pick.getSupplierName());
                row.setMaterialCheckResult(pick.getCheckResult());
                rows.add(row);
            }
        }
        return rows;
    }

    @Override
    public List<QualityTraceReverseExportVo> reverseExportRows(String batchNo) {
        QualityTraceReverseVo trace = reverse(batchNo);
        List<QualityTraceReverseExportVo> rows = new ArrayList<>();
        QualityTraceMaterialBatchVo material = trace.getMaterial();
        if (trace.getOrders().isEmpty()) {
            rows.add(newReverseRow(trace, material, null, null));
            return rows;
        }
        for (QualityTraceReverseOrderVo order : trace.getOrders()) {
            String batchNos = order.getFinishedBatches().stream()
                    .map(QualityTraceFinishedBatchVo::getBatchNo)
                    .filter(StringUtils::isNotBlank).distinct().collect(Collectors.joining("/"));
            rows.add(newReverseRow(trace, material, order, batchNos));
        }
        return rows;
    }

    private QualityTraceForwardExportVo newForwardRow(String batchNo, QualityTraceChainVo chain,
                                                      String operations, String inspectResults,
                                                      String unqualifiedResults) {
        QualityTraceForwardExportVo row = new QualityTraceForwardExportVo();
        row.setBatchNo(batchNo);
        row.setNpsNo(chain.getNpsNo());
        row.setFinishedProduct(chain.getFinishedProduct());
        row.setCompleteQty(chain.getCompleteQty());
        row.setOperations(operations);
        row.setInspectResults(inspectResults);
        row.setUnqualifiedResults(unqualifiedResults);
        return row;
    }

    private QualityTraceReverseExportVo newReverseRow(QualityTraceReverseVo trace,
                                                      QualityTraceMaterialBatchVo material,
                                                      QualityTraceReverseOrderVo order, String batchNos) {
        QualityTraceReverseExportVo row = new QualityTraceReverseExportVo();
        row.setBatchNo(trace.getBatchNo());
        if (material != null) {
            row.setMaterialName(material.getMaterialName());
            row.setMaterialModel(material.getMaterialModel());
            row.setUnit(material.getUnit());
            row.setSupplierName(material.getSupplierName());
            row.setContractNo(material.getContractNo());
            row.setEntryDate(material.getEntryDate());
            row.setMaterialCheckResult(material.getCheckResult());
        }
        if (order != null) {
            row.setNpsNo(order.getNpsNo());
            row.setFinishedProduct(order.getFinishedProduct());
            row.setPickedQty(order.getPickedQty());
            row.setFinishedBatchNos(batchNos);
        }
        return row;
    }

    @Override
    public List<QualityTraceBatchOptionVo> batchOptions(String type, String keyword, Integer limit) {
        String queryType = "material".equals(type) ? "material" : "finished";
        int size = (limit == null || limit <= 0 || limit > 200) ? 50 : limit;
        return qualityTraceMapper.listBatchOptions(queryType, StringUtils.isBlank(keyword) ? null : keyword.trim(), size);
    }

    /** 用原料批号回溯入库来源，补全领料行的供应商/合同/检验结论 */
    private void fillPickSource(List<QualityTracePickVo> picks) {
        List<String> batchNos = distinct(picks.stream().map(QualityTracePickVo::getBatchNo)
                .filter(StringUtils::isNotBlank).collect(Collectors.toList()));
        if (batchNos.isEmpty()) {
            return;
        }
        Map<String, QualityTraceMaterialBatchVo> infoByBatch = new LinkedHashMap<>();
        for (QualityTraceMaterialBatchVo info : qualityTraceMapper.listMaterialBatchInfoByBatches(batchNos)) {
            if (StringUtils.isNotBlank(info.getBatchNo())) {
                infoByBatch.putIfAbsent(info.getBatchNo(), info);
            }
        }
        for (QualityTracePickVo pick : picks) {
            QualityTraceMaterialBatchVo info = infoByBatch.get(pick.getBatchNo());
            if (info == null) {
                continue;
            }
            pick.setSupplierName(info.getSupplierName());
            pick.setContractNo(info.getContractNo());
            pick.setCheckResult(info.getCheckResult());
            if (StringUtils.isBlank(pick.getMaterialName())) {
                pick.setMaterialName(info.getMaterialName());
            }
            if (StringUtils.isBlank(pick.getMaterialModel())) {
                pick.setMaterialModel(info.getMaterialModel());
            }
            if (StringUtils.isBlank(pick.getUnit())) {
                pick.setUnit(info.getUnit());
            }
        }
    }

    private String requireBatchNo(String batchNo) {
        if (StringUtils.isBlank(batchNo)) {
            throw new ServiceException("批号不能为空");
        }
        return batchNo.trim();
    }

    private <T> List<T> distinct(List<T> ids) {
        return ids.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());
    }

    private BigDecimal nvl(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }
}