package cn.iocoder.yudao.module.mes.service.pro.bagcode;

import cn.iocoder.yudao.module.mes.dal.dataobject.pro.bagcode.MesProBagCodeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.pallet.MesProPalletDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeGenerateTaskMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeMapper;
import cn.iocoder.yudao.module.mes.dal.redis.MesCodeRedisDAO;
import cn.iocoder.yudao.module.mes.enums.pro.MesProBagCodeGenerateBizTypeEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProBagCodeStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProPalletStatusEnum;
import cn.iocoder.yudao.module.mes.framework.bagcode.MesProBagCodeGenerateProperties;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 袋码批量生成执行器（同步与异步共用）
 * <p>
 * 与旧实现的关键差异：
 * <ul>
 *     <li>编码批量向 Redis 申请，避免每个袋码两次网络往返；</li>
 *     <li>袋序号一次性分配，分段只做偏移计算；</li>
 *     <li>每段独立事务落库，并在段间回写进度、检查取消与超时。</li>
 * </ul>
 */
@Slf4j
@Component
public class MesProBagCodeBatchGenerator {

    @Resource
    private MesProBagCodeMapper bagCodeMapper;
    @Resource
    private MesProBagCodeGenerateTaskMapper taskMapper;
    @Resource
    private MesCodeRedisDAO codeRedisDao;
    @Resource
    private MesProBagCodeChunkWriter chunkWriter;
    @Resource
    private MesProBagCodeGenerateProperties properties;

    /**
     * 执行生成
     *
     * @param spec       生成参数
     * @param taskId     任务编号；为 null 表示同步生成，不回写进度
     * @param cancelFlag 取消标记
     * @return 生成结果（袋码数 + 托盘编号）
     */
    public GenerateResult generate(MesProBagCodeGenerateSpec spec, Long taskId, AtomicBoolean cancelFlag) {
        assertNotCancelled(cancelFlag);
        long deadline = System.currentTimeMillis()
                + Duration.ofMinutes(Math.max(1, properties.getMaxRuntimeMinutes())).toMillis();
        // 1. 全局袋序号一次性分配：后续分段只做偏移，避免每段都查库内最大值
        int startNo = codeRedisDao.allocateBagNoStart(spec.totalCount(), bagCodeMapper.selectMaxBagNo());
        // 2. 托盘（仅数据包模式且按 N 袋换算时生成）
        PalletRefs palletRefs = createPallets(spec, cancelFlag, deadline);
        // 3. 袋码分段落库
        int chunkSize = Math.max(1, properties.getChunkSize());
        int finished = 0;
        while (finished < spec.totalCount()) {
            assertNotCancelled(cancelFlag);
            assertNotTimeout(deadline);
            int size = Math.min(chunkSize, spec.totalCount() - finished);
            // 每个袋码需要追溯码 + 业务码
            List<String> codes = codeRedisDao.generateBatch(size * 2);
            List<MesProBagCodeDO> chunk = new ArrayList<>(size);
            for (int i = 0; i < size; i++) {
                int index = finished + i;
                PalletRef pallet = palletRefs.resolve(spec, index);
                chunk.add(new MesProBagCodeDO()
                        .setUuid(spec.uuid())
                        .setCode(codes.get(i * 2))
                        .setBusinessCode(codes.get(i * 2 + 1))
                        .setBagNo(startNo + index)
                        .setItemId(spec.itemId())
                        .setItemCode(spec.itemCode())
                        .setItemName(spec.itemName())
                        .setPalletId(pallet == null ? null : pallet.id())
                        .setPalletCode(pallet == null ? null : pallet.tempCode())
                        .setStatus(MesProBagCodeStatusEnum.GENERATED.getStatus())
                        .setRemark(spec.remark()));
            }
            chunkWriter.insertBagCodes(chunk);
            finished += size;
            if (taskId != null) {
                taskMapper.updateProgress(taskId, finished);
            }
        }
        return new GenerateResult(finished, palletRefs.ids());
    }

    /**
     * 按需创建托盘：数据包模式下袋码按「每托 N 袋」均分绑定
     */
    private PalletRefs createPallets(MesProBagCodeGenerateSpec spec,
                                     AtomicBoolean cancelFlag, long deadline) {
        if (spec.bizType() != MesProBagCodeGenerateBizTypeEnum.PACKAGE || spec.palletCount() <= 0) {
            return PalletRefs.EMPTY;
        }
        int chunkSize = Math.max(1, properties.getChunkSize());
        List<Long> ids = new ArrayList<>(spec.palletCount());
        List<String> tempCodes = new ArrayList<>(spec.palletCount());
        int created = 0;
        while (created < spec.palletCount()) {
            assertNotCancelled(cancelFlag);
            assertNotTimeout(deadline);
            int size = Math.min(chunkSize, spec.palletCount() - created);
            // 每个托盘需要临时码 + 业务码
            List<String> codes = codeRedisDao.generateBatch(size * 2);
            List<MesProPalletDO> pallets = new ArrayList<>(size);
            for (int i = 0; i < size; i++) {
                pallets.add(new MesProPalletDO()
                        .setTempCode(codes.get(i * 2))
                        .setBusinessCode(codes.get(i * 2 + 1))
                        .setBagCount(spec.perPallet())
                        .setAutoGenerated(true)
                        .setItemId(spec.itemId())
                        .setGenerateUuid(spec.uuid())
                        .setStatus(MesProPalletStatusEnum.IN_USE.getStatus()));
            }
            chunkWriter.insertPallets(pallets);
            pallets.forEach(pallet -> {
                ids.add(pallet.getId());
                tempCodes.add(pallet.getTempCode());
            });
            created += size;
        }
        return new PalletRefs(ids, tempCodes);
    }

    private void assertNotCancelled(AtomicBoolean cancelFlag) {
        if (cancelFlag != null && cancelFlag.get()) {
            throw new CancelledException();
        }
    }

    private void assertNotTimeout(long deadline) {
        if (System.currentTimeMillis() > deadline) {
            throw new IllegalStateException("生成任务超过最长运行时间（"
                    + properties.getMaxRuntimeMinutes() + " 分钟）");
        }
    }

    /**
     * 托盘引用：只保留袋码需要回写的两个字段，避免在内存中堆积整表 DO
     */
    private record PalletRefs(List<Long> ids, List<String> tempCodes) {

        private static final PalletRefs EMPTY = new PalletRefs(List.of(), List.of());

        private PalletRef resolve(MesProBagCodeGenerateSpec spec, int bagIndex) {
            if (ids.isEmpty() || spec.perPallet() <= 0) {
                return null;
            }
            int palletIndex = bagIndex / spec.perPallet();
            return new PalletRef(ids.get(palletIndex), tempCodes.get(palletIndex));
        }

    }

    private record PalletRef(Long id, String tempCode) {
    }

    /**
     * 生成结果：同步路径需要托盘编号用于响应，异步路径只关心完成数量
     */
    public record GenerateResult(int finishedCount, List<Long> palletIds) {
    }

    /**
     * 取消信号：生成线程检测到取消时抛出，由调用方统一清理半成品
     */
    public static class CancelledException extends RuntimeException {

        public CancelledException() {
            super("生成任务已取消");
        }

    }

}