package jnpf.elnService.template.impl;

import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jnpf.base.UserInfo;
import jnpf.database.util.TenantDataSourceUtil;
import jnpf.elnEntity.template.ElnTemplateStageEntity;
import jnpf.elnEntity.template.ElnTemplateStepEntity;
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
import jnpf.elnEntity.template.ElnTemplateRepeatGroupEntity;
import jnpf.elnEntity.template.ElnTemplateEnums;
import jnpf.elnEntity.template.ElnTemplateForms;
import jnpf.elnEntity.template.ElnTemplateVersionEntity;
import jnpf.elnEntity.template.ElnTemplateVos;
import jnpf.elnMapper.ElnTemplateMapper;
import jnpf.elnMapper.ElnTemplateStageMapper;
import jnpf.elnMapper.ElnTemplateStepMapper;
import jnpf.elnMapper.ElnTemplateBindingMapper;
import jnpf.elnMapper.ElnTemplateRepeatGroupMapper;
import jnpf.elnService.template.ElnTemplateStepService;
import jnpf.exception.DataException;
import jnpf.model.tenant.TenantVO;
import jnpf.util.UserProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;

@Service
public class ElnTemplateStepServiceImpl implements ElnTemplateStepService {

    private final Store store;
    private final Supplier<UserContext> userContextSupplier;
    private final Supplier<String> idSupplier;

    @Autowired
    public ElnTemplateStepServiceImpl(ElnTemplateMapper templateMapper,
            ElnTemplateStageMapper stageMapper, ElnTemplateStepMapper stepMapper,
            ElnTemplateBindingMapper bindingMapper,
            ElnTemplateRepeatGroupMapper repeatGroupMapper) {
        this(new MyBatisStore(templateMapper, stageMapper, stepMapper,
                        bindingMapper, repeatGroupMapper),
                ElnTemplateStepServiceImpl::currentUserContext, IdUtil::getSnowflakeNextIdStr);
    }

    ElnTemplateStepServiceImpl(Store store, Supplier<UserContext> userContextSupplier) {
        this(store, userContextSupplier, IdUtil::getSnowflakeNextIdStr);
    }

    ElnTemplateStepServiceImpl(Store store, Supplier<UserContext> userContextSupplier,
            Supplier<String> idSupplier) {
        this.store = store;
        this.userContextSupplier = userContextSupplier;
        this.idSupplier = idSupplier;
    }

    @Override
    @Transactional(readOnly = true)
    public ElnTemplateVos.StepConfiguration configuration(String templateId) {
        UserContext context = requireContext();
        String actualTemplateId = requireText(templateId, "模板不存在");
        return configuration(context.getTenantId(), actualTemplateId);
    }

    @Override
    @Transactional(readOnly = true)
    public ElnTemplateVos.StepFillStructure fillStructure(
            String tenantId, String templateId) {
        String actualTenantId = requireText(tenantId, "租户标识无效");
        String actualTemplateId = requireText(templateId, "模板不存在");
        ElnTemplateVos.StepFillStructure result = new ElnTemplateVos.StepFillStructure();
        result.setConfiguration(configuration(actualTenantId, actualTemplateId));

        Map<String, String> primarySteps = new LinkedHashMap<>();
        List<ElnTemplateBindingEntity> bindings = store.listBindings(
                actualTenantId, actualTemplateId);
        for (ElnTemplateBindingEntity binding : bindings) {
            if (!isActiveBinding(binding) || !"PRIMARY".equals(binding.getKongjianJuese())) {
                continue;
            }
            String stepId = requireText(binding.getStepId(), "模板普通字段步骤归属无效");
            primarySteps.put(binding.getId(), stepId);
            putControlStep(result, binding.getKongjianBiaoqian(), stepId);
        }

        Map<String, String> groupSteps = result.getRepeatGroupSteps();
        for (ElnTemplateRepeatGroupEntity group
                : store.listRepeatGroups(actualTenantId, actualTemplateId)) {
            String code = requireText(group.getRepeatGroupCode(), "模板重复组配置无效");
            String stepId = requireText(group.getStepId(), "模板重复组步骤归属无效");
            if (groupSteps.put(code, stepId) != null) {
                throw new DataException("模板重复组配置重复");
            }
        }

        for (ElnTemplateBindingEntity binding : bindings) {
            if (!isActiveBinding(binding)) continue;
            if ("REFERENCE".equals(binding.getKongjianJuese())) {
                String stepId = primarySteps.get(binding.getYinyongShiliId());
                if (!StringUtils.hasText(stepId)) {
                    throw new DataException("模板引用控件步骤归属无效");
                }
                putControlStep(result, binding.getKongjianBiaoqian(), stepId);
            } else if ("REPEAT".equals(binding.getKongjianJuese())) {
                String stepId = groupSteps.get(binding.getRepeatGroupCode());
                if (!StringUtils.hasText(stepId)) {
                    throw new DataException("模板重复列步骤归属无效");
                }
                putControlStep(result, binding.getKongjianBiaoqian(), stepId);
            }
        }
        return result;
    }

    private ElnTemplateVos.StepConfiguration configuration(
            String tenantId, String templateId) {
        ElnTemplateVersionEntity template = store.findTemplate(
                tenantId, templateId);
        if (template == null) throw new DataException("模板不存在");

        List<ElnTemplateStepEntity> steps = orderedSteps(tenantId, templateId);
        if (steps.isEmpty()) throw new DataException("模板版本未配置步骤");

        ElnTemplateVos.StepConfiguration result = new ElnTemplateVos.StepConfiguration();
        int order = 0;
        for (ElnTemplateStepEntity step : steps) result.getSteps().add(toStep(step, ++order));
        result.setSingleStep(result.getSteps().size() == 1);
        return result;
    }

    private List<ElnTemplateStepEntity> orderedSteps(String tenantId, String templateId) {
        List<ElnTemplateStageEntity> stages = store.listStages(tenantId, templateId);
        stages.sort(Comparator.comparing(ElnTemplateStageEntity::getPaixu,
                        Comparator.nullsLast(Integer::compareTo))
                .thenComparing(ElnTemplateStageEntity::getId));
        Map<String, Integer> stageOrder = new LinkedHashMap<>();
        int order = 0;
        for (ElnTemplateStageEntity stage : stages) stageOrder.put(stage.getId(), ++order);

        List<ElnTemplateStepEntity> steps = store.listSteps(tenantId, templateId);
        steps.sort(Comparator.comparing((ElnTemplateStepEntity step) ->
                        stageOrder.getOrDefault(step.getJieduanId(), Integer.MAX_VALUE))
                .thenComparing(ElnTemplateStepEntity::getPaixu,
                        Comparator.nullsLast(Integer::compareTo))
                .thenComparing(ElnTemplateStepEntity::getId));
        return steps;
    }

    private static void putControlStep(ElnTemplateVos.StepFillStructure result,
            String controlTag, String stepId) {
        String tag = requireText(controlTag, "模板控件标签无效");
        if (result.getControlSteps().put(tag, stepId) != null) {
            throw new DataException("模板控件标签重复");
        }
    }

    private static boolean isActiveBinding(ElnTemplateBindingEntity binding) {
        return binding != null && "ACTIVE".equals(binding.getBangdingZhuangtai())
                && !Integer.valueOf(1).equals(binding.getFDeleteMark());
    }

    @Override
    @Transactional
    public ElnTemplateVos.StepConfiguration save(
            String templateId, ElnTemplateForms.SaveStepConfiguration form) {
        UserContext context = requireContext();
        String actualTemplateId = requireText(templateId, "模板不存在");
        ElnTemplateVersionEntity template = store.findTemplateForUpdate(
                context.getTenantId(), actualTemplateId);
        if (template == null) throw new DataException("模板不存在");
        if (!ElnTemplateEnums.TemplateStatus.DRAFT.name().equals(template.getBizStatus())) {
            throw new DataException("只有草稿模板可以修改步骤");
        }
        List<ElnTemplateForms.Step> requested = form == null ? null : form.getSteps();
        if (requested == null || requested.isEmpty() || requested.size() > 20) {
            throw new DataException("模板步骤数量必须为 1 至 20 个");
        }

        Map<String, ElnTemplateStepEntity> existing = new LinkedHashMap<>();
        for (ElnTemplateStepEntity step : store.listSteps(context.getTenantId(), actualTemplateId)) {
            existing.put(step.getId(), step);
        }
        Set<String> seenIds = new LinkedHashSet<>();
        Set<String> seenNames = new LinkedHashSet<>();
        Set<String> targetStepIds = new LinkedHashSet<>();
        store.releaseStepUniqueness(context.getTenantId(), actualTemplateId);
        int order = 0;
        for (ElnTemplateForms.Step input : requested) {
            if (input == null) throw new DataException("模板步骤无效");
            String name = requireText(input.getName(), "步骤名称不能为空");
            if (name.length() > 100) throw new DataException("步骤名称不能超过 100 个字符");
            if (!seenNames.add(name.toLowerCase(Locale.ROOT))) {
                throw new DataException("步骤名称不能重复");
            }
            String requestedId = StringUtils.hasText(input.getId()) ? input.getId().trim() : null;
            ElnTemplateStepEntity target;
            if (requestedId == null) {
                target = new ElnTemplateStepEntity();
                target.setId(requireText(idSupplier.get(), "步骤标识生成失败"));
                target.setFTenantId(context.getTenantId());
                target.setMubanId(actualTemplateId);
                target.setFVersion(0);
                target.setFCreatorUserId(context.getUserId());
                target.setFCreatorTime(new Date());
                target.setFDeleteMark(0);
            } else {
                if (!seenIds.add(requestedId)) throw new DataException("步骤标识不能重复");
                ElnTemplateStepEntity current = existing.get(requestedId);
                if (current == null) throw new DataException("步骤不属于当前模板版本");
                target = copyStep(current);
            }
            targetStepIds.add(target.getId());
            target.setJieduanId(null);
            target.setBuzhouMingcheng(name);
            target.setPaixu(++order);
            reactivate(target);
            target.setFLastModifyUserId(context.getUserId());
            target.setFLastModifyTime(new Date());
            if (requestedId == null) store.insertStep(target);
            else store.updateStep(target);
        }
        migrateAndDeleteSteps(context, actualTemplateId, existing, targetStepIds,
                form.getStepMigrations());
        return configuration(actualTemplateId);
    }

    @Override
    @Transactional
    public void copyForVersion(String tenantId, String sourceTemplateId, String targetTemplateId) {
        String actualTenantId = requireText(tenantId, "租户标识无效");
        String sourceId = requireText(sourceTemplateId, "源模板版本无效");
        String targetId = requireText(targetTemplateId, "目标模板版本无效");
        if (sourceId.equals(targetId)) throw new DataException("源模板与目标模板不能相同");

        List<ElnTemplateStepEntity> sourceSteps = orderedSteps(actualTenantId, sourceId);
        if (sourceSteps.isEmpty()) throw new DataException("源模板版本未配置步骤");
        List<ElnTemplateStepEntity> targetSteps = store.listSteps(actualTenantId, targetId);
        Map<String, ElnTemplateStepEntity> copiedSteps = new LinkedHashMap<>();
        for (ElnTemplateStepEntity target : targetSteps) {
            if (StringUtils.hasText(target.getLaiyuanBuzhouId())) {
                copiedSteps.put(target.getLaiyuanBuzhouId(), target);
            }
        }
        ElnTemplateStepEntity reusableDefault = targetSteps.size() == 1
                && !StringUtils.hasText(targetSteps.get(0).getLaiyuanBuzhouId())
                ? targetSteps.get(0) : null;
        store.releaseStepUniqueness(actualTenantId, targetId);
        Map<String, String> stepIds = new LinkedHashMap<>();
        int order = 0;
        for (ElnTemplateStepEntity source : sourceSteps) {
            ElnTemplateStepEntity target = copiedSteps.get(source.getId());
            boolean created = target == null && reusableDefault == null;
            if (target == null) {
                target = reusableDefault;
                reusableDefault = null;
            }
            if (target == null) {
                target = new ElnTemplateStepEntity();
                target.setId(requireText(idSupplier.get(), "目标步骤标识生成失败"));
                target.setFTenantId(actualTenantId);
                target.setMubanId(targetId);
                target.setFVersion(0);
                target.setFCreatorTime(new Date());
                target.setFDeleteMark(0);
                created = true;
            }
            target.setJieduanId(null);
            target.setBuzhouMingcheng(source.getBuzhouMingcheng());
            target.setPaixu(++order);
            target.setLaiyuanBuzhouId(source.getId());
            reactivate(target);
            if (created) store.insertStep(target);
            else store.updateStep(target);
            stepIds.put(source.getId(), target.getId());
        }
        remapCopiedOwnership(actualTenantId, sourceId, targetId, stepIds);
    }

    @Override
    @Transactional(readOnly = true)
    public String resolveAssignment(
            String tenantId, String templateId, String requestedStepId) {
        String actualTenantId = requireText(tenantId, "租户标识无效");
        String actualTemplateId = requireText(templateId, "模板版本无效");
        List<ElnTemplateStepEntity> steps = store.listSteps(actualTenantId, actualTemplateId);
        if (steps.isEmpty()) throw new DataException("模板版本未配置步骤");
        if (StringUtils.hasText(requestedStepId)) {
            String actualStepId = requestedStepId.trim();
            for (ElnTemplateStepEntity step : steps) {
                if (actualStepId.equals(step.getId())) return actualStepId;
            }
            throw new DataException("所选步骤不属于当前模板版本");
        }
        if (steps.size() != 1) throw new DataException("多步骤模板必须选择当前步骤");
        return steps.get(0).getId();
    }

    @Override
    @Transactional(readOnly = true)
    public List<ElnTemplateVos.Diagnostic> validate(String tenantId, String templateId) {
        return validate(tenantId, templateId, null);
    }

    @Override
    @Transactional(readOnly = true)
    public List<ElnTemplateVos.Diagnostic> validate(
            String tenantId, String templateId, String templateAttachments) {
        List<ElnTemplateVos.Diagnostic> diagnostics = new ArrayList<>();
        List<ElnTemplateStepEntity> steps = store.listSteps(tenantId, templateId);
        if (steps.isEmpty() || steps.size() > 20) {
            diagnostics.add(diagnostic("INVALID_STEP_COUNT", "模板必须配置 1 至 20 个步骤", null));
            return diagnostics;
        }
        Set<String> stepIds = new LinkedHashSet<>();
        Set<String> stepNames = new LinkedHashSet<>();
        for (ElnTemplateStepEntity step : steps) {
            if (!StringUtils.hasText(step.getId()) || !StringUtils.hasText(step.getBuzhouMingcheng())
                    || !stepIds.add(step.getId())
                    || !stepNames.add(step.getBuzhouMingcheng().trim().toLowerCase(Locale.ROOT))) {
                diagnostics.add(diagnostic("INVALID_STEP", "模板步骤名称为空或重复", null));
            }
        }

        Set<String> occupiedSteps = new LinkedHashSet<>();
        Map<String, Set<String>> primaryStepsByField = new LinkedHashMap<>();
        List<ElnTemplateBindingEntity> bindings = store.listBindings(tenantId, templateId);
        for (ElnTemplateBindingEntity binding : bindings) {
            if (!isLiveBinding(binding)) continue;
            if ("PRIMARY".equals(binding.getKongjianJuese())) {
                if (!StringUtils.hasText(binding.getStepId())
                        || !stepIds.contains(binding.getStepId())) {
                    diagnostics.add(diagnostic("UNASSIGNED_PRIMARY_BINDING",
                            "普通主绑定未归属有效步骤", binding.getId()));
                    continue;
                }
                occupiedSteps.add(binding.getStepId());
                String fieldIdentity = StringUtils.hasText(binding.getZiduanDingyiId())
                        ? binding.getZiduanDingyiId() : binding.getZiduanBianma();
                primaryStepsByField.computeIfAbsent(fieldIdentity,
                        ignored -> new LinkedHashSet<>()).add(binding.getStepId());
            } else if (StringUtils.hasText(binding.getStepId())) {
                diagnostics.add(diagnostic("INHERITED_BINDING_HAS_STEP",
                        "引用控件或重复列不能保存独立步骤归属", binding.getId()));
            }
        }
        for (Set<String> assigned : primaryStepsByField.values()) {
            if (assigned.size() > 1) {
                diagnostics.add(diagnostic("MULTIPLE_STEP_ASSIGNMENT",
                        "同一普通字段被分配到多个步骤", null));
            }
        }
        for (ElnTemplateRepeatGroupEntity group : store.listRepeatGroups(tenantId, templateId)) {
            if (!StringUtils.hasText(group.getStepId()) || !stepIds.contains(group.getStepId())) {
                diagnostics.add(diagnostic("UNASSIGNED_REPEAT_GROUP",
                        "重复组未整体归属有效步骤", group.getId()));
            } else {
                occupiedSteps.add(group.getStepId());
            }
        }
        for (ElnTemplateStepEntity step : steps) {
            if (!occupiedSteps.contains(step.getId())) {
                diagnostics.add(diagnostic("EMPTY_STEP",
                        "步骤未包含普通字段或重复组：" + step.getBuzhouMingcheng(), null));
            }
        }
        return diagnostics;
    }

    private static boolean isLiveBinding(ElnTemplateBindingEntity binding) {
        if (binding == null || Integer.valueOf(1).equals(binding.getFDeleteMark())) return false;
        return "PENDING".equals(binding.getBangdingZhuangtai())
                || "ACTIVE".equals(binding.getBangdingZhuangtai());
    }

    private static ElnTemplateVos.Diagnostic diagnostic(
            String code, String message, String bindingId) {
        ElnTemplateVos.Diagnostic result = new ElnTemplateVos.Diagnostic();
        result.setSeverity("ERROR");
        result.setCode(code);
        result.setMessage(message);
        result.setBindingId(bindingId);
        return result;
    }

    private void remapCopiedOwnership(String tenantId, String sourceTemplateId,
            String targetTemplateId, Map<String, String> stepIds) {
        Map<String, ElnTemplateBindingEntity> sourceBindings = new LinkedHashMap<>();
        for (ElnTemplateBindingEntity source : store.listBindings(tenantId, sourceTemplateId)) {
            sourceBindings.put(source.getId(), source);
        }
        for (ElnTemplateBindingEntity target : store.listBindings(tenantId, targetTemplateId)) {
            if (!StringUtils.hasText(target.getLaiyuanBangdingId())) continue;
            ElnTemplateBindingEntity source = sourceBindings.get(target.getLaiyuanBangdingId());
            if (source == null || !"PRIMARY".equals(source.getKongjianJuese())) continue;
            String targetStepId = stepIds.get(source.getStepId());
            if (!StringUtils.hasText(targetStepId)) {
                throw new DataException("源模板普通字段步骤归属无效");
            }
            target.setStepId(targetStepId);
            store.updateBindingStep(target);
        }
        Map<String, ElnTemplateRepeatGroupEntity> sourceGroups = new LinkedHashMap<>();
        for (ElnTemplateRepeatGroupEntity source
                : store.listRepeatGroups(tenantId, sourceTemplateId)) {
            sourceGroups.put(source.getRepeatGroupCode(), source);
        }
        for (ElnTemplateRepeatGroupEntity target
                : store.listRepeatGroups(tenantId, targetTemplateId)) {
            ElnTemplateRepeatGroupEntity source = sourceGroups.get(target.getRepeatGroupCode());
            if (source == null) continue;
            String targetStepId = stepIds.get(source.getStepId());
            if (!StringUtils.hasText(targetStepId)) {
                throw new DataException("源模板重复组步骤归属无效");
            }
            target.setStepId(targetStepId);
            store.updateRepeatGroupStep(target);
        }
    }

    private void migrateAndDeleteSteps(UserContext context, String templateId,
            Map<String, ElnTemplateStepEntity> existing, Set<String> targetStepIds,
            Map<String, String> requestedMigrations) {
        Map<String, String> migrations = requestedMigrations == null
                ? new LinkedHashMap<>() : requestedMigrations;
        List<ElnTemplateBindingEntity> bindings = store.listBindings(
                context.getTenantId(), templateId);
        List<ElnTemplateRepeatGroupEntity> groups = store.listRepeatGroups(
                context.getTenantId(), templateId);
        for (ElnTemplateStepEntity removed : existing.values()) {
            if (targetStepIds.contains(removed.getId())) continue;
            String targetId = StringUtils.hasText(migrations.get(removed.getId()))
                    ? migrations.get(removed.getId()).trim() : null;
            boolean ownsBindings = false;
            for (ElnTemplateBindingEntity binding : bindings) {
                if (isLivePrimary(binding) && removed.getId().equals(binding.getStepId())) {
                    ownsBindings = true;
                }
            }
            boolean ownsGroups = false;
            for (ElnTemplateRepeatGroupEntity group : groups) {
                if (removed.getId().equals(group.getStepId())) ownsGroups = true;
            }
            if ((ownsBindings || ownsGroups) && targetId == null) {
                throw new DataException("有字段归属的步骤必须先显式迁移");
            }
            if (targetId != null && (!targetStepIds.contains(targetId)
                    || removed.getId().equals(targetId))) {
                throw new DataException("步骤迁移目标无效");
            }
            if (targetId != null) {
                for (ElnTemplateBindingEntity binding : bindings) {
                    if (isLivePrimary(binding) && removed.getId().equals(binding.getStepId())) {
                        binding.setStepId(targetId);
                        binding.setFLastModifyUserId(context.getUserId());
                        binding.setFLastModifyTime(new Date());
                        store.updateBindingStep(binding);
                    }
                }
                for (ElnTemplateRepeatGroupEntity group : groups) {
                    if (removed.getId().equals(group.getStepId())) {
                        group.setStepId(targetId);
                        group.setFLastModifyUserId(context.getUserId());
                        group.setFLastModifyTime(new Date());
                        store.updateRepeatGroupStep(group);
                    }
                }
            }
            ElnTemplateStepEntity deleted = copyStep(removed);
            deleted.setFDeleteMark(1);
            deleted.setFDeleteUserId(context.getUserId());
            deleted.setFDeleteTime(new Date());
            deleted.setFLastModifyUserId(context.getUserId());
            deleted.setFLastModifyTime(new Date());
            store.updateStep(deleted);
        }
    }

    private static boolean isLivePrimary(ElnTemplateBindingEntity binding) {
        if (binding == null || !"PRIMARY".equals(binding.getKongjianJuese())) {
            return false;
        }
        String status = binding.getBangdingZhuangtai();
        return ("PENDING".equals(status) || "ACTIVE".equals(status))
                && !Integer.valueOf(1).equals(binding.getFDeleteMark());
    }

    private static ElnTemplateStepEntity copyStep(ElnTemplateStepEntity source) {
        ElnTemplateStepEntity result = new ElnTemplateStepEntity();
        result.setId(source.getId());
        result.setMubanId(source.getMubanId());
        result.setJieduanId(source.getJieduanId());
        result.setBuzhouMingcheng(source.getBuzhouMingcheng());
        result.setPaixu(source.getPaixu());
        result.setLaiyuanBuzhouId(source.getLaiyuanBuzhouId());
        result.setFTenantId(source.getFTenantId());
        result.setFVersion(source.getFVersion());
        result.setFCreatorUserId(source.getFCreatorUserId());
        result.setFCreatorTime(source.getFCreatorTime());
        result.setFLastModifyUserId(source.getFLastModifyUserId());
        result.setFLastModifyTime(source.getFLastModifyTime());
        result.setFDeleteUserId(source.getFDeleteUserId());
        result.setFDeleteTime(source.getFDeleteTime());
        result.setFDeleteMark(source.getFDeleteMark());
        return result;
    }

    private static void reactivate(ElnTemplateStepEntity entity) {
        entity.setFDeleteMark(0);
        entity.setFDeleteUserId(null);
        entity.setFDeleteTime(null);
    }

    private static ElnTemplateVos.Step toStep(ElnTemplateStepEntity entity, int order) {
        ElnTemplateVos.Step result = new ElnTemplateVos.Step();
        result.setId(entity.getId());
        result.setName(entity.getBuzhouMingcheng());
        result.setOrder(order);
        return result;
    }

    private UserContext requireContext() {
        UserContext context = userContextSupplier.get();
        if (context == null || !StringUtils.hasText(context.getTenantId())) {
            throw new DataException("当前租户无效");
        }
        return context;
    }

    private static String requireText(String value, String message) {
        if (!StringUtils.hasText(value)) throw new DataException(message);
        return value.trim();
    }

    private static UserContext currentUserContext() {
        UserInfo user = UserProvider.getUser();
        TenantVO routed = TenantDataSourceUtil.getTenantInfo();
        String tenantId = routed != null && StringUtils.hasText(routed.getEnCode())
                ? routed.getEnCode().trim()
                : user != null && StringUtils.hasText(user.getTenantId())
                ? user.getTenantId().trim() : "0";
        String userId = user == null || !StringUtils.hasText(user.getUserId())
                ? null : user.getUserId().trim();
        return new UserContext(tenantId, userId);
    }

    static final class UserContext {
        private final String tenantId;
        private final String userId;

        UserContext(String tenantId, String userId) {
            this.tenantId = tenantId;
            this.userId = userId;
        }

        String getTenantId() { return tenantId; }
        String getUserId() { return userId; }
    }

    interface Store {
        ElnTemplateVersionEntity findTemplate(String tenantId, String templateId);
        ElnTemplateVersionEntity findTemplateForUpdate(String tenantId, String templateId);
        List<ElnTemplateStageEntity> listStages(String tenantId, String templateId);
        List<ElnTemplateStepEntity> listSteps(String tenantId, String templateId);
        List<ElnTemplateBindingEntity> listBindings(String tenantId, String templateId);
        List<ElnTemplateRepeatGroupEntity> listRepeatGroups(String tenantId, String templateId);
        void releaseStepUniqueness(String tenantId, String templateId);
        void insertStep(ElnTemplateStepEntity entity);
        void updateStep(ElnTemplateStepEntity entity);
        void updateBindingStep(ElnTemplateBindingEntity entity);
        void updateRepeatGroupStep(ElnTemplateRepeatGroupEntity entity);
    }

    private static final class MyBatisStore implements Store {
        private final ElnTemplateMapper templateMapper;
        private final ElnTemplateStageMapper stageMapper;
        private final ElnTemplateStepMapper stepMapper;
        private final ElnTemplateBindingMapper bindingMapper;
        private final ElnTemplateRepeatGroupMapper repeatGroupMapper;

        private MyBatisStore(ElnTemplateMapper templateMapper,
                ElnTemplateStageMapper stageMapper, ElnTemplateStepMapper stepMapper,
                ElnTemplateBindingMapper bindingMapper,
                ElnTemplateRepeatGroupMapper repeatGroupMapper) {
            this.templateMapper = templateMapper;
            this.stageMapper = stageMapper;
            this.stepMapper = stepMapper;
            this.bindingMapper = bindingMapper;
            this.repeatGroupMapper = repeatGroupMapper;
        }

        @Override
        public ElnTemplateVersionEntity findTemplate(String tenantId, String templateId) {
            return templateMapper.selectOne(Wrappers.<ElnTemplateVersionEntity>lambdaQuery()
                    .eq(ElnTemplateVersionEntity::getFTenantId, tenantId)
                    .eq(ElnTemplateVersionEntity::getId, templateId)
                    .and(q -> q.isNull(ElnTemplateVersionEntity::getFDeleteMark)
                            .or().eq(ElnTemplateVersionEntity::getFDeleteMark, 0)));
        }

        @Override
        public ElnTemplateVersionEntity findTemplateForUpdate(String tenantId, String templateId) {
            return templateMapper.lockTemplateForUpdate(tenantId, templateId);
        }

        @Override
        public List<ElnTemplateStageEntity> listStages(String tenantId, String templateId) {
            return new ArrayList<>(stageMapper.selectList(
                    Wrappers.<ElnTemplateStageEntity>lambdaQuery()
                            .eq(ElnTemplateStageEntity::getFTenantId, tenantId)
                            .eq(ElnTemplateStageEntity::getMubanId, templateId)
                            .and(q -> q.isNull(ElnTemplateStageEntity::getFDeleteMark)
                                    .or().eq(ElnTemplateStageEntity::getFDeleteMark, 0))));
        }

        @Override
        public List<ElnTemplateStepEntity> listSteps(String tenantId, String templateId) {
            return new ArrayList<>(stepMapper.selectList(
                    Wrappers.<ElnTemplateStepEntity>lambdaQuery()
                            .eq(ElnTemplateStepEntity::getFTenantId, tenantId)
                            .eq(ElnTemplateStepEntity::getMubanId, templateId)
                            .and(q -> q.isNull(ElnTemplateStepEntity::getFDeleteMark)
                                    .or().eq(ElnTemplateStepEntity::getFDeleteMark, 0))));
        }

        @Override
        public List<ElnTemplateBindingEntity> listBindings(String tenantId, String templateId) {
            return new ArrayList<>(bindingMapper.selectList(
                    Wrappers.<ElnTemplateBindingEntity>lambdaQuery()
                            .eq(ElnTemplateBindingEntity::getFTenantId, tenantId)
                            .eq(ElnTemplateBindingEntity::getMubanId, templateId)
                            .and(q -> q.isNull(ElnTemplateBindingEntity::getFDeleteMark)
                                    .or().eq(ElnTemplateBindingEntity::getFDeleteMark, 0))));
        }

        @Override
        public List<ElnTemplateRepeatGroupEntity> listRepeatGroups(
                String tenantId, String templateId) {
            return new ArrayList<>(repeatGroupMapper.selectList(
                    Wrappers.<ElnTemplateRepeatGroupEntity>lambdaQuery()
                            .eq(ElnTemplateRepeatGroupEntity::getFTenantId, tenantId)
                            .eq(ElnTemplateRepeatGroupEntity::getMubanId, templateId)
                            .and(q -> q.isNull(ElnTemplateRepeatGroupEntity::getFDeleteMark)
                                    .or().eq(ElnTemplateRepeatGroupEntity::getFDeleteMark, 0))));
        }

        @Override
        public void releaseStepUniqueness(String tenantId, String templateId) {
            stepMapper.update(null, Wrappers.<ElnTemplateStepEntity>lambdaUpdate()
                    .eq(ElnTemplateStepEntity::getFTenantId, tenantId)
                    .eq(ElnTemplateStepEntity::getMubanId, templateId)
                    .and(q -> q.isNull(ElnTemplateStepEntity::getFDeleteMark)
                            .or().eq(ElnTemplateStepEntity::getFDeleteMark, 0))
                    .set(ElnTemplateStepEntity::getFDeleteMark, 1));
        }


        @Override
        public void insertStep(ElnTemplateStepEntity entity) {
            stepMapper.insert(entity);
        }

        @Override
        public void updateStep(ElnTemplateStepEntity entity) {
            if (stepMapper.updateById(entity) != 1) {
                throw new DataException("步骤已被其他操作修改，请刷新后重试");
            }
        }

        @Override
        public void updateBindingStep(ElnTemplateBindingEntity entity) {
            if (bindingMapper.updateById(entity) != 1) {
                throw new DataException("字段归属已被其他操作修改，请刷新后重试");
            }
        }

        @Override
        public void updateRepeatGroupStep(ElnTemplateRepeatGroupEntity entity) {
            if (repeatGroupMapper.updateById(entity) != 1) {
                throw new DataException("重复组归属已被其他操作修改，请刷新后重试");
            }
        }
    }
}