package com.ruoyi.quality.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.common.enums.RawMaterialCheckResult;
import com.ruoyi.common.enums.RawMaterialCheckType;
import com.ruoyi.common.enums.RawMaterialInspectState;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.inspectiontask.mapper.QualityInspectItemMapper;
import com.ruoyi.inspectiontask.pojo.QualityInspectItem;
import com.ruoyi.quality.dto.RawMaterialDto;
import com.ruoyi.quality.mapper.RawMaterialMapper;
import com.ruoyi.quality.pojo.RawMaterial;
import com.ruoyi.quality.pojo.RawMaterialQualityInspectItem;
import com.ruoyi.quality.service.RawMaterialQualityInspectItemService;
import com.ruoyi.quality.service.RawMaterialService;
import lombok.AllArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
 * @since 2026-03-13 02:44:09
 */
@AllArgsConstructor
@Service
public class RawMaterialServiceImpl extends ServiceImpl<RawMaterialMapper, RawMaterial> implements RawMaterialService {
    private RawMaterialMapper rawMaterialMapper;

    private RawMaterialQualityInspectItemService rawMaterialQualityInspectItemService;

    private QualityInspectItemMapper qualityInspectItemMapper;

    private ProductModelMapper productModelMapper;

    private ProductMapper productMapper;

    @Override
    public IPage<RawMaterialDto> listPage(Page page, RawMaterialDto rawMaterialDto) {
        IPage<RawMaterialDto> pageRes = rawMaterialMapper.listPage(page, rawMaterialDto);
        List<RawMaterialDto> rawMaterials = pageRes.getRecords();
        Map<Long, ProductModel> productModelMap = new HashMap<>();
        Map<Long, Product> productMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(rawMaterials)) {
            List<Long> productModelIds = rawMaterials.stream().map(RawMaterialDto::getProductModelId).collect(Collectors.toList());
            List<ProductModel> productModels = productModelMapper.selectList(new LambdaQueryWrapper<ProductModel>()
                    .in(ProductModel::getId, productModelIds));
            productModelMap = productModels.stream().collect(Collectors.toMap(ProductModel::getId, productModel -> productModel));
            List<Long> productIds = productModels.stream().map(ProductModel::getProductId).collect(Collectors.toList());
            List<Product> products = productMapper.selectList(new LambdaQueryWrapper<Product>()
                    .in(Product::getId, productIds));
            productMap = products.stream().collect(Collectors.toMap(Product::getId, product -> product));
        }

        for (RawMaterialDto rawMaterial : pageRes.getRecords()) {
            rawMaterial.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()) == null ? "" : RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());
            rawMaterial.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()) == null ? "" : RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());
            rawMaterial.setInspectStateText(RawMaterialInspectState.fromValue(rawMaterial.getInspectState()) == null ? "" : RawMaterialInspectState.fromValue(rawMaterial.getInspectState()).getValue());
            rawMaterial.setProductName(productMap.get(productModelMap.get(rawMaterial.getProductModelId()).getProductId()).getProductName());
            rawMaterial.setModel(productModelMap.get(rawMaterial.getProductModelId()).getModel());
            rawMaterial.setProductId(productModelMap.get(rawMaterial.getProductModelId()).getProductId());
        }
        return pageRes;
    }

    @Override
    public RawMaterialDto detail(Long id) {
        RawMaterial rawMaterial = rawMaterialMapper.selectById(id);
        RawMaterialDto rawMaterialDto = new RawMaterialDto();
        BeanUtils.copyBeanProp(rawMaterialDto, rawMaterial);
        // 获取检测项关联关系
        List<RawMaterialQualityInspectItem> rawQualityList = rawMaterialQualityInspectItemService.list(new LambdaQueryWrapper<RawMaterialQualityInspectItem>()
                .eq(RawMaterialQualityInspectItem::getRawMaterialId, id));
        Map<Long, RawMaterialQualityInspectItem> map = rawQualityList.stream().collect(Collectors.toMap(RawMaterialQualityInspectItem::getQualityInspectItemId, qualityInspectItem -> qualityInspectItem));
        // 获取检验项目
        List<QualityInspectItem> qualityInspectItems = qualityInspectItemMapper.selectList(new LambdaQueryWrapper<QualityInspectItem>()
                .in(QualityInspectItem::getId, rawQualityList.stream().map(RawMaterialQualityInspectItem::getQualityInspectItemId).collect(Collectors.toList())));
        // 替换化验值
        qualityInspectItems.forEach(qualityInspectItem -> {
            qualityInspectItem.setTestValue(map.get(qualityInspectItem.getId()).getTestValue());
        });
        rawMaterialDto.setQualityInspectItem(qualityInspectItems);

        // 查询产品id
        ProductModel productModel = productModelMapper.selectById(rawMaterialDto.getProductModelId());
        rawMaterialDto.setProductId(productModel.getProductId());
        rawMaterialDto.setUnit(productModel.getUnit());
        return rawMaterialDto;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean add(RawMaterialDto rawMaterialDto) {
        rawMaterialDto.setInspectState(RawMaterialInspectState.RawMaterialInspectStateUnsubmitted.getCode());
        // 新增原料
        int i = rawMaterialMapper.insert(rawMaterialDto);
        // 新增检测项关联关系
        if (CollectionUtils.isNotEmpty(rawMaterialDto.getQualityInspectItem())) {
            List<RawMaterialQualityInspectItem> rawMaterialQualityInspectItems = rawMaterialDto.getQualityInspectItem().stream()
                    .map(qualityInspectItem -> {
                        RawMaterialQualityInspectItem item = new RawMaterialQualityInspectItem();
                        item.setRawMaterialId(rawMaterialDto.getId());
                        item.setQualityInspectItemId(qualityInspectItem.getId());
                        item.setTestValue(qualityInspectItem.getTestValue());
                        return item;
                    })
                    .collect(Collectors.toList());
            rawMaterialQualityInspectItemService.saveBatch(rawMaterialQualityInspectItems);
        }
        return i > 0;
    }

    @Override
    public boolean update(RawMaterialDto rawMaterialDto) {
        // 删除所有关联项目重新加载
        rawMaterialQualityInspectItemService.remove(new LambdaQueryWrapper<RawMaterialQualityInspectItem>()
                .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialDto.getId()));
        int i = rawMaterialMapper.updateById(rawMaterialDto);
        // 新增检测项关联关系
        if (CollectionUtils.isNotEmpty(rawMaterialDto.getQualityInspectItem())) {
            List<RawMaterialQualityInspectItem> rawMaterialQualityInspectItems = rawMaterialDto.getQualityInspectItem().stream()
                    .map(qualityInspectItem -> {
                        RawMaterialQualityInspectItem item = new RawMaterialQualityInspectItem();
                        item.setRawMaterialId(rawMaterialDto.getId());
                        item.setQualityInspectItemId(qualityInspectItem.getId());
                        item.setTestValue(qualityInspectItem.getTestValue());
                        return item;
                    })
                    .collect(Collectors.toList());
            rawMaterialQualityInspectItemService.saveBatch(rawMaterialQualityInspectItems);
        }
        return i > 0;
    }
}