package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jnpf.audit.sdk.annotation.AuditLog;
import jnpf.exception.DataException;
import jnpf.permission.UserApi;
import jnpf.permission.entity.UserEntity;
import jnpf.tmsEntity.TmsQuestionBankEntity;
import jnpf.tmsEntity.TmsQuestionEntity;
import jnpf.tmsEntity.TmsQuestionOptionEntity;
import jnpf.tmsEntity.question.TmsQuestionBankOption;
import jnpf.tmsEntity.question.TmsQuestionExportForm;
import jnpf.tmsEntity.question.TmsQuestionForm;
import jnpf.tmsEntity.question.TmsQuestionImportResult;
import jnpf.tmsEntity.question.TmsQuestionOptionForm;
import jnpf.tmsEntity.question.TmsQuestionQuery;
import jnpf.tmsEntity.enums.TmsOpenClosedInvalid;
import jnpf.tmsEntity.enums.TmsQuestionLifeType;
import jnpf.tmsEntity.enums.TmsQuestionType;
import jnpf.tmsEntity.enums.TmsYesNo;
import jnpf.tmsMapper.TmsQuestionBankMapper;
import jnpf.tmsMapper.TmsQuestionMapper;
import jnpf.tmsMapper.TmsQuestionOptionMapper;
import jnpf.tmsService.TmsQuestionService;
import jnpf.tmsUtil.TmsExcelExportHelper;
import jnpf.tmsUtil.TmsExcelImportHelper;
import jnpf.util.DateUtil;
import jnpf.util.RandomUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class TmsQuestionServiceImpl implements TmsQuestionService {

    /** 导入/导出表头（顺序固定） */
    private static final List<String> EXCEL_HEADERS = Arrays.asList(
            "试题编号", "题库名称", "题型", "难度", "题干", "解析",
            "选项A", "选项B", "选项C", "选项D", "选项E", "选项F", "正确答案", "状态");
    private static final List<Integer> EXCEL_WIDTHS = Arrays.asList(
            80, 140, 70, 60, 280, 160, 100, 100, 100, 100, 100, 100, 100, 70);
    private static final String SOURCE_IMPORT = "import";
    private static final int EXPORT_LIMIT = 5000;

    private final TmsQuestionMapper questionMapper;
    private final TmsQuestionOptionMapper optionMapper;
    private final TmsQuestionBankMapper bankMapper;
    private final UserApi userApi;
    /**
     * 查询题库列表
     */
    @Override
    public List<TmsQuestionBankOption> listBanks() {
        LambdaQueryWrapper<TmsQuestionBankEntity> qw = new LambdaQueryWrapper<>();
        qw.orderByDesc(TmsQuestionBankEntity::getCreatorTime);
        List<TmsQuestionBankEntity> list = bankMapper.selectList(qw);
        List<TmsQuestionBankOption> result = new ArrayList<>(list.size());
        for (TmsQuestionBankEntity bank : list) {
            TmsQuestionBankOption opt = new TmsQuestionBankOption();
            opt.setId(bank.getId());
            opt.setFullName(bank.getBankName());
            result.add(opt);
        }
        return result;
    }
    /**
     * 查询管理员列表
     */
    @Override
    public List<Map<String, String>> listAdmins() {
        QueryWrapper<TmsQuestionEntity> qw = new QueryWrapper<>();
        qw.select("DISTINCT admin_user_id");
        qw.isNotNull("admin_user_id");
        qw.ne("admin_user_id", "");
        List<TmsQuestionEntity> rows = questionMapper.selectList(qw);
        List<String> userIds = rows.stream()
                .map(TmsQuestionEntity::getAdminUserId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList());
        if (userIds.isEmpty()) {
            return Collections.emptyList();
        }
        Map<String, String> nameMap = loadUserNames(userIds);
        List<Map<String, String>> result = new ArrayList<>();
        for (String userId : userIds) {
            Map<String, String> item = new HashMap<>(2);
            item.put("id", userId);
            item.put("fullName", nameMap.getOrDefault(userId, userId));
            result.add(item);
        }
        return result;
    }
    /**
     * 试题：条件分页查询列表
     */
    @Override
    public List<TmsQuestionForm> getList(TmsQuestionQuery query) {
        LambdaQueryWrapper<TmsQuestionEntity> qw = new LambdaQueryWrapper<>();
        if (StringUtil.isNotEmpty(query.getBankId())) {
            qw.eq(TmsQuestionEntity::getBankId, query.getBankId());
        }
        if (StringUtil.isNotEmpty(query.getQuestionType())) {
            qw.eq(TmsQuestionEntity::getQuestionType, query.getQuestionType());
        }
        if (StringUtil.isNotEmpty(query.getBizStatus())) {
            qw.eq(TmsQuestionEntity::getBizStatus, query.getBizStatus());
        }
        if (StringUtil.isNotEmpty(query.getLifeType())) {
            qw.eq(TmsQuestionEntity::getLifeType, query.getLifeType());
        }
        if (StringUtil.isNotEmpty(query.getAdminUserId())) {
            qw.eq(TmsQuestionEntity::getAdminUserId, query.getAdminUserId());
        }
        if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
            String kw = query.getKeyword().trim();
            qw.like(TmsQuestionEntity::getStem, kw);
        }
        qw.orderByDesc(TmsQuestionEntity::getCreatorTime);

        Page<TmsQuestionEntity> page = new Page<>(query.getCurrentPage(), query.getPageSize());
        Page<TmsQuestionEntity> result = questionMapper.selectPage(page, qw);
        List<TmsQuestionEntity> records = result.getRecords();

        Map<String, String> bankNames = loadBankNames(
                records.stream().map(TmsQuestionEntity::getBankId).filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList()));
        Map<String, String> userNames = loadUserNames(
                records.stream().map(TmsQuestionEntity::getAdminUserId).filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList()));

        List<TmsQuestionForm> list = new ArrayList<>(records.size());
        for (TmsQuestionEntity entity : records) {
            list.add(toForm(entity, bankNames, userNames, false));
        }
        query.setData(list, result.getTotal());
        return list;
    }
    /**
     * 试题：按主键查询详情
     */
    @Override
    public TmsQuestionForm getInfo(String id) {
        TmsQuestionEntity entity = questionMapper.selectById(id);
        if (entity == null) {
            throw new DataException("试题不存在");
        }
        Map<String, String> bankNames = loadBankNames(Collections.singletonList(entity.getBankId()));
        Map<String, String> userNames = loadUserNames(
                StringUtil.isEmpty(entity.getAdminUserId())
                        ? Collections.emptyList()
                        : Collections.singletonList(entity.getAdminUserId()));
        return toForm(entity, bankNames, userNames, true);
    }
    /**
     * 试题：新增
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String create(TmsQuestionForm form) {
        validateForm(form);
        String id = RandomUtil.uuId();
        Date now = new Date();
        String userId = UserProvider.getLoginUserId();

        TmsQuestionEntity entity = new TmsQuestionEntity();
        entity.setId(id);
        entity.setQuestionNo(nextQuestionNo());
        entity.setBankId(form.getBankId());
        entity.setQuestionType(form.getQuestionType());
        entity.setDifficulty(form.getDifficulty());
        entity.setSourceType(form.getSourceType());
        applyLifeFields(entity, form);
        entity.setStem(form.getStem());
        entity.setAnalysis(form.getAnalysis());
        entity.setAdminUserId(StringUtil.isNotEmpty(form.getAdminUserId()) ? form.getAdminUserId() : userId);
        entity.setBizStatus(StringUtil.isNotEmpty(form.getBizStatus()) ? form.getBizStatus() : TmsOpenClosedInvalid.OPEN.getCode());
        entity.setCreatorUserId(userId);
        entity.setCreatorTime(now);
        questionMapper.insert(entity);

        saveOptions(id, form.getOptions());
        refreshBankCount(form.getBankId());
        return id;
    }
    /**
     * 试题：更新
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(String id, TmsQuestionForm form) {
        TmsQuestionEntity entity = questionMapper.selectById(id);
        if (entity == null) {
            throw new DataException("试题不存在");
        }
        if (TmsOpenClosedInvalid.INVALID.equalsCode(entity.getBizStatus())) {
            throw new DataException("已废弃试题不可修改");
        }
        validateForm(form);

        String oldBankId = entity.getBankId();
        entity.setBankId(form.getBankId());
        entity.setQuestionType(form.getQuestionType());
        entity.setDifficulty(form.getDifficulty());
        entity.setSourceType(form.getSourceType());
        applyLifeFields(entity, form);
        entity.setStem(form.getStem());
        entity.setAnalysis(form.getAnalysis());
        if (StringUtil.isNotEmpty(form.getAdminUserId())) {
            entity.setAdminUserId(form.getAdminUserId());
        }
        if (StringUtil.isNotEmpty(form.getBizStatus())) {
            entity.setBizStatus(form.getBizStatus());
        }
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        questionMapper.updateById(entity);
        // 长期题清空过期时间（updateById 默认忽略 null）
        if (TmsQuestionLifeType.LONG.equalsCode(entity.getLifeType())) {
            questionMapper.update(null, new LambdaUpdateWrapper<TmsQuestionEntity>()
                    .eq(TmsQuestionEntity::getId, id)
                    .set(TmsQuestionEntity::getExpireTime, null));
        }

        // 选项全量替换
        LambdaQueryWrapper<TmsQuestionOptionEntity> delQw = new LambdaQueryWrapper<>();
        delQw.eq(TmsQuestionOptionEntity::getForeignId, id);
        optionMapper.delete(delQw);
        saveOptions(id, form.getOptions());

        refreshBankCount(oldBankId);
        if (!Objects.equals(oldBankId, form.getBankId())) {
            refreshBankCount(form.getBankId());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @AuditLog(action = "QUESTION_INVALIDATE", label = "废弃试题", bizType = "TMS_QUESTION",
            bizCodeExpr = "#id", targetTable = "tms_question", targetIdExpr = "#id")
    /**
     * 试题：作废
     */
    public void invalidate(String id) {
        TmsQuestionEntity entity = questionMapper.selectById(id);
        if (entity == null) {
            return;
        }
        if (TmsOpenClosedInvalid.INVALID.equalsCode(entity.getBizStatus())) {
            return;
        }
        if (TmsOpenClosedInvalid.OPEN.equalsCode(entity.getBizStatus())) {
            throw new DataException("请先设为不开放后再废弃");
        }
        // 可见弃用态：保留记录，列表可按状态筛选区分在用/弃用
        entity.setBizStatus(TmsOpenClosedInvalid.INVALID.getCode());
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        questionMapper.updateById(entity);
        refreshBankCount(entity.getBankId());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @AuditLog(action = "QUESTION_STATUS", label = "试题开放状态变更", bizType = "TMS_QUESTION",
            bizCodeExpr = "#id", targetTable = "tms_question", targetIdExpr = "#id",
            extraExpr = "{'bizStatus': #bizStatus}")
    /**
     * 设置业务状态
     */
    public void setBizStatus(String id, String bizStatus) {
        if (!TmsOpenClosedInvalid.OPEN.equalsCode(bizStatus) && !TmsOpenClosedInvalid.CLOSED.equalsCode(bizStatus)) {
            throw new DataException("状态无效，仅支持开放/不开放");
        }
        TmsQuestionEntity entity = questionMapper.selectById(id);
        if (entity == null) {
            throw new DataException("试题不存在或已删除");
        }
        if (TmsOpenClosedInvalid.INVALID.equalsCode(entity.getBizStatus())) {
            throw new DataException("已废弃试题不可开放或不开放");
        }
        entity.setBizStatus(bizStatus);
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        questionMapper.updateById(entity);
    }

    /**
     * 校验表单
     */
    private void validateForm(TmsQuestionForm form) {
        if (form == null) {
            throw new DataException("参数不能为空");
        }
        if (StringUtil.isEmpty(form.getBankId())) {
            throw new DataException("请选择所属题库");
        }
        if (StringUtil.isEmpty(form.getQuestionType())) {
            throw new DataException("请选择题型");
        }
        if (StringUtil.isEmpty(form.getStem())) {
            throw new DataException("请填写题干");
        }
        TmsQuestionBankEntity bank = bankMapper.selectById(form.getBankId());
        if (bank == null) {
            throw new DataException("题库不存在或已删除");
        }
        String lifeType = StringUtil.isNotEmpty(form.getLifeType())
                ? form.getLifeType()
                : TmsQuestionLifeType.LONG.getCode();
        if (TmsQuestionLifeType.of(lifeType) == null) {
            throw new DataException("时效类型无效，仅支持长期/临时");
        }
        if (TmsQuestionLifeType.TEMP.equalsCode(lifeType)) {
            if (StringUtil.isEmpty(form.getExpireTime())) {
                throw new DataException("临时试题请填写过期时间");
            }
            if (parseDate(form.getExpireTime()) == null) {
                throw new DataException("过期时间格式无效");
            }
        }
    }

    /** 写入时效类型与过期时间；长期题清空过期时间 */
    private void applyLifeFields(TmsQuestionEntity entity, TmsQuestionForm form) {
        String lifeType = StringUtil.isNotEmpty(form.getLifeType())
                ? form.getLifeType()
                : TmsQuestionLifeType.LONG.getCode();
        entity.setLifeType(lifeType);
        if (TmsQuestionLifeType.TEMP.equalsCode(lifeType)) {
            entity.setExpireTime(parseDate(form.getExpireTime()));
        } else {
            entity.setExpireTime(null);
        }
    }

    private static Date parseDate(String raw) {
        if (StringUtil.isEmpty(raw)) {
            return null;
        }
        try {
            return DateUtil.stringToDate(raw.trim());
        } catch (Exception ignored) {
            return null;
        }
    }

    /**
     * 保存试题选项
     */
    private void saveOptions(String questionId, List<TmsQuestionOptionForm> options) {
        if (options == null || options.isEmpty()) {
            return;
        }
        Date now = new Date();
        String userId = UserProvider.getLoginUserId();
        int i = 0;
        for (TmsQuestionOptionForm opt : options) {
            TmsQuestionOptionEntity row = new TmsQuestionOptionEntity();
            row.setId(RandomUtil.uuId());
            row.setForeignId(questionId);
            row.setSortNo(opt.getSortNo() != null ? opt.getSortNo() : ++i);
            row.setOptionLabel(opt.getOptionLabel());
            row.setOptionContent(opt.getOptionContent());
            row.setIsCorrect(StringUtil.isNotEmpty(opt.getIsCorrect()) ? opt.getIsCorrect() : "0");
            row.setCreatorUserId(userId);
            row.setCreatorTime(now);
            optionMapper.insert(row);
        }
    }

    /** 按题库下未删除且未废弃试题实计回写 question_count */
    private void refreshBankCount(String bankId) {
        if (StringUtil.isEmpty(bankId)) {
            return;
        }
        TmsQuestionBankEntity bank = bankMapper.selectById(bankId);
        if (bank == null) {
            return;
        }
        LambdaQueryWrapper<TmsQuestionEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsQuestionEntity::getBankId, bankId)
                .ne(TmsQuestionEntity::getBizStatus, TmsOpenClosedInvalid.INVALID.getCode());
        Long count = questionMapper.selectCount(qw);
        bank.setQuestionCount(count == null ? 0 : count.intValue());
        bank.setLastModifyUserId(UserProvider.getLoginUserId());
        bank.setLastModifyTime(new Date());
        bankMapper.updateById(bank);
    }

    /**
     * 试题编号：年份后两位 + 4 位流水，如 260001。
     * 按当年最大号 +1，含已删记录，避免流水回退。
     */
    private synchronized String nextQuestionNo() {
        String prefix = String.format("%02d", LocalDate.now().getYear() % 100);
        String maxNo = questionMapper.selectMaxQuestionNo(prefix);
        int next = 1;
        if (StringUtil.isNotEmpty(maxNo) && maxNo.length() >= 6 && maxNo.startsWith(prefix)) {
            try {
                next = Integer.parseInt(maxNo.substring(prefix.length())) + 1;
            } catch (NumberFormatException ignored) {
                next = 1;
            }
        }
        if (next > 9999) {
            throw new DataException("当年试题编号已用尽（" + prefix + "9999）");
        }
        return prefix + String.format("%04d", next);
    }

    /**
     * 实体转为表单/VO
     */
    private TmsQuestionForm toForm(
            TmsQuestionEntity entity,
            Map<String, String> bankNames,
            Map<String, String> userNames,
            boolean withOptions) {
        TmsQuestionForm form = new TmsQuestionForm();
        form.setId(entity.getId());
        form.setQuestionNo(entity.getQuestionNo());
        form.setBankId(entity.getBankId());
        form.setBankName(bankNames.get(entity.getBankId()));
        form.setQuestionType(entity.getQuestionType());
        form.setDifficulty(entity.getDifficulty());
        form.setSourceType(entity.getSourceType());
        form.setLifeType(StringUtil.isNotEmpty(entity.getLifeType())
                ? entity.getLifeType()
                : TmsQuestionLifeType.LONG.getCode());
        form.setExpireTime(entity.getExpireTime() == null
                ? null
                : DateUtil.dateToString(entity.getExpireTime(), "yyyy-MM-dd HH:mm:ss"));
        form.setStem(entity.getStem());
        form.setAnalysis(entity.getAnalysis());
        form.setAdminUserId(entity.getAdminUserId());
        form.setAdminUserName(userNames.get(entity.getAdminUserId()));
        form.setBizStatus(entity.getBizStatus());
        form.setCreatorTime(entity.getCreatorTime() == null
                ? null
                : DateUtil.dateToString(entity.getCreatorTime(), "yyyy-MM-dd HH:mm:ss"));
        if (withOptions) {
            form.setOptions(loadOptions(entity.getId()));
        }
        return form;
    }

    /**
     * 加载题目选项
     */
    private List<TmsQuestionOptionForm> loadOptions(String questionId) {
        LambdaQueryWrapper<TmsQuestionOptionEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsQuestionOptionEntity::getForeignId, questionId);
        qw.orderByAsc(TmsQuestionOptionEntity::getSortNo);
        List<TmsQuestionOptionEntity> rows = optionMapper.selectList(qw);
        List<TmsQuestionOptionForm> list = new ArrayList<>(rows.size());
        for (TmsQuestionOptionEntity row : rows) {
            TmsQuestionOptionForm opt = new TmsQuestionOptionForm();
            opt.setId(row.getId());
            opt.setSortNo(row.getSortNo());
            opt.setOptionLabel(row.getOptionLabel());
            opt.setOptionContent(row.getOptionContent());
            opt.setIsCorrect(row.getIsCorrect());
            list.add(opt);
        }
        return list;
    }

    /**
     * 加载题库名称
     */
    private Map<String, String> loadBankNames(List<String> bankIds) {
        if (bankIds == null || bankIds.isEmpty()) {
            return Collections.emptyMap();
        }
        List<TmsQuestionBankEntity> banks = bankMapper.selectBatchIds(bankIds);
        Map<String, String> map = new HashMap<>();
        for (TmsQuestionBankEntity bank : banks) {
            map.put(bank.getId(), bank.getBankName());
        }
        return map;
    }

    /**
     * 批量加载用户姓名
     */
    private Map<String, String> loadUserNames(List<String> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Collections.emptyMap();
        }
        try {
            List<UserEntity> users = userApi.getUserName(userIds);
            if (users == null || users.isEmpty()) {
                return Collections.emptyMap();
            }
            return users.stream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(UserEntity::getId, UserEntity::getRealName, (a, b) -> a));
        } catch (Exception ex) {
            return Collections.emptyMap();
        }
    }
    /**
     * 导出 Excel
     */
    @Override
    public void exportExcel(TmsQuestionExportForm form, HttpServletResponse response) {
        List<TmsQuestionEntity> entities = loadForExport(form);
        if (entities.isEmpty()) {
            throw new DataException("没有可导出的试题");
        }
        Map<String, String> bankNames = loadBankNames(
                entities.stream().map(TmsQuestionEntity::getBankId).filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList()));
        Map<String, List<TmsQuestionOptionForm>> optionMap = loadOptionsBatch(
                entities.stream().map(TmsQuestionEntity::getId).collect(Collectors.toList()));

        List<List<String>> rows = new ArrayList<>(entities.size());
        for (TmsQuestionEntity entity : entities) {
            List<TmsQuestionOptionForm> options = optionMap.getOrDefault(entity.getId(), Collections.emptyList());
            rows.add(toExportRow(entity, bankNames.get(entity.getBankId()), options));
        }
        try {
            TmsExcelExportHelper.writeSpreadsheet(response, "试题导出", "试题", EXCEL_HEADERS, EXCEL_WIDTHS, rows);
        } catch (IOException e) {
            throw new DataException("导出试题失败");
        }
    }
    /**
     * 下载导入模板
     */
    @Override
    public void downloadImportTemplate(HttpServletResponse response) {
        List<List<String>> samples = new ArrayList<>();
        samples.add(Arrays.asList(
                "", "示例题库", "单选", "一般", "GMP要求中，质量管理部门的职责是？", "示例解析",
                "批准产品质量", "生产排产", "设备维保", "销售推广", "", "", "A", "开放"));
        samples.add(Arrays.asList(
                "", "示例题库", "判断", "简单", "培训记录应长期保存。", "",
                "", "", "", "", "", "", "正确", "开放"));
        samples.add(Arrays.asList(
                "", "示例题库", "多选", "困难", "下列属于人员卫生要求的有？", "",
                "洗手", "更衣", "佩戴饰品", "进入洁净区前更衣", "", "", "A,B,D", "开放"));
        try {
            TmsExcelExportHelper.writeSpreadsheet(response, "试题导入模板", "试题", EXCEL_HEADERS, EXCEL_WIDTHS, samples);
        } catch (IOException e) {
            throw new DataException("下载导入模板失败");
        }
    }

    @Override
    @AuditLog(action = "QUESTION_IMPORT", label = "试题批量导入", bizType = "TMS_QUESTION",
            bizCodeExpr = "#fileName != null && !#fileName.isEmpty() ? #fileName : 'IMPORT'",
            targetTable = "tms_question", bizCodeRequired = false,
            extraExpr = "{'successCount': #result?.successCount, 'failCount': #result?.failCount}")
    /**
     * Excel 导入
     */
    public TmsQuestionImportResult importExcel(byte[] fileBytes, String fileName) {
        List<List<String>> rawRows = TmsExcelImportHelper.readRows(fileBytes, fileName);
        if (rawRows == null || rawRows.isEmpty()) {
            throw new DataException("导入文件无数据");
        }
        Map<String, Integer> headerIndex = buildHeaderIndex(rawRows.get(0));
        requireHeader(headerIndex, "题库名称");
        requireHeader(headerIndex, "题型");
        requireHeader(headerIndex, "题干");

        Map<String, String> bankIdByName = loadBankIdByName();
        TmsQuestionImportResult result = new TmsQuestionImportResult();
        for (int i = 1; i < rawRows.size(); i++) {
            List<String> row = rawRows.get(i);
            int excelRow = i + 1;
            try {
                TmsQuestionForm form = parseImportRow(row, headerIndex, bankIdByName);
                if (form == null) {
                    continue;
                }
                form.setSourceType(SOURCE_IMPORT);
                if (StringUtil.isEmpty(form.getBizStatus())) {
                    form.setBizStatus(TmsOpenClosedInvalid.OPEN.getCode());
                }
                create(form);
                result.addSuccess();
            } catch (Exception ex) {
                String msg = ex.getMessage() == null ? "未知错误" : ex.getMessage();
                result.addError("第" + excelRow + "行：" + msg);
            }
        }
        if (result.getSuccessCount() == 0 && result.getFailCount() == 0) {
            throw new DataException("未识别到有效数据行，请检查模板表头与内容");
        }
        return result;
    }

    /**
     * 加载导出数据
     */
    private List<TmsQuestionEntity> loadForExport(TmsQuestionExportForm form) {
        LambdaQueryWrapper<TmsQuestionEntity> qw = new LambdaQueryWrapper<>();
        if (form != null && form.getIds() != null && !form.getIds().isEmpty()) {
            List<String> ids = form.getIds().stream().filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
            if (ids.isEmpty()) {
                return Collections.emptyList();
            }
            qw.in(TmsQuestionEntity::getId, ids);
        } else {
            if (form != null) {
                if (StringUtil.isNotEmpty(form.getBankId())) {
                    qw.eq(TmsQuestionEntity::getBankId, form.getBankId());
                }
                if (StringUtil.isNotEmpty(form.getQuestionType())) {
                    qw.eq(TmsQuestionEntity::getQuestionType, form.getQuestionType());
                }
                if (StringUtil.isNotEmpty(form.getBizStatus())) {
                    qw.eq(TmsQuestionEntity::getBizStatus, form.getBizStatus());
                }
                if (StringUtil.isNotEmpty(form.getLifeType())) {
                    qw.eq(TmsQuestionEntity::getLifeType, form.getLifeType());
                }
                if (StringUtil.isNotEmpty(form.getKeyword()) && !"null".equalsIgnoreCase(form.getKeyword())) {
                    String kw = form.getKeyword().trim();
                    qw.like(TmsQuestionEntity::getStem, kw);
                }
            }
            qw.last("LIMIT " + EXPORT_LIMIT);
        }
        qw.orderByDesc(TmsQuestionEntity::getCreatorTime);
        return questionMapper.selectList(qw);
    }

    /**
     * 批量加载题目选项
     */
    private Map<String, List<TmsQuestionOptionForm>> loadOptionsBatch(List<String> questionIds) {
        if (questionIds == null || questionIds.isEmpty()) {
            return Collections.emptyMap();
        }
        LambdaQueryWrapper<TmsQuestionOptionEntity> qw = new LambdaQueryWrapper<>();
        qw.in(TmsQuestionOptionEntity::getForeignId, questionIds);
        qw.orderByAsc(TmsQuestionOptionEntity::getSortNo);
        List<TmsQuestionOptionEntity> rows = optionMapper.selectList(qw);
        Map<String, List<TmsQuestionOptionForm>> map = new HashMap<>();
        for (TmsQuestionOptionEntity row : rows) {
            TmsQuestionOptionForm opt = new TmsQuestionOptionForm();
            opt.setId(row.getId());
            opt.setSortNo(row.getSortNo());
            opt.setOptionLabel(row.getOptionLabel());
            opt.setOptionContent(row.getOptionContent());
            opt.setIsCorrect(row.getIsCorrect());
            map.computeIfAbsent(row.getForeignId(), k -> new ArrayList<>()).add(opt);
        }
        return map;
    }

    /**
     * 转为导出行
     */
    private List<String> toExportRow(TmsQuestionEntity entity, String bankName, List<TmsQuestionOptionForm> options) {
        String[] optContents = new String[6];
        Arrays.fill(optContents, "");
        List<String> correctLabels = new ArrayList<>();
        if (options != null) {
            for (TmsQuestionOptionForm opt : options) {
                String label = opt.getOptionLabel() == null ? "" : opt.getOptionLabel().trim().toUpperCase(Locale.ROOT);
                int idx = label.length() == 1 && label.charAt(0) >= 'A' && label.charAt(0) <= 'F'
                        ? label.charAt(0) - 'A' : -1;
                if (idx >= 0) {
                    optContents[idx] = nvl(opt.getOptionContent());
                }
                if (TmsYesNo.isYesCode(opt.getIsCorrect())) {
                    if (TmsQuestionType.JUDGE.equalsCode(entity.getQuestionType())) {
                        correctLabels.add(labelJudgeAnswer(opt));
                    } else if (TmsQuestionType.BLANK.equalsCode(entity.getQuestionType())
                            || TmsQuestionType.ESSAY.equalsCode(entity.getQuestionType())) {
                        correctLabels.add(nvl(opt.getOptionContent()));
                    } else if (StringUtil.isNotEmpty(label)) {
                        correctLabels.add(label);
                    }
                }
            }
            // 判断题未标 A/B 时，按内容导出
            if (TmsQuestionType.JUDGE.equalsCode(entity.getQuestionType()) && correctLabels.isEmpty()) {
                for (TmsQuestionOptionForm opt : options) {
                    if (TmsYesNo.isYesCode(opt.getIsCorrect())) {
                        correctLabels.add(labelJudgeAnswer(opt));
                    }
                }
            }
            // 填空：全部选项内容按顺序作为答案
            if (TmsQuestionType.BLANK.equalsCode(entity.getQuestionType()) && correctLabels.isEmpty()) {
                for (TmsQuestionOptionForm opt : options) {
                    if (StringUtil.isNotEmpty(opt.getOptionContent())) {
                        correctLabels.add(opt.getOptionContent().trim());
                    }
                }
            }
        }
        String answer = String.join(
                TmsQuestionType.BLANK.equalsCode(entity.getQuestionType()) ? "|" : ",",
                correctLabels);
        return Arrays.asList(
                nvl(entity.getQuestionNo()),
                nvl(bankName),
                labelQuestionType(entity.getQuestionType()),
                labelDifficulty(entity.getDifficulty()),
                stripHtml(entity.getStem()),
                stripHtml(entity.getAnalysis()),
                optContents[0], optContents[1], optContents[2],
                optContents[3], optContents[4], optContents[5],
                answer,
                labelBizStatus(entity.getBizStatus()));
    }

    /**
     * 判断题答案标签
     */
    private static String labelJudgeAnswer(TmsQuestionOptionForm opt) {
        String content = nvl(opt.getOptionContent());
        String label = opt.getOptionLabel() == null ? "" : opt.getOptionLabel().trim().toUpperCase(Locale.ROOT);
        if (content.contains("正确") || "T".equals(label) || "A".equals(label) || "对".equals(content)) {
            return "正确";
        }
        if (content.contains("错误") || "F".equals(label) || "B".equals(label) || "错".equals(content)) {
            return "错误";
        }
        return StringUtil.isNotEmpty(content) ? content : label;
    }

    /**
     * 解析导入行
     */
    private TmsQuestionForm parseImportRow(List<String> row, Map<String, Integer> headerIndex,
                                          Map<String, String> bankIdByName) {
        String bankName = cell(row, headerIndex, "题库名称");
        String typeLabel = cell(row, headerIndex, "题型");
        String stem = cell(row, headerIndex, "题干");
        if (StringUtil.isEmpty(bankName) && StringUtil.isEmpty(typeLabel) && StringUtil.isEmpty(stem)) {
            return null;
        }
        if (StringUtil.isEmpty(bankName)) {
            throw new DataException("题库名称不能为空");
        }
        if (StringUtil.isEmpty(stem)) {
            throw new DataException("题干不能为空");
        }
        String bankId = bankIdByName.get(bankName.trim());
        if (StringUtil.isEmpty(bankId)) {
            throw new DataException("题库不存在：" + bankName);
        }
        String questionType = parseQuestionType(typeLabel);
        if (StringUtil.isEmpty(questionType)) {
            throw new DataException("题型无效：" + typeLabel);
        }

        TmsQuestionForm form = new TmsQuestionForm();
        form.setBankId(bankId);
        form.setQuestionType(questionType);
        form.setDifficulty(parseDifficulty(cell(row, headerIndex, "难度")));
        form.setStem(stem);
        form.setAnalysis(cell(row, headerIndex, "解析"));
        form.setBizStatus(parseBizStatus(cell(row, headerIndex, "状态")));
        form.setOptions(buildOptions(
                questionType,
                Arrays.asList(
                        cell(row, headerIndex, "选项A"),
                        cell(row, headerIndex, "选项B"),
                        cell(row, headerIndex, "选项C"),
                        cell(row, headerIndex, "选项D"),
                        cell(row, headerIndex, "选项E"),
                        cell(row, headerIndex, "选项F")),
                cell(row, headerIndex, "正确答案")));
        return form;
    }

    /**
     * 构建选项列表
     */
    private List<TmsQuestionOptionForm> buildOptions(String questionType, List<String> optionTexts, String answerRaw) {
        List<TmsQuestionOptionForm> options = new ArrayList<>();
        String answer = answerRaw == null ? "" : answerRaw.trim();
        if (TmsQuestionType.JUDGE.equalsCode(questionType)) {
            boolean trueCorrect = isTrueAnswer(answer);
            options.add(option("A", "正确", trueCorrect));
            options.add(option("B", "错误", !trueCorrect && StringUtil.isNotEmpty(answer)));
            if (StringUtil.isEmpty(answer)) {
                throw new DataException("判断题请填写正确答案（正确/错误）");
            }
            return options;
        }
        if (TmsQuestionType.BLANK.equalsCode(questionType)) {
            String[] parts = answer.split("[|｜;；]");
            int i = 0;
            for (String part : parts) {
                if (StringUtil.isEmpty(part)) {
                    continue;
                }
                i++;
                options.add(option(String.valueOf(i), part.trim(), true));
            }
            if (options.isEmpty()) {
                throw new DataException("填空题请在正确答案中填写答案，多个用|分隔");
            }
            return options;
        }
        if (TmsQuestionType.ESSAY.equalsCode(questionType)) {
            if (StringUtil.isNotEmpty(answer)) {
                options.add(option("1", answer, true));
            }
            return options;
        }
        // 单选 / 多选
        char label = 'A';
        for (String text : optionTexts) {
            if (StringUtil.isEmpty(text)) {
                label++;
                continue;
            }
            String lab = String.valueOf(label);
            boolean correct = isChoiceCorrect(answer, lab);
            options.add(option(lab, text.trim(), correct));
            label++;
        }
        if (options.size() < 2) {
            throw new DataException("选择题至少需要两个选项");
        }
        boolean anyCorrect = options.stream().anyMatch(o -> TmsYesNo.isYesCode(o.getIsCorrect()));
        if (!anyCorrect) {
            throw new DataException("请填写正确答案，如 A 或 A,C");
        }
        return options;
    }

    /**
     * 构建选项
     */
    private static TmsQuestionOptionForm option(String label, String content, boolean correct) {
        TmsQuestionOptionForm opt = new TmsQuestionOptionForm();
        opt.setOptionLabel(label);
        opt.setOptionContent(content);
        opt.setIsCorrect(correct ? TmsYesNo.YES.getCode() : TmsYesNo.NO.getCode());
        return opt;
    }

    /**
     * 判断选择题正误
     */
    private static boolean isChoiceCorrect(String answer, String label) {
        if (StringUtil.isEmpty(answer) || StringUtil.isEmpty(label)) {
            return false;
        }
        String normalized = answer.toUpperCase(Locale.ROOT).replace("，", ",").replace(" ", "");
        for (String part : normalized.split("[,|/、]")) {
            if (label.equalsIgnoreCase(part.trim())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否为正确答案
     */
    private static boolean isTrueAnswer(String answer) {
        if (StringUtil.isEmpty(answer)) {
            return false;
        }
        String v = answer.trim().toLowerCase(Locale.ROOT);
        return "正确".equals(answer.trim()) || "对".equals(answer.trim()) || "true".equals(v)
                || "t".equals(v) || "y".equals(v) || "yes".equals(v) || "a".equals(v) || "1".equals(v);
    }

    /**
     * 按题库名解析 ID
     */
    private Map<String, String> loadBankIdByName() {
        List<TmsQuestionBankEntity> banks = bankMapper.selectList(new LambdaQueryWrapper<>());
        Map<String, String> map = new LinkedHashMap<>();
        for (TmsQuestionBankEntity bank : banks) {
            if (bank != null && StringUtil.isNotEmpty(bank.getBankName())) {
                map.put(bank.getBankName().trim(), bank.getId());
            }
        }
        return map;
    }

    /**
     * 构建表头列索引
     */
    private static Map<String, Integer> buildHeaderIndex(List<String> headerRow) {
        Map<String, Integer> map = new HashMap<>();
        if (headerRow == null) {
            return map;
        }
        for (int i = 0; i < headerRow.size(); i++) {
            String h = headerRow.get(i);
            if (StringUtil.isNotEmpty(h)) {
                map.put(h.trim(), i);
            }
        }
        return map;
    }

    /**
     * 校验并获取导入表头
     */
    private static void requireHeader(Map<String, Integer> headerIndex, String name) {
        if (!headerIndex.containsKey(name)) {
            throw new DataException("导入模板缺少列：" + name);
        }
    }

    /**
     * 导出单元格文本
     */
    private static String cell(List<String> row, Map<String, Integer> headerIndex, String name) {
        Integer idx = headerIndex.get(name);
        if (idx == null || row == null || idx < 0 || idx >= row.size()) {
            return "";
        }
        String v = row.get(idx);
        return v == null ? "" : v.trim();
    }

    /**
     * 解析题型
     */
    private static String parseQuestionType(String raw) {
        if (StringUtil.isEmpty(raw)) {
            return null;
        }
        String v = raw.trim();
        TmsQuestionType byCode = TmsQuestionType.of(v);
        if (byCode != null) {
            return byCode.getCode();
        }
        switch (v) {
            case "单选":
            case "单选题":
                return TmsQuestionType.SINGLE.getCode();
            case "多选":
            case "多选题":
                return TmsQuestionType.MULTI.getCode();
            case "判断":
            case "判断题":
                return TmsQuestionType.JUDGE.getCode();
            case "填空":
            case "填空题":
                return TmsQuestionType.BLANK.getCode();
            case "问答":
            case "问答题":
            case "简答":
                return TmsQuestionType.ESSAY.getCode();
            default:
                return null;
        }
    }

    /**
     * 解析难度
     */
    private static String parseDifficulty(String raw) {
        if (StringUtil.isEmpty(raw)) {
            return "normal";
        }
        String v = raw.trim();
        if ("easy".equalsIgnoreCase(v) || "简单".equals(v)) {
            return "easy";
        }
        if ("hard".equalsIgnoreCase(v) || "困难".equals(v) || "难".equals(v)) {
            return "hard";
        }
        return "normal";
    }

    /**
     * 解析业务状态
     */
    private static String parseBizStatus(String raw) {
        if (StringUtil.isEmpty(raw)) {
            return TmsOpenClosedInvalid.OPEN.getCode();
        }
        String v = raw.trim();
        if (TmsOpenClosedInvalid.CLOSED.equalsCode(v) || "关闭".equals(v) || "不开放".equals(v) || "停用".equals(v)) {
            return TmsOpenClosedInvalid.CLOSED.getCode();
        }
        if (TmsOpenClosedInvalid.INVALID.equalsCode(v) || "作废".equals(v) || "废弃".equals(v)) {
            return TmsOpenClosedInvalid.INVALID.getCode();
        }
        return TmsOpenClosedInvalid.OPEN.getCode();
    }

    /**
     * 题型字典标签
     */
    private static String labelQuestionType(String code) {
        TmsQuestionType t = TmsQuestionType.of(code);
        return t == null ? nvl(code) : t.getLabel();
    }

    /**
     * 难度字典标签
     */
    private static String labelDifficulty(String code) {
        if ("easy".equalsIgnoreCase(code)) {
            return "简单";
        }
        if ("hard".equalsIgnoreCase(code)) {
            return "困难";
        }
        if ("normal".equalsIgnoreCase(code) || StringUtil.isEmpty(code)) {
            return "一般";
        }
        return code;
    }

    /**
     * 业务状态标签
     */
    private static String labelBizStatus(String code) {
        TmsOpenClosedInvalid s = TmsOpenClosedInvalid.of(code);
        return s == null ? nvl(code) : s.getLabel();
    }

    /**
     * 去除 HTML 标签
     */
    private static String stripHtml(String html) {
        if (StringUtil.isEmpty(html)) {
            return "";
        }
        return html.replaceAll("<[^>]+>", " ")
                .replace("&nbsp;", " ")
                .replaceAll("\\s+", " ")
                .trim();
    }

    /**
     * 空值兜底
     */
    private static String nvl(String v) {
        return v == null ? "" : v;
    }
}