//package com.ruoyi.inhospvisit.api;
//
//import com.ruoyi.common.core.service.IConfigService;
//import com.ruoyi.common.core.service.dto.VisitAgainSubtaskDto;
//import com.ruoyi.inhospvisit.config.InhospVisitAvailabilityInterceptor;
//import com.ruoyi.inhospvisit.config.InhospVisitProperties;
//import com.ruoyi.inhospvisit.config.InhospVisitSwitch;
//import com.ruoyi.inhospvisit.config.InhospVisitWebConfig;
//import org.springframework.beans.factory.ObjectProvider;
//import org.springframework.context.annotation.AnnotationConfigApplicationContext;
//
//import java.util.concurrent.atomic.AtomicInteger;
//
///**
// * 出入院随访模块的 <b>Spring 容器装配校验</b>（不依赖 JUnit、不依赖数据库）。
// *
// * <p>照抄 {@code SatisfactionContextCheck} 的做法：用真实的（但极简的）
// * {@link AnnotationConfigApplicationContext} 验证"Spring 能把 Bean 装起来" ——
// * 静态检查证明不了装配。满意度模块当时有<b>两个真实缺陷</b>只有真起容器才能发现：
// * <ol>
// *   <li>门面有两个公开构造器却没标 {@code @Autowired} → 启动报 {@code No default constructor found}；</li>
// *   <li>门面把自己当实现 → 调用时无限递归 → {@code StackOverflowError}。</li>
// * </ol>
// * 本类把这两条都做成断言。
// *
// * <h3>运行方式（仓库内没有现成脚本）</h3>
// * <pre>
// * mvn -o -q -pl ruoyi-inhospvisit -am test-compile -DskipTests
// * # 然后用模块 classpath 直接跑 main（surefire 认不出它，因为没有 @Test）
// * </pre>
// * classpath 可用 {@code mvn dependency:build-classpath -Dmdep.outputFile=...} 导出。
// */
//public class InhospVisitContextCheck {
//
//    private static int failed = 0;
//
//    private static void check(String name, String expected, String actual) {
//        if (expected.equals(actual)) {
//            System.out.println("  [OK]   " + name + " = " + actual);
//        } else {
//            System.out.println("  [FAIL] " + name + " 期望=[" + expected + "] 实际=[" + actual + "]");
//            failed++;
//        }
//    }
//
//    public static void main(String[] args) {
//        System.out.println("=== 场景 1：参数表 inhospvisit.enabled=true，且存在内部实现 ===");
//        try (AnnotationConfigApplicationContext ctx = context(true, true, SYS_ON)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("门面能被 Spring 实例化（构造器不再歧义）", "true", String.valueOf(facade != null));
//            check("启用时 isEnabled()", "true", String.valueOf(facade.isEnabled()));
//            check("取到的是【内部实现】而不是门面自己", "1",
//                    String.valueOf(facade.dealOutHospInfo("7")));
//            check("门面同时是 PublicitySubtaskApi（下沉给宣教模块的那一个）", "true",
//                    String.valueOf(ctx.getBean(com.ruoyi.common.core.service.PublicitySubtaskApi.class) == facade));
//            // 容器里应有 2 个 InhospVisitApi：门面自己 + 内部实现（门面也实现该接口，这是设计使然）
//            check("容器内 InhospVisitApi 实现数 = 门面 1 + 内部实现 1", "2",
//                    String.valueOf(ctx.getBeansOfType(InhospVisitApi.class).size()));
//            check("开关读取的键名是 sys_config 的 inhospvisit.enabled", "inhospvisit.enabled",
//                    InhospVisitSwitch.CONFIG_KEY);
//        }
//
//        System.out.println();
//        System.out.println("=== 场景 2：参数表=true，但【没有】内部实现（模块没被打进应用）===");
//        try (AnnotationConfigApplicationContext ctx = context(true, false, SYS_ON)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("无实现时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
//            // 关键：不能把门面自己当实现，否则这里会 StackOverflowError
//            String result;
//            try {
//                result = String.valueOf(facade.dealOutHospInfo("7"));
//            } catch (StackOverflowError e) {
//                result = "StackOverflowError";
//            }
//            check("无实现时 dealOutHospInfo 安全返回 0（不会自引用递归）", "0", result);
//
//            String again;
//            try {
//                VisitAgainSubtaskDto dto = facade.buildAgainVisitDraft("ORG1", 1L, 2L, 2L);
//                again = String.valueOf(dto.isInhospFound());
//            } catch (StackOverflowError e) {
//                again = "StackOverflowError";
//            }
//            check("无实现时 buildAgainVisitDraft 返回「未找到出入院记录」而不是递归", "false", again);
//
//            check("无实现时 generatePublicitySubtask 安全返回 false", "false",
//                    String.valueOf(facade.generatePublicitySubtask(1L, 1L, 1L, 4, "7")));
//
//            // 反证：直接问容器"按类型有哪些候选"，看它是否把门面自己算进去
//            ProviderProbe probe = ctx.getBean(ProviderProbe.class);
//            check("无实现时，容器按类型只找到门面自己（证明自引用兜底存在）", "true",
//                    String.valueOf(probe.rawCandidate() == facade));
//            check("但门面不会把'自己'当成实现（self 过滤生效）", "false",
//                    String.valueOf(facade.isEnabled()));
//        }
//
//        System.out.println();
//        System.out.println("=== 场景 3：参数表 inhospvisit.enabled=false（实现 Bean 依然存在，但门面必须不转发）===");
//        StubApi.CALLS.set(0);
//        try (AnnotationConfigApplicationContext ctx = context(true, true, SYS_OFF)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("关闭时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
//            String result;
//            try {
//                result = String.valueOf(facade.dealOutHospInfo("7"));
//            } catch (StackOverflowError e) {
//                result = "StackOverflowError";
//            }
//            check("关闭时 dealOutHospInfo 返回 0（不会自递归）", "0", result);
//            check("关闭时不再调用内部实现（stub 调用次数 = 0）", "0",
//                    String.valueOf(StubApi.CALLS.get()));
//
//            // ------------------------------------------------------------------
//            // 关键：基础出入院信息的读写【不受本开关管辖】
//            //   理由见 InhospVisitDataService 类注释 —— HIS 采集与档案汇聚都依赖它写入院记录，
//            //   若把开关一并套上，关闭随访生成会连带让数据采集瘫痪，那是两件事。
//            // ------------------------------------------------------------------
//            StubDataService.CALLS.set(0);
//            String dataResult;
//            try {
//                dataResult = String.valueOf(facade.selectPatMedInhospByInhospid(123L) != null);
//            } catch (StackOverflowError e) {
//                dataResult = "StackOverflowError";
//            }
//            check("关闭时【数据查询】仍可用（不受开关管辖）", "true", dataResult);
//            check("关闭时【数据查询】确实转发到数据服务（调用次数 = 1）", "1",
//                    String.valueOf(StubDataService.CALLS.get()));
//
//            StubDataService.CALLS.set(0);
//            String updResult;
//            try {
//                updResult = String.valueOf(facade.updatePatMedInhosp(
//                        new com.ruoyi.inhospvisit.domain.PatMedInhosp()));
//            } catch (StackOverflowError e) {
//                updResult = "StackOverflowError";
//            }
//            check("关闭时【数据写入】仍可用且返回真实行数（不受开关管辖）", "7", updResult);
//            check("关闭时【数据写入】确实转发到数据服务（调用次数 = 1）", "1",
//                    String.valueOf(StubDataService.CALLS.get()));
//
//            InhospVisitAvailabilityInterceptor interceptor = ctx.getBean(InhospVisitAvailabilityInterceptor.class);
//            String thrown = "(未抛异常)";
//            try {
//                interceptor.preHandle(null, null, null);
//            } catch (Exception e) {
//                thrown = e.getClass().getSimpleName() + "|" + e.getMessage();
//            }
//            check("关闭时拦截器抛 ServiceException", "true", String.valueOf(thrown.startsWith("ServiceException|")));
//            check("关闭时错误提示明确（含键名与「接口不可用」）", "true",
//                    String.valueOf(thrown.contains("inhospvisit.enabled=false") && thrown.contains("接口不可用")));
//            check("关闭时错误提示说明定时任务不受开关控制", "true",
//                    String.valueOf(thrown.contains("定时任务不受此开关控制")));
//
//            check("关闭时受保护路径 2 条（阶段一：不含 addOperationSubTask）", "2",
//                    String.valueOf(InhospVisitWebConfig.guardedPathPatterns().size()));
//            check("受保护路径不含出入院记录 CRUD 端点", "false",
//                    String.valueOf(InhospVisitWebConfig.guardedPathPatterns().stream()
//                            .anyMatch(p -> p.contains("selectPatMedInhospList") || p.endsWith("/add")
//                                    || p.endsWith("/edit") || p.endsWith("/export"))));
//        }
//
//        System.out.println();
//        System.out.println("=== 场景 4：参数表【没有】inhospvisit.enabled 这一行时，回落 application.yml ===");
//        try (AnnotationConfigApplicationContext ctx = context(true, true, SYS_MISSING)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("参数行缺失、yml 默认 true 时 isEnabled() 为 true", "true", String.valueOf(facade.isEnabled()));
//        }
//        try (AnnotationConfigApplicationContext ctx = context(false, true, SYS_MISSING)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("参数行缺失、yml=false 时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
//        }
//
//        System.out.println();
//        System.out.println("=== 场景 5：容器里【没有】IConfigService 时（独立/测试环境）必须能启动且按 yml 兜底 ===");
//        try (AnnotationConfigApplicationContext ctx = context(true, true, null, false)) {
//            InhospVisitFacade facade = ctx.getBean(InhospVisitFacade.class);
//            check("无配置服务时门面仍能装配并启动", "true", String.valueOf(facade != null));
//            check("无配置服务时按 yml 兜底（true）", "true", String.valueOf(facade.isEnabled()));
//        }
//
//        System.out.println();
//        if (failed == 0) {
//            System.out.println("===== 出入院随访模块 Spring 装配校验全部通过 =====");
//        } else {
//            System.out.println("===== 出入院随访模块 Spring 装配校验失败 " + failed + " 项 =====");
//            System.exit(1);
//        }
//    }
//
//    /**
//     * 参数表的模拟取值
//     */
//    static final class Cfg {
//        /** 参数行存在且为 true */
//        static final String SYS_ON = "true";
//        /** 参数行存在且为 false */
//        static final String SYS_OFF = "false";
//        /** 参数行不存在 */
//        static final String SYS_MISSING = null;
//    }
//
//    private static final String SYS_ON = Cfg.SYS_ON;
//    private static final String SYS_OFF = Cfg.SYS_OFF;
//    private static final String SYS_MISSING = Cfg.SYS_MISSING;
//
//    private static AnnotationConfigApplicationContext context(boolean ymlEnabled,
//                                                             boolean withImpl,
//                                                             String sysConfigValue) {
//        return context(ymlEnabled, withImpl, sysConfigValue, true);
//    }
//
//    private static AnnotationConfigApplicationContext context(boolean ymlEnabled,
//                                                             boolean withImpl,
//                                                             String sysConfigValue,
//                                                             boolean withConfigService) {
//        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
//        InhospVisitProperties properties = new InhospVisitProperties();
//        properties.setEnabled(ymlEnabled);
//        ctx.registerBean(InhospVisitProperties.class, () -> properties);
//        ctx.register(InhospVisitFacade.class,
//                InhospVisitSwitch.class,
//                InhospVisitAvailabilityInterceptor.class,
//                InhospVisitWebConfig.class,
//                ProviderProbe.class,
//                StubDataService.class);
//        if (withConfigService) {
//            // 假的参数配置服务：只认 inhospvisit.enabled 这一个键，值由 sysConfigValue 决定
//            ctx.registerBean("stubConfigService", IConfigService.class,
//                    () -> (IConfigService) configKey ->
//                            InhospVisitSwitch.CONFIG_KEY.equals(configKey) ? sysConfigValue : "");
//        }
//        if (withImpl) {
//            ctx.registerBean("stubInhospVisitApi", InhospVisitApi.class, StubApi::new);
//        }
//        ctx.refresh();
//        return ctx;
//    }
//
//    /**
//     * 顶替 {@code DefaultInhospVisitApi} 的桩：只回填调用次数与固定返回值，不碰数据库。
//     * 这样本校验可以在没有数据源的环境里跑。
//     */
//    public static class StubApi implements InhospVisitApi {
//
//        /**
//         * 调用次数：用来证明"开关关闭时门面确实没有转发给实现"
//         */
//        static final AtomicInteger CALLS = new AtomicInteger();
//
//        @Override
//        public boolean isEnabled() {
//            return true;
//        }
//
//        @Override
//        public int dealOutHospInfo(String config) {
//            CALLS.incrementAndGet();
//            return 1;
//        }
//
//        @Override
//        public int dealOutHospInfoBySchedule(String config) {
//            CALLS.incrementAndGet();
//            return 1;
//        }
//
//        /**
//         * 补齐 {@link InhospVisitApi} 的抽象方法。
//         * <p>
//         * ⚠️ 这两个方法此前在本桩里<b>缺失</b>，导致本测试类从未编译成功
//         * （{@code target/test-classes} 一直是空的）——即"装配校验"实际上一次都没跑起来过。
//         * 这是被发现的既有缺陷，此处补上。
//         */
//        @Override
//        public int addOperationSubTask(String config) {
//            CALLS.incrementAndGet();
//            return 1;
//        }
//
//        /**
//         * 补齐 {@link InhospVisitApi} 的抽象方法（见 {@link #addOperationSubTask}）。
//         * <p>
//         * 门诊随访属第二批 {@code ruoyi-outpatientvisit}，桩里只记调用并返回 0。
//         */
//        @Override
//        public int dealOutpatientInfo() {
//            CALLS.incrementAndGet();
//            return 0;
//        }
//
//        @Override
//        public int rollTaskGroupCycle() {
//            CALLS.incrementAndGet();
//            return 0;
//        }
//
//        @Override
//        public VisitAgainSubtaskDto buildAgainVisitDraft(String orgid, Long inhospid, Long newTaskId, Long sendstate) {
//            CALLS.incrementAndGet();
//            return InhospVisitFacade.emptyAgainDraft("stub");
//        }
//
//        @Override
//        public boolean generatePublicitySubtask(Long taskid, Long patid, Long inhospid, int type, String config) {
//            CALLS.incrementAndGet();
//            return true;
//        }
//    }
//
//    /**
//     * 探针：以"旁观者"身份注入 {@code ObjectProvider<InhospVisitApi>}，看容器按类型能找到谁。
//     * <p>
//     * 它不是 {@code InhospVisitApi} 的实现，所以不存在"自引用被排除"的情况，
//     * 因此它看到的就是完整的候选集合 —— 用来证明"没有内部实现时容器会把门面自己当候选"。
//     */
//    public static class ProviderProbe {
//
//        @org.springframework.beans.factory.annotation.Autowired
//        private ObjectProvider<InhospVisitApi> provider;
//
//        InhospVisitApi rawCandidate() {
//            return provider.stream().findFirst().orElse(null);
//        }
//    }
//
//    // ======================================================================
//    // 基础出入院信息数据通路（InhospVisitDataService）
//    //
//    // 为什么必须单独验：
//    //   门面同时实现了 InhospVisitDataService，而 Spring 的构造注入是按类型找候选。
//    //   早先的写法（直接注入接口类型）在真实容器里会命中"正在创建的门面自己"，
//    //   抛 BeanCurrentlyInCreationException —— 这个缺陷【只有真起容器】才能发现，
//    //   静态检查与编译都发现不了（满意度模块踩过同类坑）。
//    //   因此这里用桩数据服务把这条通路钉住：
//    //     · 门面能装配（不自引用）；
//    //     · 数据方法确实转发到数据服务，且【不受 inhospvisit.enabled 开关管辖】。
//    // ======================================================================
//
//    /**
//     * 顶替 {@code DefaultInhospVisitDataService} 的桩：只记调用次数，不碰数据库。
//     * <p>
//     * ⚠️ 本桩只实现接口（<b>不继承</b> {@link DefaultInhospVisitDataService}）：
//     * 真实实现类带一个 {@code @Autowired PatMedInhospMapper} 字段，继承它就会把
//     * "需要数据源"这个耦合带进本校验，而本校验的整个前提就是<b>不起数据库</b>
//     * （极简上下文里没有 Mapper Bean，继承版会在 refresh 时抛 NoSuchBeanDefinitionException）。
//     * <p>
//     * 门面因此按【接口】{@code ObjectProvider<InhospVisitDataService>} 取候选并过滤自己，
//     * 既能取到本桩，也不会自引用/循环依赖。
//     */
//    public static class StubDataService implements InhospVisitDataService {
//
//        static final AtomicInteger CALLS = new AtomicInteger();
//
//        @Override
//        public com.ruoyi.inhospvisit.domain.PatMedInhosp selectPatMedInhospByInhospid(Long inhospid) {
//            CALLS.incrementAndGet();
//            com.ruoyi.inhospvisit.domain.PatMedInhosp row = new com.ruoyi.inhospvisit.domain.PatMedInhosp();
//            row.setInhospid(inhospid);
//            return row;
//        }
//
//        @Override
//        public int updatePatMedInhosp(com.ruoyi.inhospvisit.domain.PatMedInhosp patMedInhosp) {
//            CALLS.incrementAndGet();
//            return 7;
//        }
//
//        // ---- 其余方法：本校验不涉及，返回安全空值 ----
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectPatMedInhosp(
//                com.ruoyi.inhospvisit.domain.PatMedInhosp q) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectOutInhospByPatnoAndOutDate(
//                String patno, java.util.Date dayStart, java.util.Date dayEnd) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public String getTagnameBypatid(Long patid) {
//            return null;
//        }
//
//        @Override
//        public java.util.List<java.util.Map<String, Object>> getTagnameByPatids(java.util.List<Long> patids) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectPatMedInhospList(
//                com.ruoyi.inhospvisit.domain.PatMedInhosp q) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectPatMedInhospListBySerialnum(
//                com.ruoyi.inhospvisit.domain.PatMedInhosp q) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectPatMedInhospListByCondition(
//                com.ruoyi.inhospvisit.domain.PatMedInhospVO vo) {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public com.ruoyi.common.core.service.dto.PatMedRes selectPatMedInhospCount(
//                com.ruoyi.common.core.service.dto.PatMedReq req) {
//            return null;
//        }
//
//        @Override
//        public java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> selectNeedProcessList() {
//            return java.util.Collections.emptyList();
//        }
//
//        @Override
//        public int insertPatMedInhosp(com.ruoyi.inhospvisit.domain.PatMedInhosp p) {
//            return 0;
//        }
//
//        @Override
//        public int insertPatMedInhospBatch(java.util.List<com.ruoyi.inhospvisit.domain.PatMedInhosp> list) {
//            return 0;
//        }
//
//        @Override
//        public int deletePatMedInhospByInhospid(Long inhospid) {
//            return 0;
//        }
//
//        @Override
//        public int deletePatMedInhospByInhospno(String inhospno) {
//            return 0;
//        }
//
//        @Override
//        public int deletePatMedInhospByInhospids(Long[] inhospids) {
//            return 0;
//        }
//    }
//}