package cn.iocoder.yudao.module.mes.service.md.item;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.module.mdm.api.category.MdmItemCategoryApi;
import cn.iocoder.yudao.module.mdm.api.category.dto.MdmItemCategoryRespDTO;
import cn.iocoder.yudao.module.mdm.api.category.dto.MdmItemCategorySaveReqDTO;
import cn.iocoder.yudao.module.mes.controller.admin.md.item.vo.type.MesMdItemTypeImportExcelVO;
import cn.iocoder.yudao.module.mes.controller.admin.md.item.vo.type.MesMdItemTypeImportRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.md.item.vo.type.MesMdItemTypeListReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.md.item.vo.type.MesMdItemTypeSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemTypeDO;
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.*;
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 实现类
 *
 * 物料分类已统一由 MDM 管理，数据存储在 mdm_item_category 表。
 * 本服务保留 MES 的分类接口，底层全部通过 {@link MdmItemCategoryApi} 读写 MDM 分类。
 *
 * @author 超级管理员
 */
@Service
@Validated
public class MesMdItemTypeServiceImpl implements MesMdItemTypeService {

    /** MDM 物料类型：物料 */
    private static final Integer MDM_ITEM_TYPE_MATERIAL = 1;
    /** MDM 物料类型：产品 */
    private static final Integer MDM_ITEM_TYPE_PRODUCT = 2;
    /** MES 物料/产品标识：产品 */
    private static final String ITEM_OR_PRODUCT_PRODUCT = "PRODUCT";

    @Resource
    private MdmItemCategoryApi mdmItemCategoryApi;

    @Resource
    @Lazy
    private MesMdItemService itemService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createItemType(MesMdItemTypeSaveReqVO createReqVO) {
        // 校验父分类
        validateParentItemType(createReqVO.getId(), createReqVO.getParentId());
        // 写入 MDM 分类表
        CommonResult<Long> result = mdmItemCategoryApi.createItemCategory(buildSaveDTO(createReqVO));
        return result.getData();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateItemType(MesMdItemTypeSaveReqVO updateReqVO) {
        // 校验存在
        validateItemTypeExists(updateReqVO.getId());
        // 校验父分类
        validateParentItemType(updateReqVO.getId(), updateReqVO.getParentId());
        // 更新 MDM 分类表
        MdmItemCategorySaveReqDTO updateDTO = buildSaveDTO(updateReqVO);
        updateDTO.setId(updateReqVO.getId());
        mdmItemCategoryApi.updateItemCategory(updateDTO);
    }

    private MdmItemCategorySaveReqDTO buildSaveDTO(MesMdItemTypeSaveReqVO reqVO) {
        MdmItemCategorySaveReqDTO dto = new MdmItemCategorySaveReqDTO();
        dto.setParentId(ObjUtil.defaultIfNull(reqVO.getParentId(), MesMdItemTypeDO.PARENT_ID_ROOT));
        dto.setCode(reqVO.getCode());
        dto.setName(reqVO.getName());
        dto.setItemOrProduct(reqVO.getItemOrProduct());
        dto.setItemType(convertMdmItemType(reqVO.getItemOrProduct()));
        dto.setSort(ObjUtil.defaultIfNull(reqVO.getSort(), 0));
        dto.setStatus(ObjUtil.defaultIfNull(reqVO.getStatus(), CommonStatusEnum.ENABLE.getStatus()));
        dto.setRemark(reqVO.getRemark());
        return dto;
    }

    /**
     * MES 物料/产品标识 -> MDM 物料类型
     */
    private Integer convertMdmItemType(String itemOrProduct) {
        if (StrUtil.isBlank(itemOrProduct)) {
            return null;
        }
        return ITEM_OR_PRODUCT_PRODUCT.equalsIgnoreCase(itemOrProduct)
                ? MDM_ITEM_TYPE_PRODUCT : MDM_ITEM_TYPE_MATERIAL;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteItemType(Long id) {
        // 1.1 校验存在
        validateItemTypeExists(id);
        // 1.2 校验是否有物料
        if (itemService.getItemCountByItemTypeId(id) > 0) {
            throw exception(MD_ITEM_TYPE_EXITS_ITEM);
        }
        // 2. 删除（子分类、MDM 物料引用由 MDM 侧校验）
        mdmItemCategoryApi.deleteItemCategory(id);
    }

    private void validateItemTypeExists(Long id) {
        if (getItemType(id) == null) {
            throw exception(MD_ITEM_TYPE_NOT_EXISTS);
        }
    }

    private void validateParentItemType(Long id, Long parentId) {
        if (parentId == null || MesMdItemTypeDO.PARENT_ID_ROOT.equals(parentId)) {
            return;
        }
        // 1. 不能设置自己为父分类
        if (Objects.equals(id, parentId)) {
            throw exception(MD_ITEM_TYPE_PARENT_ERROR);
        }
        // 2. 父分类不存在
        MesMdItemTypeDO parentItemType = getItemType(parentId);
        if (parentItemType == null) {
            throw exception(MD_ITEM_TYPE_PARENT_NOT_EXITS);
        }
        // 3. 递归校验父分类，如果父分类是自己的子分类，则报错，避免形成环路
        if (id == null) {
            return;
        }
        for (int i = 0; i < Short.MAX_VALUE; i++) {
            parentId = parentItemType.getParentId();
            if (Objects.equals(id, parentId)) {
                throw exception(MD_ITEM_TYPE_PARENT_IS_CHILD);
            }
            if (parentId == null || MesMdItemTypeDO.PARENT_ID_ROOT.equals(parentId)) {
                break;
            }
            parentItemType = getItemType(parentId);
            if (parentItemType == null) {
                break;
            }
        }
    }

    @Override
    public MesMdItemTypeDO getItemType(Long id) {
        CommonResult<MdmItemCategoryRespDTO> result = mdmItemCategoryApi.getItemCategory(id);
        return result.isSuccess() ? convertToMesDO(result.getData()) : null;
    }

    @Override
    public MesMdItemTypeDO getItemTypeByCode(String code) {
        CommonResult<MdmItemCategoryRespDTO> result = mdmItemCategoryApi.getItemCategoryByCode(code);
        return result.isSuccess() ? convertToMesDO(result.getData()) : null;
    }

    @Override
    public List<MesMdItemTypeDO> getItemTypeList(MesMdItemTypeListReqVO listReqVO) {
        List<MesMdItemTypeDO> list = getAllItemTypeList();
        return list.stream()
                .filter(itemType -> StrUtil.isBlank(listReqVO.getName())
                        || StrUtil.contains(itemType.getName(), listReqVO.getName()))
                .filter(itemType -> listReqVO.getStatus() == null
                        || Objects.equals(listReqVO.getStatus(), itemType.getStatus()))
                .sorted(Comparator.comparing(itemType -> ObjUtil.defaultIfNull(itemType.getSort(), 0)))
                .toList();
    }

    @Override
    public List<MesMdItemTypeDO> getItemTypeList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyList();
        }
        CommonResult<List<MdmItemCategoryRespDTO>> result = mdmItemCategoryApi.getItemCategoryList(ids);
        return convertToMesDOList(result.isSuccess() ? result.getData() : null);
    }

    private List<MesMdItemTypeDO> getAllItemTypeList() {
        CommonResult<List<MdmItemCategoryRespDTO>> result = mdmItemCategoryApi.getItemCategoryAllList();
        return convertToMesDOList(result.isSuccess() ? result.getData() : null);
    }

    private List<MesMdItemTypeDO> convertToMesDOList(List<MdmItemCategoryRespDTO> list) {
        if (CollUtil.isEmpty(list)) {
            return new ArrayList<>();
        }
        return new ArrayList<>(list.stream().map(this::convertToMesDO).toList());
    }

    @Override
    public List<MesMdItemTypeDO> getItemTypeChildrenList(Long parentId) {
        List<MesMdItemTypeDO> allList = getAllItemTypeList();
        List<MesMdItemTypeDO> result = new ArrayList<>();
        collectItemTypeChildren(result, parentId, allList);
        return result;
    }

    private void collectItemTypeChildren(List<MesMdItemTypeDO> result, Long parentId, List<MesMdItemTypeDO> allList) {
        for (MesMdItemTypeDO itemType : allList) {
            if (Objects.equals(itemType.getParentId(), parentId)) {
                result.add(itemType);
                collectItemTypeChildren(result, itemType.getId(), allList);
            }
        }
    }

    /**
     * 转换 MDM 分类 DTO 为 MES DO
     */
    private MesMdItemTypeDO convertToMesDO(MdmItemCategoryRespDTO dto) {
        if (dto == null) {
            return null;
        }
        MesMdItemTypeDO mesDO = new MesMdItemTypeDO();
        mesDO.setId(dto.getId());
        mesDO.setCode(dto.getCode());
        mesDO.setName(dto.getName());
        mesDO.setParentId(dto.getParentId());
        mesDO.setItemOrProduct(dto.getItemOrProduct());
        mesDO.setSort(dto.getSort());
        mesDO.setStatus(dto.getStatus());
        mesDO.setRemark(dto.getRemark());
        mesDO.setCreateTime(dto.getCreateTime());
        return mesDO;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MesMdItemTypeImportRespVO importItemTypeList(List<MesMdItemTypeImportExcelVO> importItemTypeList,
                                                        boolean updateSupport) {
        // 1. 校验非空
        if (CollUtil.isEmpty(importItemTypeList)) {
            throw exception(MD_ITEM_TYPE_IMPORT_LIST_IS_EMPTY);
        }

        // 2. 逐行处理
        MesMdItemTypeImportRespVO respVO = MesMdItemTypeImportRespVO.builder()
                .createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
                .failureCodes(new LinkedHashMap<>()).build();
        List<MesMdItemTypeDO> allList = getAllItemTypeList();
        AtomicInteger index = new AtomicInteger(1);
        importItemTypeList.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 (StrUtil.isBlank(importItem.getItemOrProduct())) {
                respVO.getFailureCodes().put(key, "物料/产品标识不能为空");
                return;
            }
            // 2.1 解析父分类（为空则默认为根分类）
            Long parentId = MesMdItemTypeDO.PARENT_ID_ROOT;
            if (StrUtil.isNotBlank(importItem.getParentCode())) {
                MesMdItemTypeDO parentItemType = allList.stream()
                        .filter(itemType -> Objects.equals(importItem.getParentCode(), itemType.getCode()))
                        .findFirst().orElse(null);
                if (parentItemType == null) {
                    respVO.getFailureCodes().put(key, "父分类编码[" + importItem.getParentCode() + "]不存在");
                    return;
                }
                parentId = parentItemType.getId();
            }
            // 2.2 判断是否存在（同一父分类下编码唯一）
            Long finalParentId = parentId;
            MesMdItemTypeDO existItemType = allList.stream()
                    .filter(itemType -> Objects.equals(finalParentId, itemType.getParentId())
                            && Objects.equals(importItem.getCode(), itemType.getCode()))
                    .findFirst().orElse(null);
            try {
                MdmItemCategorySaveReqDTO dto = new MdmItemCategorySaveReqDTO();
                dto.setParentId(parentId);
                dto.setCode(importItem.getCode());
                dto.setName(importItem.getName());
                dto.setItemOrProduct(importItem.getItemOrProduct());
                dto.setItemType(convertMdmItemType(importItem.getItemOrProduct()));
                dto.setSort(ObjUtil.defaultIfNull(importItem.getSort(), 0));
                dto.setStatus(ObjUtil.defaultIfNull(importItem.getStatus(), CommonStatusEnum.ENABLE.getStatus()));
                dto.setRemark(importItem.getRemark());
                if (existItemType == null) {
                    // 2.2.1 新增
                    dto.setId(null);
                    Long id = mdmItemCategoryApi.createItemCategory(dto).getData();
                    MesMdItemTypeDO created = new MesMdItemTypeDO();
                    created.setId(id);
                    created.setParentId(parentId);
                    created.setCode(importItem.getCode());
                    created.setName(importItem.getName());
                    created.setItemOrProduct(importItem.getItemOrProduct());
                    created.setSort(dto.getSort());
                    created.setStatus(dto.getStatus());
                    created.setRemark(importItem.getRemark());
                    allList.add(created);
                    respVO.getCreateCodes().add(importItem.getCode());
                } else if (updateSupport) {
                    // 2.2.2 更新
                    dto.setId(existItemType.getId());
                    mdmItemCategoryApi.updateItemCategory(dto);
                    respVO.getUpdateCodes().add(importItem.getCode());
                } else {
                    respVO.getFailureCodes().put(key, "分类编码已存在");
                }
            } catch (ServiceException e) {
                respVO.getFailureCodes().put(key, e.getMessage());
            }
        });
        return respVO;
    }

}