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.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
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.HackLoopTableRenderPolicy;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.inspectiontask.mapper.QualityInspectItemMapper;
import com.ruoyi.inspectiontask.pojo.QualityInspectItem;
import com.ruoyi.quality.dto.RawMaterialDto;
import com.ruoyi.quality.dto.RawMaterialQualityInspectItemDto;
import com.ruoyi.quality.mapper.RawMaterialMapper;
import com.ruoyi.quality.pojo.QualityInspect;
import com.ruoyi.quality.pojo.QualityInspectParam;
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 javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.*;
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 = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(rawQualityList)) {
            List<Long> qualityInspectItemIds = rawQualityList.stream().map(RawMaterialQualityInspectItem::getQualityInspectItemId).collect(Collectors.toList());
            qualityInspectItems = qualityInspectItemMapper.selectList(new LambdaQueryWrapper<QualityInspectItem>()
                    .in(QualityInspectItem::getId, qualityInspectItemIds));
        }
        // 替换化验值
        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
    @Transactional(rollbackFor = Exception.class)
    public boolean update(RawMaterialDto rawMaterialDto) {
        // 更新原料
        if (rawMaterialMapper.updateById(rawMaterialDto) <= 0) {
            return false;
        }

        Long rawMaterialId = rawMaterialDto.getId();
        List<QualityInspectItem> newQualityInspectItems = rawMaterialDto.getQualityInspectItem();

        // 获取现有检验项关联记录
        List<RawMaterialQualityInspectItem> existingItems = rawMaterialQualityInspectItemService.list(
                new LambdaQueryWrapper<RawMaterialQualityInspectItem>()
                        .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialId)
        );

        // 删除不存在的关联记录
        if (CollectionUtils.isEmpty(newQualityInspectItems)) {
            // 如果没有检验项，删除所有现有关联记录
            if (CollectionUtils.isNotEmpty(existingItems)) {
                List<Long> existingIds = existingItems.stream()
                        .map(RawMaterialQualityInspectItem::getId)
                        .collect(Collectors.toList());
                rawMaterialQualityInspectItemService.removeByIds(existingIds);
            }
            return true;
        }

        // 获取新检验项的ID集合和测试值映射
        Set<Long> newItemIds = newQualityInspectItems.stream()
                .map(QualityInspectItem::getId)
                .collect(Collectors.toSet());

        Map<Long, String> testValueMap = newQualityInspectItems.stream()
                .collect(Collectors.toMap(QualityInspectItem::getId, QualityInspectItem::getTestValue));

        // 删除不存在的关联记录
        List<Long> toDelete = existingItems.stream()
                .filter(item -> !newItemIds.contains(item.getQualityInspectItemId()))
                .map(RawMaterialQualityInspectItem::getId)
                .collect(Collectors.toList());

        if (CollectionUtils.isNotEmpty(toDelete)) {
            rawMaterialQualityInspectItemService.removeByIds(toDelete);
        }

        // 处理更新数据
        List<RawMaterialQualityInspectItem> toUpdate = existingItems.stream()
                .filter(item -> newItemIds.contains(item.getQualityInspectItemId()))
                .peek(item -> item.setTestValue(testValueMap.get(item.getQualityInspectItemId())))
                .collect(Collectors.toList());

        if (CollectionUtils.isNotEmpty(toUpdate)) {
            rawMaterialQualityInspectItemService.updateBatchById(toUpdate);
        }

        // 处理新增数据
        Set<Long> existingItemIds = existingItems.stream()
                .map(RawMaterialQualityInspectItem::getQualityInspectItemId)
                .collect(Collectors.toSet());

        List<RawMaterialQualityInspectItem> toCreate = newQualityInspectItems.stream()
                .filter(item -> !existingItemIds.contains(item.getId()))
                .map(item -> {
                    RawMaterialQualityInspectItem newItem = new RawMaterialQualityInspectItem();
                    newItem.setRawMaterialId(rawMaterialId);
                    newItem.setQualityInspectItemId(item.getId());
                    newItem.setTestValue(item.getTestValue());
                    return newItem;
                })
                .collect(Collectors.toList());

        if (CollectionUtils.isNotEmpty(toCreate)) {
            rawMaterialQualityInspectItemService.saveBatch(toCreate);
        }

        return true;
    }

    @Override
    public void export(HttpServletResponse response, RawMaterialDto rawMaterialDto) {
        List<RawMaterialDto> rawMaterials = rawMaterialMapper.listPage(new Page<>(1, Integer.MAX_VALUE), rawMaterialDto).getRecords();
        ExcelUtil<RawMaterialDto> util = new ExcelUtil<RawMaterialDto>(RawMaterialDto.class);
        util.exportExcel(response, rawMaterials, "原料检验导出");
    }

    @Override
    public void down(HttpServletResponse response, RawMaterialDto rawMaterialDto) {
        RawMaterial rawMaterial = rawMaterialMapper.selectById(rawMaterialDto.getId());
        // 获取产品型号信息
        ProductModel productModel = productModelMapper.selectById(rawMaterial.getProductModelId());
        Product product = productMapper.selectById(productModel.getProductId());
        RawMaterialDto inspect = new RawMaterialDto();
        BeanUtils.copyProperties(rawMaterial, inspect);
        inspect.setModel(productModel.getModel());
        inspect.setProductName(product.getProductName());
        inspect.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()) == null ? "" : RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());
        inspect.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()) == null ? "" : RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());

        List<RawMaterialQualityInspectItem> paramList = rawMaterialQualityInspectItemService.list(
                new LambdaQueryWrapper<RawMaterialQualityInspectItem>()
                        .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialDto.getId())
        );
        List<RawMaterialQualityInspectItemDto> inspectItems = new ArrayList<>();

        int index = 1;
        for (RawMaterialQualityInspectItem item : paramList) {
            RawMaterialQualityInspectItemDto dto = new RawMaterialQualityInspectItemDto();
            BeanUtils.copyProperties(item, dto);
            QualityInspectItem qualityInspectItem = qualityInspectItemMapper.selectById(item.getQualityInspectItemId());
            dto.setName(qualityInspectItem.getName());
            dto.setUnit(qualityInspectItem.getUnit());
            dto.setStandardValue(qualityInspectItem.getStandardValue());
            dto.setInternalControl(qualityInspectItem.getInternalControl());
            dto.setIndex(index);
            inspectItems.add(dto);
            index++;
        }

        InputStream inputStream = this.getClass().getResourceAsStream("/static/report-template.docx");
        Configure configure = Configure.builder()
                .bind("paramList", new HackLoopTableRenderPolicy())
                .build();
        XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
                new HashMap<String, Object>() {{
                    put("inspect", inspect);
                    put("paramList", inspectItems);
                }});

        try {
            response.setContentType("application/msword");
            String fileName = URLEncoder.encode(
                    "检验报告", "UTF-8");
            response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");
            response.setHeader("Content-disposition",
                    "attachment;filename=" + fileName + ".docx");
            OutputStream os = response.getOutputStream();
            template.write(os);
            os.flush();
            os.close();
            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("导出失败");
        }
    }
}