package com.ruoyi.appendix.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.appendix.pojo.ProcessRouteItemInstance;
import com.ruoyi.appendix.pojo.ProcessRouteItemParamInstance;
import com.ruoyi.appendix.pojo.ProductProcessParamInstance;
import com.ruoyi.appendix.pojo.ProductStructureInstance;
import com.ruoyi.appendix.service.*;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.production.pojo.*;
import com.ruoyi.production.service.*;
import com.ruoyi.productionPlan.dto.ProductionPlanDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <br>
 * BOM-工艺路线附表Service接口实现类
 * </br>
 *
 * @author deslrey
 * @version 1.0
 * @since 2026/03/18 14:45
 */
@Slf4j
@Service
public class AppendixServiceImpl implements AppendixService {

    @Resource
    private ProcessRouteItemInstanceService processRouteItemInstanceService;

    @Resource
    private ProcessRouteItemParamInstanceService processRouteItemParamInstanceService;

    @Resource
    private ProductProcessParamInstanceService productProcessParamInstanceService;

    @Resource
    private ProductStructureInstanceService productStructureInstanceService;

    @Resource
    private ProcessRouteService processRouteService;

    @Resource
    private ProcessRouteItemService processRouteItemService;

    @Resource
    private ProcessRouteItemParamService processRouteItemParamService;

    @Resource
    private ProductProcessParamService productProcessParamService;

    @Resource
    private ProductStructureService productStructureService;

    @Resource
    private ProductOrderService productOrderService;

    @Override
    public Long populateBlocks(ProductionPlanDto productionPlanDto) {
        if (productionPlanDto == null) {
            throw new ServiceException("下发数据不能为空");
        }
        if (StringUtils.isEmpty(productionPlanDto.getStrength())) {
            throw new ServiceException("砌块的产品类型不能为空");
        }
        ProcessRoute processRoute = processRouteService.latestTypeDate(productionPlanDto.getProductName(), productionPlanDto.getStrength());
        if (processRoute == null) {
            log.info("下发产品【{}】未查询出工艺路线", productionPlanDto.getProductName());
            return null;
        }
        migration(processRoute);
        return processRoute.getId();
    }

    @Override
    public Long populatePlates(ProductionPlanDto productionPlanDto) {
        if (productionPlanDto == null) {
            throw new ServiceException("下发数据不能为空");
        }
        //  板材不区分强度，strength传null
        ProcessRoute processRoute = processRouteService.latestTypeDate(productionPlanDto.getProductName(), null);
        if (processRoute == null) {
            log.info("下发产品【{}】未查询出工艺路线", productionPlanDto.getProductName());
            return null;
        }
        migration(processRoute);
        return processRoute.getId();
    }

    @Override
    public void populateData(Long productOrderId, Long processRouteId) {
        ProcessRoute processRoute = processRouteService.getById(processRouteId);
        if (processRoute == null) {
            log.info("生产订单【{}】未查询出工艺路线【{}】", productOrderId, processRouteId);
            return;
        }
        migration(processRoute);

        //  回写工艺路线id到生产订单
        ProductOrder productOrder = new ProductOrder();
        productOrder.setId(productOrderId);
        productOrder.setRouteId(processRouteId);
        productOrderService.updateById(productOrder);
    }

    @Override
    public void deleteData(Long processRouteId) {
        //  查出工艺路线子集，用于关联删除参数附表
        List<ProcessRouteItem> itemList = processRouteItemService.list(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRouteId));

        if (itemList != null && !itemList.isEmpty()) {
            List<Long> itemIds = itemList.stream().map(ProcessRouteItem::getId).collect(Collectors.toList());
            List<Long> processIds = itemList.stream().map(ProcessRouteItem::getProcessId).collect(Collectors.toList());

            //  删除工艺路线工序参数附表
            processRouteItemParamInstanceService.remove(new LambdaQueryWrapper<ProcessRouteItemParamInstance>().in(ProcessRouteItemParamInstance::getRouteItemId, itemIds));

            //  删除工序绑定参数附表
            productProcessParamInstanceService.remove(new LambdaQueryWrapper<ProductProcessParamInstance>().in(ProductProcessParamInstance::getProcessId, processIds));
        }

        //  删除工艺路线子集附表
        processRouteItemInstanceService.remove(
                new LambdaQueryWrapper<ProcessRouteItemInstance>().eq(ProcessRouteItemInstance::getRouteId, processRouteId));

        //  删除BOM子集附表
        ProcessRoute processRoute = processRouteService.getById(processRouteId);
        if (processRoute != null && processRoute.getBomId() != null) {
            productStructureInstanceService.remove(new LambdaQueryWrapper<ProductStructureInstance>().eq(ProductStructureInstance::getBomId, processRoute.getBomId()));
        }
    }

    /**
     * 根据工艺路线迁移四张附表数据
     */
    private void migration(ProcessRoute processRoute) {
        //  迁移工艺路线子集表数据
        List<ProcessRouteItem> processRouteItemList = processRouteItemService.list(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRoute.getId()));
        migrationProcessRouteItem(processRouteItemList);

        //  迁移工艺路线内绑定的工序及工序参数
        if (processRouteItemList != null && !processRouteItemList.isEmpty()) {
            for (ProcessRouteItem item : processRouteItemList) {
                List<ProcessRouteItemParam> paramList = processRouteItemParamService.list(new LambdaQueryWrapper<ProcessRouteItemParam>().eq(ProcessRouteItemParam::getRouteItemId, item.getId()));
                migrationProcessRouteItemParam(paramList);

                List<ProductProcessParam> processParamList = productProcessParamService.list(new LambdaQueryWrapper<ProductProcessParam>().eq(ProductProcessParam::getProcessId, item.getProcessId()));
                migrationProductProcessParam(processParamList);
            }
        }

        //  迁移BOM子集表数据
        if (processRoute.getBomId() != null) {
            List<ProductStructure> structureList = productStructureService.list(new LambdaQueryWrapper<ProductStructure>().eq(ProductStructure::getBomId, processRoute.getBomId()));
            migrationProductStructure(structureList);
        }
    }

    private void migrationProcessRouteItem(List<ProcessRouteItem> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProcessRouteItemInstance> instances = list.stream().map(item -> {
            ProcessRouteItemInstance instance = new ProcessRouteItemInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setIsQuality(item.getIsQuality() != null && item.getIsQuality() ? 1 : 0);
            return instance;
        }).collect(Collectors.toList());
        processRouteItemInstanceService.saveBatch(instances);
    }

    private void migrationProcessRouteItemParam(List<ProcessRouteItemParam> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProcessRouteItemParamInstance> instances = list.stream().map(item -> {
            ProcessRouteItemParamInstance instance = new ProcessRouteItemParamInstance();
            BeanUtils.copyProperties(item, instance, "id");
            return instance;
        }).collect(Collectors.toList());
        processRouteItemParamInstanceService.saveBatch(instances);
    }

    private void migrationProductProcessParam(List<ProductProcessParam> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProductProcessParamInstance> instances = list.stream().map(item -> {
            ProductProcessParamInstance instance = new ProductProcessParamInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setIsRequired(item.getIsRequired() != null && item.getIsRequired() == 1);
            return instance;
        }).collect(Collectors.toList());
        productProcessParamInstanceService.saveBatch(instances);
    }

    private void migrationProductStructure(List<ProductStructure> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProductStructureInstance> instances = list.stream().map(item -> {
            ProductStructureInstance instance = new ProductStructureInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setBomId(item.getBomId() != null ? item.getBomId().longValue() : null);
            return instance;
        }).collect(Collectors.toList());
        productStructureInstanceService.saveBatch(instances);
    }
}