package cn.iocoder.yudao.module.mes.service.wm.arrivalnotice;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.wm.arrivalnotice.vo.MesWmArrivalNoticePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.wm.arrivalnotice.vo.MesWmArrivalNoticeSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.arrivalnotice.MesWmArrivalNoticeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.arrivalnotice.MesWmArrivalNoticeLineDO;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.arrivalnotice.MesWmArrivalNoticeMapper;
import cn.iocoder.yudao.module.mes.enums.wm.MesWmArrivalNoticeStatusEnum;
import cn.iocoder.yudao.module.erp.api.purchase.ErpPurchaseOrderApi;
import cn.iocoder.yudao.module.erp.api.purchase.ErpSupplierApi;
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseOrderRespDTO;
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseOrderItemRespDTO;
import cn.iocoder.yudao.module.mes.service.mdm.MesMdmItemService;
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcService;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcCheckResultEnum;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
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.math.BigDecimal;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

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

/**
 * MES 到货通知单 Service 实现类
 */
@Service
@Validated
@Slf4j
public class MesWmArrivalNoticeServiceImpl implements MesWmArrivalNoticeService {

    @Resource
    private MesWmArrivalNoticeMapper arrivalNoticeMapper;

    @Resource
    private MesWmArrivalNoticeLineService arrivalNoticeLineService;

    @Resource
    private ErpSupplierApi supplierApi;

    @Resource
    private ErpPurchaseOrderApi purchaseOrderApi;

    @Resource
    private MesMdmItemService mdmItemService;

    @Resource
    @Lazy
    private MesQcIqcService iqcService;

    @Override
    public Long createArrivalNotice(MesWmArrivalNoticeSaveReqVO createReqVO) {
        // 校验数据
        validateArrivalNoticeSaveData(createReqVO);

        // 插入
        MesWmArrivalNoticeDO notice = BeanUtils.toBean(createReqVO, MesWmArrivalNoticeDO.class);
        notice.setStatus(MesWmArrivalNoticeStatusEnum.PREPARE.getStatus());
        arrivalNoticeMapper.insert(notice);
        return notice.getId();
    }

    @Override
    public void updateArrivalNotice(MesWmArrivalNoticeSaveReqVO updateReqVO) {
        // 校验存在 + 草稿状态
        validateArrivalNoticeExistsAndDraft(updateReqVO.getId());
        // 校验数据
        validateArrivalNoticeSaveData(updateReqVO);

        // 更新
        MesWmArrivalNoticeDO updateObj = BeanUtils.toBean(updateReqVO, MesWmArrivalNoticeDO.class);
        arrivalNoticeMapper.updateById(updateObj);
    }

    private void validateArrivalNoticeSaveData(MesWmArrivalNoticeSaveReqVO reqVO) {
        // 校验编码唯一
        validateCodeUnique(reqVO.getId(), reqVO.getCode());
        // 校验供应商存在（ERP 采购供应商）
        supplierApi.validateSupplier(reqVO.getVendorId());
        // 校验采购订单存在
        if (reqVO.getPurchaseOrderId() != null) {
            ErpPurchaseOrderRespDTO purchaseOrder = purchaseOrderApi.getPurchaseOrder(reqVO.getPurchaseOrderId()).getCheckedData();
            if (purchaseOrder == null) {
                throw exception(WM_PURCHASE_ORDER_NOT_EXISTS);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteArrivalNotice(Long id) {
        // 校验存在 + 草稿状态
        validateArrivalNoticeExistsAndDraft(id);

        // 级联删除行
        arrivalNoticeLineService.deleteArrivalNoticeLineByNoticeId(id);
        // 删除
        arrivalNoticeMapper.deleteById(id);
    }

    @Override
    public MesWmArrivalNoticeDO getArrivalNotice(Long id) {
        return arrivalNoticeMapper.selectById(id);
    }

    @Override
    public PageResult<MesWmArrivalNoticeDO> getArrivalNoticePage(MesWmArrivalNoticePageReqVO pageReqVO) {
        return arrivalNoticeMapper.selectPage(pageReqVO);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitArrivalNotice(Long id) {
        // 1.1 校验存在 + 草稿状态
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExistsAndDraft(id);
        // 1.2 检查是否有行项目
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        if (CollUtil.isEmpty(lines)) {
            throw exception(WM_ARRIVAL_NOTICE_NO_LINE);
        }

        // 2. 检查所有行的 iqcCheckFlag：如果有需要检验的行，进入待质检状态
        boolean needCheck = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()));
        if (needCheck) {
            // 2.1 需要检验，进入待质检
            arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                    .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus()));
            // 2.2 为需要质检的行自动创建 IQC 检验单
            for (MesWmArrivalNoticeLineDO line : lines) {
                if (Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcId() == null) {
                    try {
                        Long iqcId = iqcService.createIqcFromArrivalNotice(
                                id, line, notice.getCode(), notice.getVendorId());
                        // 更新行上的 iqcId
                        arrivalNoticeLineService.updateArrivalNoticeLineIqcId(line.getId(), iqcId);
                        log.info("[submitArrivalNotice][到货通知单({}) 行({}) 自动创建 IQC 检验单({})]",
                                id, line.getId(), iqcId);
                    } catch (Exception e) {
                        log.warn("[submitArrivalNotice][到货通知单({}) 行({}) 创建 IQC 失败: {}]",
                                id, line.getId(), e.getMessage());
                        // 继续处理其他行，不中断流程
                    }
                }
            }
            return;
        }
        // 不需要检验，直接进入待入库
        arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateArrivalNoticeWhenIqcFinish(Long id, Long lineId, Long iqcId, Integer checkResult, BigDecimal qualifiedQuantity) {
        // 1.1 校验到货通知单存在
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        // 1.2 校验状态为待质检
        if (ObjUtil.notEqual(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus(), notice.getStatus())) {
            throw exception(WM_ARRIVAL_NOTICE_STATUS_NOT_PENDING_QC);
        }

        // 2. 更新到货通知单行：绑定 iqcId + 质检结果 + 合格数量
        arrivalNoticeLineService.updateArrivalNoticeLineWhenIqcFinish(lineId, iqcId, checkResult, qualifiedQuantity);

        // 3.1 判断是否所有需检行都已完成质检
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        boolean hasUnchecked = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcCheckResult() == null);
        if (hasUnchecked) {
            log.info("[updateArrivalNoticeWhenIqcFinish][到货通知单({}) 还有未完成检验的行，暂不更新状态]", id);
            return;
        }

        // 3.2 判断是否所有需检行都可以入库（合格或特采）
        boolean hasNonInbound = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag())
                        && !MesQcCheckResultEnum.canInbound(line.getIqcCheckResult()));
        if (hasNonInbound) {
            log.info("[updateArrivalNoticeWhenIqcFinish][到货通知单({}) 存在不可入库的行（退货/报废），状态保持待质检]", id);
            return;
        }

        // 3.3 所有行检验完成且可入库，更新主表状态 PENDING_QC → PENDING_RECEIPT
        arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus()));
    }

    @Override
    public void finishArrivalNotice(Long id) {
        // 校验存在
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        // 校验状态：只有待入库才允许完成
        if (ObjUtil.notEqual(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus(), notice.getStatus())) {
            throw exception(WM_ARRIVAL_NOTICE_STATUS_NOT_PENDING_RECEIPT);
        }
        // 行级防御校验：确保所有需检行都已完成 IQC
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        boolean hasUnchecked = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcId() == null);
        if (hasUnchecked) {
            throw exception(WM_ARRIVAL_NOTICE_IQC_PENDING);
        }

        // 完成
        arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.FINISHED.getStatus()));
    }

    @Override
    public List<MesWmArrivalNoticeDO> getArrivalNoticeList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyList();
        }
        return arrivalNoticeMapper.selectByIds(ids);
    }

    @Override
    public void validateArrivalNoticeAndLineExists(Long noticeId, Long lineId) {
        // 1. 校验通知单存在
        MesWmArrivalNoticeDO notice = arrivalNoticeMapper.selectById(noticeId);
        if (notice == null) {
            throw exception(WM_ARRIVAL_NOTICE_NOT_EXISTS);
        }
        // 2.1 校验行存在
        MesWmArrivalNoticeLineDO line = arrivalNoticeLineService.getArrivalNoticeLine(lineId);
        if (line == null) {
            throw exception(WM_ARRIVAL_NOTICE_LINE_NOT_EXISTS);
        }
        // 2.2 校验行属于该通知单
        if (ObjUtil.notEqual(line.getNoticeId(), noticeId)) {
            throw exception(WM_ARRIVAL_NOTICE_LINE_NOT_EXISTS);
        }
    }

    @Override
    public MesWmArrivalNoticeDO validateArrivalNoticeExists(Long id) {
        MesWmArrivalNoticeDO notice = arrivalNoticeMapper.selectById(id);
        if (notice == null) {
            throw exception(WM_ARRIVAL_NOTICE_NOT_EXISTS);
        }
        return notice;
    }

    @Override
    public MesWmArrivalNoticeDO validateArrivalNoticeExistsAndDraft(Long id) {
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        if (ObjUtil.notEqual(MesWmArrivalNoticeStatusEnum.PREPARE.getStatus(), notice.getStatus())) {
            throw exception(WM_ARRIVAL_NOTICE_STATUS_NOT_PREPARE);
        }
        return notice;
    }

    @Override
    public MesWmArrivalNoticeDO validateArrivalNoticeReadyForReceipt(Long id) {
        // 1. 校验到货通知单存在且状态为待入库
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        if (ObjUtil.notEqual(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus(), notice.getStatus())) {
            throw exception(WM_ARRIVAL_NOTICE_STATUS_NOT_PENDING_RECEIPT);
        }
        // 2. 行级防御校验：确保所有需检行都已完成 IQC
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        boolean hasUnchecked = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcId() == null);
        if (hasUnchecked) {
            throw exception(WM_ARRIVAL_NOTICE_IQC_PENDING);
        }
        return notice;
    }

    private void validateCodeUnique(Long id, String code) {
        MesWmArrivalNoticeDO notice = arrivalNoticeMapper.selectByCode(code);
        if (notice == null) {
            return;
        }
        if (ObjUtil.notEqual(id, notice.getId())) {
            throw exception(WM_ARRIVAL_NOTICE_CODE_DUPLICATE);
        }
    }

    @Override
    public Long getArrivalNoticeCountByVendorId(Long vendorId) {
        return arrivalNoticeMapper.selectCountByVendorId(vendorId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long generateArrivalNoticeFromPurchaseOrder(Long purchaseOrderId) {
        // 1. 校验是否已生成过到货通知单（防止重复生成）
        MesWmArrivalNoticeDO existNotice = arrivalNoticeMapper.selectByPurchaseOrderId(purchaseOrderId);
        if (existNotice != null) {
            throw exception(WM_ARRIVAL_NOTICE_ALREADY_EXISTS);
        }

        // 2. 获取采购订单
        ErpPurchaseOrderRespDTO purchaseOrder = purchaseOrderApi.getPurchaseOrder(purchaseOrderId).getCheckedData();
        if (purchaseOrder == null) {
            throw exception(WM_PURCHASE_ORDER_NOT_EXISTS);
        }

        // 3. 获取采购订单明细
        List<ErpPurchaseOrderItemRespDTO> items = purchaseOrderApi.getPurchaseOrderItemList(purchaseOrderId).getCheckedData();
        if (CollUtil.isEmpty(items)) {
            throw exception(WM_PURCHASE_ORDER_NO_ITEM);
        }

        // 4. 生成到货通知单编码
        String code = generateArrivalNoticeCode();

        // 5. 创建到货通知单主表，直接设为待入库状态
        MesWmArrivalNoticeDO notice = new MesWmArrivalNoticeDO();
        notice.setCode(code);
        notice.setName(purchaseOrder.getNo() + "到货通知");
        notice.setPurchaseOrderId(purchaseOrderId);
        notice.setPurchaseOrderCode(purchaseOrder.getNo());
        notice.setVendorId(purchaseOrder.getSupplierId());
        notice.setArrivalDate(java.time.LocalDateTime.now()); // 到货时间为当前时间
        notice.setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus());
        arrivalNoticeMapper.insert(notice);

        // 6. 遍历明细创建到货通知单行
        boolean hasNeedQc = false;
        for (ErpPurchaseOrderItemRespDTO item : items) {
            MesWmArrivalNoticeLineDO line = new MesWmArrivalNoticeLineDO();
            line.setNoticeId(notice.getId());
            line.setPurchaseOrderItemId(item.getId());
            line.setItemId(item.getProductId()); // 从采购订单明细带入物料编号
            BigDecimal arrivalQuantity = item.getCount() != null ? item.getCount().subtract(item.getInCount() != null ? item.getInCount() : BigDecimal.ZERO) : BigDecimal.ZERO;
            line.setArrivalQuantity(arrivalQuantity);
            // 从采购订单明细带入质检标识
            boolean needQc = Boolean.TRUE.equals(item.getQcCheckFlag());
            line.setIqcCheckFlag(needQc);
            // 如果不需要质检，合格数量等于到货数量
            if (!needQc) {
                line.setQualifiedQuantity(arrivalQuantity);
            } else {
                hasNeedQc = true;
            }
            arrivalNoticeLineService.createArrivalNoticeLineFromPurchaseOrderItem(line);
        }

        // 7. 如果有需要质检的行，更新状态为待质检并自动创建 IQC 单
        if (hasNeedQc) {
            arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                    .setId(notice.getId()).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus()));
            // 为需要质检的行自动创建 IQC 检验单
            List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(notice.getId());
            for (MesWmArrivalNoticeLineDO line : lines) {
                if (Boolean.TRUE.equals(line.getIqcCheckFlag())) {
                    Long iqcId = iqcService.createIqcFromArrivalNotice(
                            notice.getId(), line, notice.getCode(), notice.getVendorId());
                    arrivalNoticeLineService.updateArrivalNoticeLineIqcId(line.getId(), iqcId);
                    log.info("[generateArrivalNoticeFromPurchaseOrder][到货通知单({}) 行({}) 自动创建 IQC 检验单({})]",
                            notice.getId(), line.getId(), iqcId);
                }
            }
        }

        return notice.getId();
    }

    /**
     * 生成到货通知单编码
     */
    private String generateArrivalNoticeCode() {
        // TODO: 使用编码规则服务生成编码
        return "AN" + System.currentTimeMillis();
    }

}