package com.ruoyi.inhospvisit.service;

import com.ruoyi.common.core.service.PublicityDataPort;
import com.ruoyi.common.core.service.VisitTaskCreateApi;
import com.ruoyi.common.core.service.dto.VisitInhospUpdateDto;
import com.ruoyi.common.core.service.dto.VisitPendingSubtaskDto;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.service.dto.VisitArchiveRow;
import com.ruoyi.inhospvisit.domain.row.VisitInhospRow;
import com.ruoyi.inhospvisit.domain.row.VisitTaskdeptRow;
import com.ruoyi.inhospvisit.domain.row.VisitTaskdiagRow;
import com.ruoyi.inhospvisit.mapper.VisitArchiveMapper;
import com.ruoyi.inhospvisit.mapper.VisitInhospMapper;
import com.ruoyi.inhospvisit.mapper.VisitTaskdeptMapper;
import com.ruoyi.inhospvisit.mapper.VisitTaskdiagMapper;
import com.ruoyi.inhospvisit.support.InhospFlagWriter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * 出院随访「编排器」—— 逐行搬自 {@code PatMedInhospServiceImpl}
 * 的编排层（{@code addSubTaskByRule} + 3 个 {@code *ForPatient} + {@code dealInHospInfo}）。
 *
 * <h3>来源对照（@ b25c3b51）</h3>
 * <table border="1">
 *   <tr><th>本类方法</th><th>原实现</th><th>行数</th></tr>
 *   <tr><td>{@link #addSubTaskByRule}</td><td>{@code addSubTaskByRule} L1691-1847</td><td>157</td></tr>
 *   <tr><td>{@link #addDeptSubTaskForPatient}</td><td>L1854-1887</td><td>34</td></tr>
 *   <tr><td>{@link #addWardSubTaskForPatient}</td><td>L1894-1935</td><td>42</td></tr>
 *   <tr><td>{@link #addIcd10SubTaskForPatient}</td><td>L1942-2001</td><td>60</td></tr>
 *   <tr><td>{@link #dealInHospInfo}</td><td>L1321-1359</td><td>39</td></tr>
 * </table>
 *
 * <h3>⚠️ 三个 {@code *ForPatient} 的失败回写<b>写进去的列集合不同</b>，已逐一保真</h3>
 * <table border="1">
 *   <tr><th>位置</th><th>原写法</th><th>实际写入的列</th></tr>
 *   <tr><td>科室·无模板（L1866-1872）</td>
 *       <td>重读对象 {@code setDeptcheckFlag("2")}，另两个 flag 由重读对象原样带回</td>
 *       <td>deptcheck + wardcheck + diagcheck + reason</td></tr>
 *   <tr><td>科室·catch（L1879-1885）</td>
 *       <td>在<b>新鲜对象</b>上 set</td>
 *       <td>deptcheck + reason</td></tr>
 *   <tr><td>病区·失败（L1914-1920）</td>
 *       <td>重读对象 {@code setWardcheckFlag("2")}，另两个 flag 原样带回</td>
 *       <td>wardcheck + deptcheck + diagcheck + reason</td></tr>
 *   <tr><td>病区·catch（L1927-1933）</td>
 *       <td>在新鲜对象上 set</td>
 *       <td>wardcheck + reason</td></tr>
 *   <tr><td>疾病·两处（L1967-1971 / L1985-1991）</td>
 *       <td>重读对象 {@code setDiagcheckFlag("2")} 并覆写 reason</td>
 *       <td>diagcheck + reason（注意：<b>没有</b>带回其它两个 flag）</td></tr>
 *   <tr><td>疾病·catch（L1993-1998）</td>
 *       <td>在新鲜对象上 set</td>
 *       <td>diagcheck + reason</td></tr>
 * </table>
 * 因此本类用 {@link PublicityDataPort#updateVisitInhosp(VisitInhospUpdateDto)}（可一次写多个 flag），
 * 而不是窄的"单 flag"接口 —— 后者表达不了这些差异。
 *
 * <h3>⚠️ 站点差异（原样保留）</h3>
 * <ul>
 *   <li>{@code nhfy}：疾病维度改用<b>主诊断名称</b> {@code leavediagname} 查询，而不是 ICD10 编码
 *       （因为南华附一的 icd10code 有重复）；</li>
 *   <li>{@code xh}：{@code addSubTaskByRule} 里<b>整块跳过</b>病区 + 疾病两个维度（多处 {@code !xh} 判断）。</li>
 * </ul>
 */
@Slf4j
@Service
public class InhospTaskOrchestrator {

    /** 出院随访的服务类型 */
    private static final String SERVICE_TYPE_DISCHARGE = "2";

    /** 维度：科室 */
    private static final String DEPT_TYPE_DEPT = "1";

    /** 维度：病区 */
    private static final String DEPT_TYPE_WARD = "2";

    /** 站点：新华（跳过病区+疾病维度） */
    private static final String SITE_XH = "xh";

    /** 站点：南华附一（疾病维度用诊断名） */
    private static final String SITE_NHFY = "nhfy";

    @Value("${spring.profiles.active}")
    private String active;

    @Autowired
    private VisitInhospMapper inhospMapper;

    @Autowired
    private VisitArchiveMapper archiveMapper;

    @Autowired
    private VisitTaskdeptMapper taskdeptMapper;

    @Autowired
    private VisitTaskdiagMapper taskdiagMapper;

    @Autowired
    private InhospSubtaskWriter subtaskWriter;

    @Autowired
    private InhospFlagWriter flagWriter;

    @Autowired
    private ObjectProvider<PublicityDataPort> dataPortProvider;

    @Autowired
    private ObjectProvider<VisitTaskCreateApi> taskCreateApiProvider;

    // ==========================================================================
    // 1. 基于规则的任务生成（原 L1691-1847）
    // ==========================================================================

    /**
     * 按 {@code service_task_rule} 的「首要(1)/次要(2)」规则编排科室/病区/疾病三个维度。
     * <p>
     * 逐行对应原 {@code addSubTaskByRule(String config, List<PatMedInhosp> patMedInhosps)}。
     * <p>
     * ⚠️ 规则查询 {@code serviceTaskRuleMapper.selectServiceTaskRuleByDeptOrWard} 仍在 smartor，
     * 所以本方法接收<b>已查好的规则</b>（由调用方 {@code InhospVisitTaskService} 通过
     * {@code PublicityDataPort} 取——该端口已含"按科室/病区查规则"的能力，见下）。
     * 这样做是为了避免为"规则表"再加一个 Mapper 或端口。
     *
     * @param inhosp 待处理的出院患者
     * @param archive 患者档案
     * @param rule 已查好的规则；{@code null} = 未配置规则（全部生成）
     * @param config {@code sys_config: visit.early.day}
     */
    public void addSubTaskByRule(VisitInhospRow inhosp, VisitArchiveRow archive,
                                 VisitTaskRule rule, String config) {
        try {
            if (rule == null) {
                // 原 L1709-1716：规则为空，全部生成
                log.info("【基于规则】患者{}未配置规则，执行全部生成逻辑", inhosp.getInhospid());
                addDeptSubTaskForPatient(inhosp, archive, config);
                if (!SITE_XH.equals(active)) {
                    addWardSubTaskForPatient(inhosp, archive, config);
                    addIcd10SubTaskForPatient(inhosp, archive, config);
                }
                return;
            }
            // 原 L1717-1726：有规则，按规则执行
            log.info("【基于规则】患者{}查询到规则：deptRule={}, wradRule={}, diagRule={}",
                    inhosp.getInhospid(), rule.getDeptRule(), rule.getWradRule(), rule.getDiagRule());

            boolean deptIsPrimary = "1".equals(rule.getDeptRule());
            boolean wardIsPrimary = "1".equals(rule.getWradRule());
            boolean diagIsPrimary = "1".equals(rule.getDiagRule());
            boolean deptIsSecondary = "2".equals(rule.getDeptRule());
            boolean wardIsSecondary = "2".equals(rule.getWradRule());
            boolean diagIsSecondary = "2".equals(rule.getDiagRule());

            boolean hasPrimaryRule = deptIsPrimary || wardIsPrimary || diagIsPrimary;

            if (!hasPrimaryRule) {
                // 原 L1829-1837：没有首要规则，全部生成
                log.info("【基于规则】无首要规则，执行全部生成逻辑");
                addDeptSubTaskForPatient(inhosp, archive, config);
                if (!SITE_XH.equals(active)) {
                    addWardSubTaskForPatient(inhosp, archive, config);
                    addIcd10SubTaskForPatient(inhosp, archive, config);
                }
                return;
            }

            // 原 L1730-1754：先执行所有规则=1 的方法
            int deptGenCount = 0;
            int wardGenCount = 0;
            int diagGenCount = 0;

            if (deptIsPrimary) {
                log.info("【基于规则】执行科室首要规则");
                deptGenCount = addDeptSubTaskForPatient(inhosp, archive, config);
            }
            if (!SITE_XH.equals(active)) {
                if (wardIsPrimary) {
                    log.info("【基于规则】执行病区首要规则");
                    wardGenCount = addWardSubTaskForPatient(inhosp, archive, config);
                }
                if (diagIsPrimary) {
                    log.info("【基于规则】执行疾病首要规则");
                    diagGenCount = addIcd10SubTaskForPatient(inhosp, archive, config);
                }
            }

            int primaryGeneratedCount = deptGenCount + wardGenCount + diagGenCount;
            log.info("【基于规则】首要规则执行结果: deptGen={}, wardGen={}, diagGen={}, total={}",
                    deptGenCount, wardGenCount, diagGenCount, primaryGeneratedCount);

            String remark = inhosp.getRemark();

            if (primaryGeneratedCount > 0) {
                // 原 L1758-1796：至少一个首要规则成功
                log.info("【基于规则】首要规则有成功(count={})，将次要规则对应flag设为2", primaryGeneratedCount);
                if (deptIsSecondary) {
                    updateCheckFlag(inhosp, 1, "2", StringUtils.isNotEmpty(remark)
                            ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
                }
                if (!SITE_XH.equals(active)) {
                    if (wardIsSecondary) {
                        updateCheckFlag(inhosp, 2, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
                    }
                    if (diagIsSecondary) {
                        updateCheckFlag(inhosp, 3, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
                    }
                }
                if (deptIsPrimary && deptGenCount > 0) {
                    updateCheckFlag(inhosp, 1, "1", StringUtils.isNotEmpty(remark)
                            ? remark + ";科室首要规则生成成功" : "科室首要规则生成成功");
                }
                if (!SITE_XH.equals(active)) {
                    if (wardIsPrimary && wardGenCount > 0) {
                        updateCheckFlag(inhosp, 2, "1", StringUtils.isNotEmpty(remark)
                                ? remark + ";病区首要规则生成成功" : "病区首要规则生成成功");
                    }
                    if (diagIsPrimary && diagGenCount > 0) {
                        updateCheckFlag(inhosp, 3, "1", StringUtils.isNotEmpty(remark)
                                ? remark + ";疾病首要规则生成成功" : "疾病首要规则生成成功");
                    }
                }
                if (deptIsPrimary && deptGenCount == 0) {
                    updateCheckFlag(inhosp, 1, "2", StringUtils.isNotEmpty(remark)
                            ? remark + ";科室首要规则生成失败" : "科室首要规则生成失败");
                }
                if (!SITE_XH.equals(active)) {
                    if (wardIsPrimary && wardGenCount == 0) {
                        updateCheckFlag(inhosp, 2, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";病区首要规则生成失败" : "病区首要规则生成失败");
                    }
                    if (diagIsPrimary && diagGenCount == 0) {
                        updateCheckFlag(inhosp, 3, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";疾病首要规则生成失败" : "疾病首要规则生成失败");
                    }
                }
            } else {
                // 原 L1797-1828：所有首要规则全部失败 → 把 =1 的置 2，然后执行次要规则
                log.info("【基于规则】首要规则全部失败，将=1的flag设为2，开始执行次要规则");
                if (deptIsPrimary) {
                    updateCheckFlag(inhosp, 1, "2", StringUtils.isNotEmpty(remark)
                            ? remark + ";科室首要规则全部失败" : "科室首要规则全部失败");
                }
                if (!SITE_XH.equals(active)) {
                    if (wardIsPrimary) {
                        updateCheckFlag(inhosp, 2, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";病区首要规则全部失败" : "病区首要规则全部失败");
                    }
                    if (diagIsPrimary) {
                        updateCheckFlag(inhosp, 3, "2", StringUtils.isNotEmpty(remark)
                                ? remark + ";疾病首要规则全部失败" : "疾病首要规则全部失败");
                    }
                }
                if (deptIsSecondary) {
                    log.info("【基于规则】执行科室次要规则");
                    addDeptSubTaskForPatient(inhosp, archive, config);
                }
                if (!SITE_XH.equals(active)) {
                    if (wardIsSecondary) {
                        log.info("【基于规则】执行病区次要规则");
                        addWardSubTaskForPatient(inhosp, archive, config);
                    }
                    if (diagIsSecondary) {
                        log.info("【基于规则】执行疾病次要规则");
                        addIcd10SubTaskForPatient(inhosp, archive, config);
                    }
                }
            }
        } catch (Exception e) {
            // 原 L1839-1845
            e.printStackTrace();
            log.error("【基于规则】患者{}处理异常：{}", inhosp.getInhospid(), e.getMessage());
            updateCheckFlag(inhosp, 1, "2", "基于规则处理异常");
        }
    }

    /**
     * 统一回写标志位 —— 委托 {@link InhospFlagWriter}（原 {@code updateCheckFlag}）。
     */
    private void updateCheckFlag(VisitInhospRow inhosp, Integer type, String flagValue, String remark) {
        flagWriter.updateCheckFlag(inhosp, type, flagValue, remark);
    }

    // ==========================================================================
    // 2. 科室维度（原 L1854-1887）
    // ==========================================================================

    /**
     * 为单个患者生成科室维度的子任务。
     *
     * @return 生成的子任务数量
     */
    public int addDeptSubTaskForPatient(VisitInhospRow inhosp, VisitArchiveRow archive, String config) {
        int generatedCount = 0;
        try {
            // 原 L1857-1864：按患者所在科室查该科室的长期任务（dept_type=1 + service_type=2）
            VisitTaskdeptRow query = new VisitTaskdeptRow();
            query.setLongtask(1L);
            query.setDeptCode(inhosp.getLeaveldeptcode());
            query.setDeptType(DEPT_TYPE_DEPT);
            query.setServiceType(SERVICE_TYPE_DISCHARGE);
            query.setOrgid(inhosp.getOrgid());
            List<VisitTaskdeptRow> taskdepts = taskdeptMapper.selectList(query);

            if (CollectionUtils.isEmpty(taskdepts)) {
                // 原 L1866-1872：⚠️ 在【重读对象】上改 deptcheck，并把另两个 flag 原样带回
                VisitInhospRow fresh = inhospMapper.selectByInhospid(inhosp.getInhospid());
                VisitInhospUpdateDto u = new VisitInhospUpdateDto();
                u.setInhospid(inhosp.getInhospid());
                u.setDeptcheckFlag("2");
                u.setWardcheckFlag(fresh == null ? null : fresh.getWardcheckFlag());
                u.setDiagcheckFlag(fresh == null ? null : fresh.getDiagcheckFlag());
                // 原实现不判 null（fresh.getLongTaskReason() + "..."），原样保留
                u.setLongTaskReason((fresh == null ? null : fresh.getLongTaskReason())
                        + "该患者所在科室未配置离院长期任务;");
                updateInhosp(u);
            } else {
                for (VisitTaskdeptRow t : taskdepts) {
                    subtaskWriter.writeInSubTask(t.getTaskId(), true, inhosp, archive, 1, config);
                    generatedCount++;
                }
            }
        } catch (Exception e) {
            // 原 L1879-1885：⚠️ 在【新鲜对象】上 set —— 只写 deptcheck + reason
            e.printStackTrace();
            log.error("【科室任务】患者{}处理异常：{}", inhosp.getInhospid(), e.getMessage());
            VisitInhospUpdateDto u = new VisitInhospUpdateDto();
            u.setInhospid(inhosp.getInhospid());
            u.setDeptcheckFlag("2");
            u.setLongTaskReason("科室任务处理异常");
            updateInhosp(u);
        }
        return generatedCount;
    }

    // ==========================================================================
    // 3. 病区维度（原 L1894-1935）
    // ==========================================================================

    /**
     * 为单个患者生成病区维度的子任务。
     *
     * @return 生成的子任务数量
     */
    public int addWardSubTaskForPatient(VisitInhospRow inhosp, VisitArchiveRow archive, String config) {
        int generatedCount = 0;
        try {
            String errorreason = null;
            List<VisitTaskdeptRow> taskdeptList = null;
            // 原 L1899-1912
            if (!StringUtils.isEmpty(inhosp.getLeavehospitaldistrictcode())) {
                VisitTaskdeptRow query = new VisitTaskdeptRow();
                query.setLongtask(1L);
                query.setDeptCode(inhosp.getLeavehospitaldistrictcode());
                query.setDeptType(DEPT_TYPE_WARD);
                query.setServiceType(SERVICE_TYPE_DISCHARGE);
                query.setOrgid(inhosp.getOrgid());
                taskdeptList = taskdeptMapper.selectList(query);
                if (CollectionUtils.isEmpty(taskdeptList)) {
                    errorreason = "该患者所在病区未配置长期任务;";
                }
            } else {
                errorreason = "离院病区为空;";
            }

            if (StringUtils.isNotEmpty(errorreason)) {
                // 原 L1914-1920：⚠️ 重读对象 setWardcheck，另两个 flag 原样带回
                VisitInhospRow fresh = inhospMapper.selectByInhospid(inhosp.getInhospid());
                VisitInhospUpdateDto u = new VisitInhospUpdateDto();
                u.setInhospid(inhosp.getInhospid());
                u.setWardcheckFlag("2");
                u.setDeptcheckFlag(fresh == null ? null : fresh.getDeptcheckFlag());
                u.setDiagcheckFlag(fresh == null ? null : fresh.getDiagcheckFlag());
                // 原有判空（与科室维度那处不同），原样保留
                u.setLongTaskReason(StringUtils.isNotEmpty(fresh == null ? null : fresh.getLongTaskReason())
                        ? fresh.getLongTaskReason() + errorreason : errorreason);
                updateInhosp(u);
            } else {
                for (VisitTaskdeptRow t : taskdeptList) {
                    subtaskWriter.writeInSubTask(t.getTaskId(), true, inhosp, archive, 2, config);
                    generatedCount++;
                }
            }
        } catch (Exception e) {
            // 原 L1927-1933：新鲜对象 —— 只写 wardcheck + reason
            e.printStackTrace();
            log.error("【病区任务】患者{}处理异常：{}", inhosp.getInhospid(), e.getMessage());
            VisitInhospUpdateDto u = new VisitInhospUpdateDto();
            u.setInhospid(inhosp.getInhospid());
            u.setWardcheckFlag("2");
            u.setLongTaskReason("病区任务处理异常");
            updateInhosp(u);
        }
        return generatedCount;
    }

    // ==========================================================================
    // 4. 疾病维度（原 L1942-2001）
    // ==========================================================================

    /**
     * 为单个患者生成疾病维度的子任务。
     *
     * @return 生成的子任务数量
     */
    public int addIcd10SubTaskForPatient(VisitInhospRow inhosp, VisitArchiveRow archive, String config) {
        int generatedCount = 0;
        try {
            // 原 L1945-1947
            if (StringUtils.isEmpty(inhosp.getLeaveicd10code())) {
                return 0;
            }

            // 原 L1949-1963：站点差异 —— nhfy 用诊断名，其它用 ICD10 编码
            VisitTaskdiagRow query = new VisitTaskdiagRow();
            query.setLongtask(1L);
            if (SITE_NHFY.equals(active)) {
                query.setIcd10name(inhosp.getLeavediagname());
                if (StringUtils.isEmpty(inhosp.getLeavediagname())) {
                    // 原 L1954-1959：⚠️ 新鲜对象 —— 只写 diagcheck + reason（覆盖式）
                    VisitInhospUpdateDto u = new VisitInhospUpdateDto();
                    u.setInhospid(inhosp.getInhospid());
                    u.setDiagcheckFlag("2");
                    u.setLongTaskReason("该患者主诊断名称为空;");
                    updateInhosp(u);
                    return 0;
                }
            } else {
                query.setIcd10code(inhosp.getLeaveicd10code());
            }
            query.setOrgid(inhosp.getOrgid());
            List<VisitTaskdiagRow> taskdiags = taskdiagMapper.selectListByIcdName(query);

            if (CollectionUtils.isEmpty(taskdiags)) {
                // 原 L1967-1971：⚠️ 重读对象，但【只】setDiagcheckFlag + 覆写 reason
                //    （与科室/病区那两处不同：这里不带回其它 flag）
                VisitInhospUpdateDto u = new VisitInhospUpdateDto();
                u.setInhospid(inhosp.getInhospid());
                u.setDiagcheckFlag("2");
                u.setLongTaskReason("该患者所患疾病未配置长期任务;");
                updateInhosp(u);
            } else {
                int flag = 0;
                for (VisitTaskdiagRow t : taskdiags) {
                    // 原 L1975-1983：必须科室或病区能匹配上才建
                    if (StringUtils.isNotEmpty(t.getDeptCode())
                            && t.getDeptCode().equals(inhosp.getLeaveldeptcode())) {
                        subtaskWriter.writeInSubTask(t.getTaskId(), true, inhosp, archive, 3, config);
                        generatedCount++;
                        flag = 1;
                    } else if (StringUtils.isNotEmpty(t.getWardCode())
                            && t.getWardCode().equals(inhosp.getLeavehospitaldistrictcode())) {
                        subtaskWriter.writeInSubTask(t.getTaskId(), true, inhosp, archive, 3, config);
                        generatedCount++;
                        flag = 1;
                    }
                }
                if (flag == 0) {
                    // 原 L1985-1991
                    log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", inhosp.getInhospid());
                    VisitInhospUpdateDto u = new VisitInhospUpdateDto();
                    u.setInhospid(inhosp.getInhospid());
                    u.setDiagcheckFlag("2");
                    u.setLongTaskReason("该科室或病区对于患者所患疾病未配置长期任务;");
                    updateInhosp(u);
                }
            }
        } catch (Exception e) {
            // 原 L1993-1998：新鲜对象 —— 只写 diagcheck + reason
            e.printStackTrace();
            log.error("【疾病任务】患者{}处理异常：{}", inhosp.getInhospid(), e.getMessage());
            VisitInhospUpdateDto u = new VisitInhospUpdateDto();
            u.setInhospid(inhosp.getInhospid());
            u.setDiagcheckFlag("2");
            u.setLongTaskReason("疾病任务处理异常");
            updateInhosp(u);
        }
        return generatedCount;
    }

    // ==========================================================================
    // 5. 再入院处理（原 L1321-1359）
    // ==========================================================================

    /**
     * 再入院处理：新入院记录出现时，把该患者<b>旧的待执行随访</b>停掉。
     * <p>
     * 逐行对应原 {@code dealInHospInfo(List<PatMedInhosp> patMedInhospList)}。
     * <p>
     * ⚠️ 原实现的两个要点：
     * <ol>
     *   <li>查询条件是 {@code patid + sendstate=2}，<b>不设 taskid</b>（按患者全量查）；
     *       这里传 {@code null} 表示不按 taskid 过滤；</li>
     *   <li>景宁（{@code 47255004333112711A1001}）跳过停机 —— 不过这次判的是
     *       <b>{@code serviceSubtask1.getOrgid()}</b>（子任务的 orgid），不是入参患者的 orgid。</li>
     * </ol>
     *
     * @param newInHosp 新入院的出入院记录（用它和旧子任务的 endtime 做比较）
     */
    public void dealInHospInfo(VisitInhospRow newInHosp) {
        try {
            VisitTaskCreateApi api = taskApi();
            if (api == null) {
                log.warn("【出入院随访】VisitTaskCreateApi 不可用，跳过再入院处理。inhospid={}",
                        newInHosp.getInhospid());
                return;
            }
            // 原 L1324-1328：patid + sendstate=2（不设 taskid）
            List<VisitPendingSubtaskDto> pendingList =
                    api.findPendingSubtasks(newInHosp.getPatid(), null);
            if (CollectionUtils.isEmpty(pendingList)) {
                return;
            }
            for (VisitPendingSubtaskDto pending : pendingList) {
                // 原 L1332-1335：不是长期任务，不处理
                if (pending.getLongSendTime() == null) {
                    continue;
                }
                // 原 L1336-1340：⚠️ 判的是【子任务的 orgid】
                boolean firstVisit = ORG_JINGNING.equals(pending.getOrgid());
                if (firstVisit) {
                    continue;
                }
                // 原 L1342-1350：旧子任务的出院时间在新入院时间之前 → 停掉
                if (pending.getEndtime() != null && newInHosp.getStarttime() != null
                        && pending.getEndtime().before(newInHosp.getStarttime())) {
                    pending.setSendstate(4L);
                    pending.setIsVisitAgain(2);
                    pending.setRemark("患者再入院");
                    pending.setResult("error");
                    api.updatePendingSubtask(pending);
                }
            }
        } catch (Exception e) {
            // 原 L1355-1357
            log.error("入院数据信息出异常了：{},{}", newInHosp, e.getMessage());
        }
    }

    /** 景宁机构ID（原 L1338；与 InhospSubtaskWriter 里那份是同一常量，已逐字核对） */
    private static final String ORG_JINGNING = "47255004333112711A1001";

    // ==========================================================================
    // 辅助
    // ==========================================================================

    private void updateInhosp(VisitInhospUpdateDto u) {
        PublicityDataPort port = dataPort();
        if (port == null) {
            log.warn("【出入院随访】PublicityDataPort 不可用，无法写回标志位。inhospid={}", u.getInhospid());
            return;
        }
        port.updateVisitInhosp(u);
    }

    private PublicityDataPort dataPort() {
        if (dataPortProvider == null) {
            return null;
        }
        try {
            return dataPortProvider.stream().findFirst().orElse(null);
        } catch (Exception e) {
            log.warn("【出入院随访】获取 PublicityDataPort 失败：{}", e.toString());
            return null;
        }
    }

    private VisitTaskCreateApi taskApi() {
        if (taskCreateApiProvider == null) {
            return null;
        }
        try {
            return taskCreateApiProvider.stream().findFirst().orElse(null);
        } catch (Exception e) {
            log.warn("【出入院随访】获取 VisitTaskCreateApi 失败：{}", e.toString());
            return null;
        }
    }

    /**
     * {@code service_task_rule} 的规则快照（原 {@code ServiceTaskRule} 的随访侧视图）。
     * <p>
     * 规则查询本身仍由 {@code PublicityDataPort} 提供（它已经在服务宣教链路），
     * 本类只消费结果，避免为规则表再加一个 Mapper。
     */
    public static class VisitTaskRule {

        /** 科室规则："1"=首要 "2"=次要，其它=不参与 */
        private String deptRule;

        /** 病区规则（原字段名就是拼错的 {@code wradRule}，保持同名以免读错） */
        private String wradRule;

        /** 疾病规则 */
        private String diagRule;

        public String getDeptRule() {
            return deptRule;
        }

        public void setDeptRule(String deptRule) {
            this.deptRule = deptRule;
        }

        public String getWradRule() {
            return wradRule;
        }

        public void setWradRule(String wradRule) {
            this.wradRule = wradRule;
        }

        public String getDiagRule() {
            return diagRule;
        }

        public void setDiagRule(String diagRule) {
            this.diagRule = diagRule;
        }
    }

    /** 供测试/日志：本类是否拿到了必需的 Mapper */
    boolean hasMappers() {
        return inhospMapper != null && archiveMapper != null
                && taskdeptMapper != null && taskdiagMapper != null;
    }

    /** 预留：供日志使用的时间戳（避免 IDE 报未使用 import Date） */
    @SuppressWarnings("unused")
    private Date now() {
        return new Date();
    }
}