package cn.iocoder.yudao.module.mes.service.tm.tool;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.tm.tool.vo.MesTmToolImportExcelVO;
import cn.iocoder.yudao.module.mes.controller.admin.tm.tool.vo.MesTmToolImportRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.tm.tool.vo.MesTmToolPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.tm.tool.vo.MesTmToolSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.tm.tool.MesTmToolDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.tm.tool.MesTmToolTypeDO;
import cn.iocoder.yudao.module.mes.dal.mysql.tm.tool.MesTmToolMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.tm.tool.MesTmToolTypeMapper;
import cn.iocoder.yudao.module.mes.enums.tm.MesTmMaintenTypeEnum;
import cn.iocoder.yudao.module.mes.enums.tm.MesTmToolStatusEnum;
import cn.iocoder.yudao.module.mes.enums.wm.BarcodeBizTypeEnum;
import cn.iocoder.yudao.module.mes.service.wm.barcode.MesWmBarcodeService;
import cn.iocoder.yudao.module.mes.service.wm.batch.MesWmBatchService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES 工具台账 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class MesTmToolServiceImpl implements MesTmToolService {

    @Resource
    private MesTmToolMapper toolMapper;

    @Resource
    private MesTmToolTypeMapper toolTypeMapper;

    @Resource
    @Lazy // 延迟加载，避免循环依赖
    private MesTmToolTypeService toolTypeService;
    @Resource
    private MesWmBarcodeService barcodeService;
    @Resource
    @Lazy
    private MesWmBatchService batchService;

    @Override
    public Long createTool(MesTmToolSaveReqVO createReqVO) {
        // 校验数据
        validateToolSaveData(null, createReqVO);

        // 插入
        MesTmToolDO tool = BeanUtils.toBean(createReqVO, MesTmToolDO.class);
        toolMapper.insert(tool);

        // 自动生成条码
        barcodeService.autoGenerateBarcode(BarcodeBizTypeEnum.TOOL.getValue(),
                tool.getId(), tool.getCode(), tool.getName());
        return tool.getId();
    }

    @Override
    public void updateTool(MesTmToolSaveReqVO updateReqVO) {
        // 1.1 校验存在
        validateToolExists(updateReqVO.getId());
        // 1.2 校验数据
        validateToolSaveData(updateReqVO.getId(), updateReqVO);

        // 2.1 保养类型互斥清理
        if (Objects.equals(updateReqVO.getMaintenType(), MesTmMaintenTypeEnum.REGULAR.getType())) {
            updateReqVO.setNextMaintenPeriod(null);
        } else if (Objects.equals(updateReqVO.getMaintenType(), MesTmMaintenTypeEnum.USAGE.getType())) {
            updateReqVO.setNextMaintenDate(null);
        }
        // 2.2 更新
        MesTmToolDO updateObj = BeanUtils.toBean(updateReqVO, MesTmToolDO.class);
        toolMapper.updateById(updateObj);
    }

    private void validateToolSaveData(Long id, MesTmToolSaveReqVO reqVO) {
        // 校验工具类型存在
        toolTypeService.validateToolTypeExists(reqVO.getToolTypeId());
        // 校验编码唯一
        validateToolCodeUnique(id, reqVO.getCode());
    }

    @Override
    public void deleteTool(Long id) {
        // 校验存在
        validateToolExists(id);
        // 校验是否被批次引用
        if (batchService.getBatchCountByToolId(id) > 0) {
            throw exception(TM_TOOL_HAS_BATCH);
        }

        // 删除
        toolMapper.deleteById(id);
    }

    private void validateToolExists(Long id) {
        if (toolMapper.selectById(id) == null) {
            throw exception(TM_TOOL_NOT_EXISTS);
        }
    }

    private void validateToolCodeUnique(Long id, String code) {
        if (code == null) {
            return;
        }
        MesTmToolDO tool = toolMapper.selectByCode(code);
        if (tool == null) {
            return;
        }
        if (ObjUtil.notEqual(tool.getId(), id)) {
            throw exception(TM_TOOL_CODE_DUPLICATE);
        }
    }

    @Override
    public MesTmToolDO getTool(Long id) {
        return toolMapper.selectById(id);
    }

    @Override
    public PageResult<MesTmToolDO> getToolPage(MesTmToolPageReqVO pageReqVO) {
        return toolMapper.selectPage(pageReqVO);
    }

    @Override
    public Long getToolCountByToolTypeId(Long toolTypeId) {
        return toolMapper.selectCountByToolTypeId(toolTypeId);
    }

    @Override
    public List<MesTmToolDO> getToolList() {
        return toolMapper.selectList();
    }

    @Override
    public List<MesTmToolDO> getToolList(Collection<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            return Collections.emptyList();
        }
        return toolMapper.selectByIds(ids);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MesTmToolImportRespVO importToolList(List<MesTmToolImportExcelVO> importList,
                                                boolean updateSupport) {
        // 1. 校验非空
        if (CollUtil.isEmpty(importList)) {
            throw exception(TM_TOOL_IMPORT_LIST_IS_EMPTY);
        }

        // 2. 逐行处理
        MesTmToolImportRespVO respVO = MesTmToolImportRespVO.builder()
                .createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
                .failureCodes(new LinkedHashMap<>()).build();
        AtomicInteger index = new AtomicInteger(1);
        importList.forEach(importItem -> {
            int currentIndex = index.getAndIncrement();
            String key = StrUtil.blankToDefault(importItem.getCode(), "第 " + currentIndex + " 行");
            if (StrUtil.isBlank(importItem.getCode())) {
                respVO.getFailureCodes().put(key, "工具编码不能为空");
                return;
            }
            if (StrUtil.isBlank(importItem.getName())) {
                respVO.getFailureCodes().put(key, "工具名称不能为空");
                return;
            }
            if (importItem.getQuantity() == null) {
                respVO.getFailureCodes().put(key, "数量不能为空");
                return;
            }
            // 解析工具类型（按名称）
            Long toolTypeId = null;
            if (StrUtil.isNotBlank(importItem.getToolTypeName())) {
                MesTmToolTypeDO toolType = toolTypeMapper.selectByName(importItem.getToolTypeName());
                if (toolType == null) {
                    respVO.getFailureCodes().put(key, "工具类型不存在：" + importItem.getToolTypeName());
                    return;
                }
                toolTypeId = toolType.getId();
            }
            // 2.1 判断：创建 or 更新
            MesTmToolDO existTool = toolMapper.selectByCode(importItem.getCode());
            if (existTool == null) {
                // 2.1.1 新增
                MesTmToolDO tool = BeanUtils.toBean(importItem, MesTmToolDO.class);
                tool.setId(null);
                tool.setToolTypeId(toolTypeId);
                tool.setStatus(ObjUtil.defaultIfNull(importItem.getStatus(), MesTmToolStatusEnum.STORE.getStatus()));
                tool.setAvailableQuantity(ObjUtil.defaultIfNull(importItem.getAvailableQuantity(), importItem.getQuantity()));
                toolMapper.insert(tool);
                respVO.getCreateCodes().add(importItem.getCode());
            } else if (updateSupport) {
                // 2.1.2 更新（保养类型互斥清理，与手动更新保持一致）
                MesTmToolDO updateObj = BeanUtils.toBean(importItem, MesTmToolDO.class);
                updateObj.setId(existTool.getId());
                updateObj.setCode(existTool.getCode());
                updateObj.setToolTypeId(toolTypeId);
                if (Objects.equals(updateObj.getMaintenType(), MesTmMaintenTypeEnum.REGULAR.getType())) {
                    updateObj.setNextMaintenPeriod(null);
                } else if (Objects.equals(updateObj.getMaintenType(), MesTmMaintenTypeEnum.USAGE.getType())) {
                    updateObj.setNextMaintenDate(null);
                }
                toolMapper.updateById(updateObj);
                respVO.getUpdateCodes().add(importItem.getCode());
            } else {
                respVO.getFailureCodes().put(key, "工具编码已存在");
            }
        });
        return respVO;
    }

}