package com.ruoyi.production;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.production.mapper.ProductBomMapper;
import com.ruoyi.production.mapper.ProductStructureMapper;
import com.ruoyi.production.pojo.ProductBom;
import com.ruoyi.production.pojo.ProductStructure;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * BOM结构补齐测试。
 */
@SpringBootTest
public class BomStructureCopyTest {

    @Autowired
    private ProductModelMapper productModelMapper;

    @Autowired
    private ProductBomMapper productBomMapper;

    @Autowired
    private ProductStructureMapper productStructureMapper;

    @Test
    @Rollback(false)
    @Transactional(rollbackFor = Exception.class)
    public void copyAllProductBomStructureByProductId() {
        List<ProductModel> allProductModels = productModelMapper.selectList(
                Wrappers.<ProductModel>lambdaQuery()
                        .isNotNull(ProductModel::getProductId)
                        .orderByAsc(ProductModel::getProductId)
                        .orderByAsc(ProductModel::getId)
        );
        if (CollectionUtils.isEmpty(allProductModels)) {
            throw new IllegalStateException("未查询到任何产品规格");
        }

        Map<Long, List<ProductModel>> productModelGroups = allProductModels.stream()
                .collect(Collectors.groupingBy(ProductModel::getProductId, LinkedHashMap::new, Collectors.toList()));

        List<CopySummary> summaries = new ArrayList<>();
        for (Map.Entry<Long, List<ProductModel>> entry : productModelGroups.entrySet()) {
            CopySummary summary = copyBomStructure(entry.getKey(), entry.getValue());
            summaries.add(summary);
            printProductSummary(summary);
        }

        printBatchSummary(summaries);
    }

    private CopySummary copyBomStructure(Long productId, List<ProductModel> productModels) {
        if (CollectionUtils.isEmpty(productModels)) {
            return CopySummary.skipped(productId, 0, 0, "未查询到产品大类对应的规格");
        }

        Map<Long, ProductModel> productModelMap = productModels.stream()
                .collect(Collectors.toMap(ProductModel::getId, item -> item, (left, right) -> left, LinkedHashMap::new));
        List<Long> productModelIds = new ArrayList<>(productModelMap.keySet());

        List<ProductBom> bomList = productBomMapper.selectList(
                Wrappers.<ProductBom>lambdaQuery()
                        .in(ProductBom::getProductModelId, productModelIds)
                        .orderByAsc(ProductBom::getId)
        );
        if (CollectionUtils.isEmpty(bomList)) {
            return CopySummary.skipped(productId, productModels.size(), 0, "未查询到产品大类对应的BOM");
        }

        Map<Integer, List<ProductStructure>> structureMap = loadStructureMap(bomList);
        ProductBom templateBom = findTemplateBomOrNull(bomList, structureMap);
        if (templateBom == null) {
            return CopySummary.skipped(productId, productModels.size(), bomList.size(), "当前产品大类下没有可作为模板的完整BOM结构");
        }

        List<ProductStructure> templateStructures = structureMap.get(templateBom.getId());
        ProductStructure templateRoot = requireSingleRoot(templateBom, templateStructures);
        List<ProductStructure> templateChildren = templateStructures.stream()
                .filter(item -> !isRoot(item))
                .sorted(Comparator.comparing(ProductStructure::getId))
                .collect(Collectors.toList());
        if (templateChildren.isEmpty()) {
            throw new IllegalStateException("模板BOM没有可复制的子结构，bomId=" + templateBom.getId());
        }

        int copiedBomCount = 0;
        int skippedBomCount = 0;
        int insertedStructureCount = 0;

        for (ProductBom targetBom : bomList) {
            if (Objects.equals(templateBom.getId(), targetBom.getId())) {
                skippedBomCount++;
                continue;
            }

            List<ProductStructure> targetStructures = structureMap.getOrDefault(targetBom.getId(), Collections.emptyList());
            if (hasChildNodes(targetStructures)) {
                skippedBomCount++;
                continue;
            }

            ProductModel targetModel = productModelMap.get(targetBom.getProductModelId());
            if (targetModel == null) {
                throw new IllegalStateException("BOM关联的规格不属于当前产品大类，bomId=" + targetBom.getId()
                        + "，productModelId=" + targetBom.getProductModelId());
            }

            RootNode targetRoot = ensureTargetRoot(targetBom, targetModel, templateRoot, targetStructures);
            int copiedChildren = copyTemplateChildren(templateBom, templateRoot, templateChildren, targetBom, targetRoot.getNode());

            copiedBomCount++;
            insertedStructureCount += copiedChildren + (targetRoot.isInserted() ? 1 : 0);
        }

        return CopySummary.copied(
                productId,
                productModels.size(),
                templateBom.getId(),
                templateBom.getBomNo(),
                bomList.size(),
                copiedBomCount,
                skippedBomCount,
                insertedStructureCount
        );
    }

    private Map<Integer, List<ProductStructure>> loadStructureMap(List<ProductBom> bomList) {
        List<Integer> bomIds = bomList.stream()
                .map(ProductBom::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        if (bomIds.isEmpty()) {
            return Collections.emptyMap();
        }

        List<ProductStructure> structures = productStructureMapper.selectList(
                Wrappers.<ProductStructure>lambdaQuery()
                        .in(ProductStructure::getBomId, bomIds)
                        .orderByAsc(ProductStructure::getId)
        );

        Map<Integer, List<ProductStructure>> structureMap = new HashMap<>();
        for (ProductStructure structure : structures) {
            structureMap.computeIfAbsent(structure.getBomId(), key -> new ArrayList<>()).add(structure);
        }
        return structureMap;
    }

    private ProductBom findTemplateBomOrNull(List<ProductBom> bomList, Map<Integer, List<ProductStructure>> structureMap) {
        return bomList.stream()
                .filter(item -> hasChildNodes(structureMap.getOrDefault(item.getId(), Collections.emptyList())))
                .max(Comparator.comparingInt(item -> childNodeCount(structureMap.getOrDefault(item.getId(), Collections.emptyList()))))
                .orElse(null);
    }

    private int childNodeCount(List<ProductStructure> structures) {
        if (structures == null) {
            return 0;
        }
        int count = 0;
        for (ProductStructure structure : structures) {
            if (!isRoot(structure)) {
                count++;
            }
        }
        return count;
    }

    private boolean hasChildNodes(List<ProductStructure> structures) {
        return childNodeCount(structures) > 0;
    }

    private ProductStructure requireSingleRoot(ProductBom bom, List<ProductStructure> structures) {
        List<ProductStructure> roots = findRoots(structures);
        if (roots.size() != 1) {
            throw new IllegalStateException("BOM根节点数量异常，bomId=" + bom.getId() + "，rootCount=" + roots.size());
        }
        return roots.get(0);
    }

    private RootNode ensureTargetRoot(ProductBom targetBom,
                                      ProductModel targetModel,
                                      ProductStructure templateRoot,
                                      List<ProductStructure> targetStructures) {
        List<ProductStructure> roots = findRoots(targetStructures);
        if (roots.size() > 1) {
            throw new IllegalStateException("目标BOM根节点数量异常，bomId=" + targetBom.getId() + "，rootCount=" + roots.size());
        }
        if (roots.size() == 1) {
            return new RootNode(roots.get(0), false);
        }

        ProductStructure targetRoot = new ProductStructure();
        targetRoot.setParentId(null);
        targetRoot.setBomId(targetBom.getId());
        targetRoot.setProductModelId(targetBom.getProductModelId());
        targetRoot.setProcessId(templateRoot.getProcessId());
        targetRoot.setUnitQuantity(templateRoot.getUnitQuantity() == null ? BigDecimal.ONE : templateRoot.getUnitQuantity());
        targetRoot.setDemandedQuantity(templateRoot.getDemandedQuantity());
        targetRoot.setUnit(targetModel.getUnit());
        targetRoot.setTenantId(firstNotNull(targetBom.getTenantId(), targetModel.getTenantId(), templateRoot.getTenantId()));
        productStructureMapper.insert(targetRoot);
        return new RootNode(targetRoot, true);
    }

    private int copyTemplateChildren(ProductBom templateBom,
                                     ProductStructure templateRoot,
                                     List<ProductStructure> templateChildren,
                                     ProductBom targetBom,
                                     ProductStructure targetRoot) {
        Map<Long, Long> idMapping = new HashMap<>();
        idMapping.put(templateRoot.getId(), targetRoot.getId());

        List<NodePair> insertedNodes = new ArrayList<>();
        for (ProductStructure sourceNode : templateChildren) {
            ProductStructure copiedNode = new ProductStructure();
            copiedNode.setParentId(null);
            copiedNode.setProductModelId(sourceNode.getProductModelId());
            copiedNode.setProcessId(sourceNode.getProcessId());
            copiedNode.setUnitQuantity(sourceNode.getUnitQuantity());
            copiedNode.setDemandedQuantity(sourceNode.getDemandedQuantity());
            copiedNode.setUnit(sourceNode.getUnit());
            copiedNode.setTenantId(firstNotNull(targetBom.getTenantId(), sourceNode.getTenantId()));
            copiedNode.setBomId(targetBom.getId());

            productStructureMapper.insert(copiedNode);
            idMapping.put(sourceNode.getId(), copiedNode.getId());
            insertedNodes.add(new NodePair(sourceNode, copiedNode));
        }

        for (NodePair insertedNode : insertedNodes) {
            Long sourceParentId = insertedNode.getSourceNode().getParentId();
            Long newParentId = idMapping.get(sourceParentId);
            if (newParentId == null) {
                throw new IllegalStateException("模板BOM存在无法映射的父节点，templateBomId=" + templateBom.getId()
                        + "，sourceNodeId=" + insertedNode.getSourceNode().getId()
                        + "，sourceParentId=" + sourceParentId);
            }

            ProductStructure copiedNode = insertedNode.getCopiedNode();
            copiedNode.setParentId(newParentId);
            productStructureMapper.updateById(copiedNode);
        }

        return insertedNodes.size();
    }

    private List<ProductStructure> findRoots(List<ProductStructure> structures) {
        if (structures == null) {
            return Collections.emptyList();
        }
        return structures.stream()
                .filter(this::isRoot)
                .collect(Collectors.toList());
    }

    private boolean isRoot(ProductStructure structure) {
        return structure.getParentId() == null || Long.valueOf(0L).equals(structure.getParentId());
    }

    private Long firstNotNull(Long first, Long second) {
        return first != null ? first : second;
    }

    private Long firstNotNull(Long first, Long second, Long third) {
        if (first != null) {
            return first;
        }
        return second != null ? second : third;
    }

    private void printProductSummary(CopySummary summary) {
        if (summary.isProductSkipped()) {
            System.out.printf(
                    "跳过产品分类：productId=%s，规格数=%s，BOM总数=%s，原因=%s%n",
                    summary.getProductId(),
                    summary.getProductModelCount(),
                    summary.getTotalBomCount(),
                    summary.getSkipReason()
            );
            return;
        }

        System.out.printf(
                "处理产品分类：productId=%s，模板BOM=%s(%s)，规格数=%s，BOM总数=%s，已补齐BOM=%s，跳过BOM=%s，新增结构节点=%s%n",
                summary.getProductId(),
                summary.getTemplateBomNo(),
                summary.getTemplateBomId(),
                summary.getProductModelCount(),
                summary.getTotalBomCount(),
                summary.getCopiedBomCount(),
                summary.getSkippedBomCount(),
                summary.getInsertedStructureCount()
        );
    }

    private void printBatchSummary(List<CopySummary> summaries) {
        int productCount = summaries.size();
        int skippedProductCount = 0;
        int totalBomCount = 0;
        int copiedBomCount = 0;
        int skippedBomCount = 0;
        int insertedStructureCount = 0;

        for (CopySummary summary : summaries) {
            if (summary.isProductSkipped()) {
                skippedProductCount++;
            }
            totalBomCount += summary.getTotalBomCount();
            copiedBomCount += summary.getCopiedBomCount();
            skippedBomCount += summary.getSkippedBomCount();
            insertedStructureCount += summary.getInsertedStructureCount();
        }

        System.out.printf(
                "BOM结构批量复制完成：产品分类数=%s，已处理分类=%s，跳过分类=%s，BOM总数=%s，已补齐BOM=%s，跳过BOM=%s，新增结构节点=%s%n",
                productCount,
                productCount - skippedProductCount,
                skippedProductCount,
                totalBomCount,
                copiedBomCount,
                skippedBomCount,
                insertedStructureCount
        );
    }

    private static class RootNode {
        private final ProductStructure node;
        private final boolean inserted;

        private RootNode(ProductStructure node, boolean inserted) {
            this.node = node;
            this.inserted = inserted;
        }

        private ProductStructure getNode() {
            return node;
        }

        private boolean isInserted() {
            return inserted;
        }
    }

    private static class NodePair {
        private final ProductStructure sourceNode;
        private final ProductStructure copiedNode;

        private NodePair(ProductStructure sourceNode, ProductStructure copiedNode) {
            this.sourceNode = sourceNode;
            this.copiedNode = copiedNode;
        }

        private ProductStructure getSourceNode() {
            return sourceNode;
        }

        private ProductStructure getCopiedNode() {
            return copiedNode;
        }
    }

    private static class CopySummary {
        private final Long productId;
        private final int productModelCount;
        private final Integer templateBomId;
        private final String templateBomNo;
        private final int totalBomCount;
        private final int copiedBomCount;
        private final int skippedBomCount;
        private final int insertedStructureCount;
        private final String skipReason;

        private CopySummary(Long productId,
                            int productModelCount,
                            Integer templateBomId,
                            String templateBomNo,
                            int totalBomCount,
                            int copiedBomCount,
                            int skippedBomCount,
                            int insertedStructureCount,
                            String skipReason) {
            this.productId = productId;
            this.productModelCount = productModelCount;
            this.templateBomId = templateBomId;
            this.templateBomNo = templateBomNo;
            this.totalBomCount = totalBomCount;
            this.copiedBomCount = copiedBomCount;
            this.skippedBomCount = skippedBomCount;
            this.insertedStructureCount = insertedStructureCount;
            this.skipReason = skipReason;
        }

        private static CopySummary copied(Long productId,
                                          int productModelCount,
                                          Integer templateBomId,
                                          String templateBomNo,
                                          int totalBomCount,
                                          int copiedBomCount,
                                          int skippedBomCount,
                                          int insertedStructureCount) {
            return new CopySummary(
                    productId,
                    productModelCount,
                    templateBomId,
                    templateBomNo,
                    totalBomCount,
                    copiedBomCount,
                    skippedBomCount,
                    insertedStructureCount,
                    null
            );
        }

        private static CopySummary skipped(Long productId, int productModelCount, int totalBomCount, String skipReason) {
            return new CopySummary(
                    productId,
                    productModelCount,
                    null,
                    null,
                    totalBomCount,
                    0,
                    totalBomCount,
                    0,
                    skipReason
            );
        }

        private Long getProductId() {
            return productId;
        }

        private int getProductModelCount() {
            return productModelCount;
        }

        private Integer getTemplateBomId() {
            return templateBomId;
        }

        private String getTemplateBomNo() {
            return templateBomNo;
        }

        private int getTotalBomCount() {
            return totalBomCount;
        }

        private int getCopiedBomCount() {
            return copiedBomCount;
        }

        private int getSkippedBomCount() {
            return skippedBomCount;
        }

        private int getInsertedStructureCount() {
            return insertedStructureCount;
        }

        private String getSkipReason() {
            return skipReason;
        }

        private boolean isProductSkipped() {
            return skipReason != null;
        }
    }
}