// ============ 核心接口定义 ============

/**
 * 规则引擎核心接口
 */
public interface RuleEngine {
    /**
     * 执行规则
     * @param context 执行上下文
     * @return 执行结果
     */
    RuleResult execute(RuleContext context);
    
    /**
     * 批量执行规则
     * @param contexts 执行上下文列表
     * @return 执行结果列表
     */
    List<RuleResult> batchExecute(List<RuleContext> contexts);
    
    /**
     * 重新加载规则
     * @param sceneCode 场景编码
     */
    void reload(String sceneCode);
    
    /**
     * 验证规则
     * @param ruleContent 规则内容
     * @return 验证结果
     */
    ValidationResult validate(String ruleContent);
}

/**
 * 规则上下文（通用）
 */
@Data
public class RuleContext {
    /**
     * 追踪ID（用于日志追踪）
     */
    private String traceId;
    
    /**
     * 场景编码
     */
    private String sceneCode;
    
    /**
     * 规则组编码（可选，不指定则执行场景下所有规则）
     */
    private String groupCode;
    
    /**
     * 输入数据（通用Map结构）
     */
    private Map<String, Object> inputData;
    
    /**
     * 扩展参数
     */
    private Map<String, Object> extParams;
    
    /**
     * 元数据
     */
    private Map<String, Object> metadata;
}

/**
 * 规则执行结果
 */
@Data
public class RuleResult {
    /**
     * 是否匹配规则
     */
    private boolean matched;
    
    /**
     * 匹配的规则列表
     */
    private List<MatchedRule> matchedRules;
    
    /**
     * 执行的动作结果
     */
    private List<ActionResult> actionResults;
    
    /**
     * 输出数据
     */
    private Map<String, Object> outputData;
    
    /**
     * 执行耗时
     */
    private long executionTime;
    
    /**
     * 错误信息（如果有）
     */
    private String errorMessage;
}

/**
 * 业务适配器接口
 */
public interface BusinessAdapter {
    /**
     * 获取场景编码
     */
    String getSceneCode();
    
    /**
     * 预处理输入数据
     * @param originalData 原始业务数据
     * @return 转换后的规则引擎输入数据
     */
    Map<String, Object> preProcess(Object originalData);
    
    /**
     * 后处理输出数据
     * @param ruleResult 规则引擎执行结果
     * @return 业务响应对象
     */
    Object postProcess(RuleResult ruleResult);
    
    /**
     * 自定义动作处理器
     * @return 动作处理器映射
     */
    default Map<String, ActionHandler> getActionHandlers() {
        return new HashMap<>();
    }
}

/**
 * 动作处理器接口
 */
public interface ActionHandler {
    /**
     * 执行动作
     * @param context 上下文
     * @param params 参数
     * @return 执行结果
     */
    Object execute(RuleContext context, Map<String, Object> params);
}

@Component
@Slf4j
public class DroolsRuleEngine implements RuleEngine {
    
    @Autowired
    private RuleDefinitionService ruleDefinitionService;
    
    @Autowired
    private RuleCompiler ruleCompiler;
    
    @Autowired
    private RuleExecutionLogger executionLogger;
    
    // 规则缓存（按场景）
    private final Map<String, KieBase> kieBaseCache = new ConcurrentHashMap<>();
    
    @Override
    public RuleResult execute(RuleContext context) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        
        try {
            // 1. 获取场景对应的KieBase
            KieBase kieBase = getOrLoadKieBase(context.getSceneCode());
            
            // 2. 创建会话
            KieSession session = kieBase.newKieSession();
            
            try {
                // 3. 设置全局变量
                session.setGlobal("ruleResult", new RuleResult());
                session.setGlobal("context", context);
                
                // 4. 插入事实
                session.insert(context.getInputData());
                
                // 5. 执行规则
                int firedRules = session.fireAllRules();
                
                // 6. 获取结果
                RuleResult result = (RuleResult) session.getGlobal("ruleResult");
                
                stopWatch.stop();
                result.setExecutionTime(stopWatch.getTotalTimeMillis());
                
                // 7. 记录执行日志
                executionLogger.log(context, result);
                
                log.info("规则执行完成，场景：{}，触发规则数：{}，耗时：{}ms",
                    context.getSceneCode(), firedRules, result.getExecutionTime());
                
                return result;
            } finally {
                session.dispose();
            }
        } catch (Exception e) {
            log.error("规则执行失败", e);
            RuleResult errorResult = new RuleResult();
            errorResult.setMatched(false);
            errorResult.setErrorMessage(e.getMessage());
            stopWatch.stop();
            errorResult.setExecutionTime(stopWatch.getTotalTimeMillis());
            return errorResult;
        }
    }
    
    @Override
    public List<RuleResult> batchExecute(List<RuleContext> contexts) {
        return contexts.parallelStream()
            .map(this::execute)
            .collect(Collectors.toList());
    }
    
    @Override
    public void reload(String sceneCode) {
        log.info("重新加载场景规则：{}", sceneCode);
        kieBaseCache.remove(sceneCode);
        getOrLoadKieBase(sceneCode);
    }
    
    @Override
    public ValidationResult validate(String ruleContent) {
        return ruleCompiler.validate(ruleContent);
    }
    
    private KieBase getOrLoadKieBase(String sceneCode) {
        return kieBaseCache.computeIfAbsent(sceneCode, this::loadKieBase);
    }
    
    private KieBase loadKieBase(String sceneCode) {
        log.info("加载场景规则：{}", sceneCode);
        
        // 1. 查询场景下的所有规则
        List<RuleDefinition> rules = ruleDefinitionService.findBySceneCode(sceneCode);
        
        // 2. 编译规则
        KieServices kieServices = KieServices.Factory.get();
        KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
        
        for (RuleDefinition rule : rules) {
            String drl = ruleCompiler.compile(rule);
            String path = "src/main/resources/rules/" + sceneCode + "/" + 
                         rule.getRuleCode() + ".drl";
            kieFileSystem.write(path, drl);
        }
        
        // 3. 构建KieBase
        KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
        kieBuilder.buildAll();
        
        if (kieBuilder.getResults().hasMessages(Message.Level.ERROR)) {
            throw new RuleCompileException("规则编译失败：" + 
                kieBuilder.getResults().getMessages());
        }
        
        KieContainer kieContainer = kieServices.newKieContainer(
            kieServices.getRepository().getDefaultReleaseId());
        
        return kieContainer.getKieBase();
    }
}

/**
 * 规则编译器
 */
@Component
@Slf4j
public class RuleCompiler {
    
    @Autowired
    private RuleConditionService conditionService;
    
    @Autowired
    private RuleActionService actionService;
    
    /**
     * 编译规则
     */
    public String compile(RuleDefinition rule) {
        switch (rule.getRuleType()) {
            case CONDITION:
                return compileConditionRule(rule);
            case DECISION_TABLE:
                return compileDecisionTable(rule);
            case SCRIPT:
                return compileScriptRule(rule);
            default:
                throw new UnsupportedOperationException(
                    "不支持的规则类型：" + rule.getRuleType());
        }
    }
    
    /**
     * 编译条件规则
     */
    private String compileConditionRule(RuleDefinition rule) {
        StringBuilder drl = new StringBuilder();
        
        // 包声明
        drl.append("package rules.").append(rule.getGroupId()).append(";\n\n");
        
        // 导入
        drl.append("import java.util.Map;\n");
        drl.append("import java.util.List;\n");
        drl.append("import com.ruleengine.core.RuleContext;\n");
        drl.append("import com.ruleengine.core.RuleResult;\n");
        drl.append("import com.ruleengine.core.MatchedRule;\n\n");
        
        // 全局变量
        drl.append("global RuleResult ruleResult;\n");
        drl.append("global RuleContext context;\n\n");
        
        // 规则
        drl.append("rule \"").append(rule.getRuleCode()).append("\"\n");
        drl.append("    salience ").append(rule.getPriority()).append("\n");
        
        // 规则属性
        if (rule.getEffectiveTime() != null) {
            drl.append("    date-effective \"")
               .append(rule.getEffectiveTime()).append("\"\n");
        }
        if (rule.getExpiryTime() != null) {
            drl.append("    date-expires \"")
               .append(rule.getExpiryTime()).append("\"\n");
        }
        
        // when部分
        drl.append("when\n");
        drl.append(buildConditions(rule.getId()));
        
        // then部分
        drl.append("then\n");
        drl.append(buildActions(rule.getId()));
        drl.append("end\n");
        
        return drl.toString();
    }
    
    /**
     * 构建条件
     */
    private String buildConditions(Long ruleId) {
        List<RuleCondition> conditions = conditionService.findByRuleId(ruleId);
        
        if (conditions.isEmpty()) {
            return "    $data : Map()\n";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("    $data : Map(\n");
        
        // 按组分组
        Map<Integer, List<RuleCondition>> groups = conditions.stream()
            .collect(Collectors.groupingBy(RuleCondition::getConditionGroup));
        
        List<String> groupConditions = new ArrayList<>();
        for (List<RuleCondition> group : groups.values()) {
            List<String> andConditions = group.stream()
                .map(this::buildSingleCondition)
                .collect(Collectors.toList());
            
            if (andConditions.size() == 1) {
                groupConditions.add(andConditions.get(0));
            } else {
                groupConditions.add("(" + String.join(" && ", andConditions) + ")");
            }
        }
        
        sb.append("        ").append(String.join(" || ", groupConditions));
        sb.append("\n    )\n");
        
        return sb.toString();
    }
    
    /**
     * 构建单个条件
     */
    private String buildSingleCondition(RuleCondition condition) {
        String field = "$data.get(\"" + condition.getLeftValue() + "\")";
        String operator = condition.getOperator();
        String value = condition.getRightValue();
        
        switch (operator.toUpperCase()) {
            case "EQ":
                return field + " == " + formatValue(value, condition.getValueType());
            case "NEQ":
                return field + " != " + formatValue(value, condition.getValueType());
            case "GT":
                return field + " > " + formatValue(value, condition.getValueType());
            case "GTE":
                return field + " >= " + formatValue(value, condition.getValueType());
            case "LT":
                return field + " < " + formatValue(value, condition.getValueType());
            case "LTE":
                return field + " <= " + formatValue(value, condition.getValueType());
            case "IN":
                return field + " memberOf " + formatArray(value);
            case "NOT_IN":
                return field + " not memberOf " + formatArray(value);
            case "LIKE":
                return field + " matches \"" + value + "\"";
            case "BETWEEN":
                String[] range = value.split(",");
                return "(" + field + " >= " + range[0] + " && " + 
                       field + " <= " + range[1] + ")";
            case "IS_NULL":
                return field + " == null";
            case "IS_NOT_NULL":
                return field + " != null";
            default:
                throw new IllegalArgumentException("不支持的操作符：" + operator);
        }
    }
    
    /**
     * 构建动作
     */
    private String buildActions(Long ruleId) {
        List<RuleAction> actions = actionService.findByRuleId(ruleId);
        
        StringBuilder sb = new StringBuilder();
        
        // 添加匹配记录
        sb.append("    MatchedRule matched = new MatchedRule();\n");
        sb.append("    matched.setRuleId(").append(ruleId).append("L);\n");
        sb.append("    matched.setRuleCode(\"").append(ruleId).append("\");\n");
        sb.append("    ruleResult.getMatchedRules().add(matched);\n");
        sb.append("    ruleResult.setMatched(true);\n\n");
        
        // 执行动作
        for (RuleAction action : actions) {
            sb.append(buildSingleAction(action));
        }
        
        return sb.toString();
    }
    
    /**
     * 构建单个动作
     */
    private String buildSingleAction(RuleAction action) {
        switch (action.getActionType()) {
            case "RETURN":
                return "    ruleResult.getOutputData().putAll(" + 
                       action.getActionParams() + ");\n";
            case "MODIFY":
                return "    $data.putAll(" + action.getActionParams() + ");\n" +
                       "    update($data);\n";
            case "LOG":
                return "    System.out.println(\"" + 
                       action.getActionParams() + "\");\n";
            default:
                return "    // Unsupported action: " + 
                       action.getActionType() + "\n";
        }
    }
    
    private String formatValue(String value, String type) {
        switch (type.toUpperCase()) {
            case "STRING":
                return "\"" + value + "\"";
            case "NUMBER":
                return value;
            case "BOOLEAN":
                return value.toLowerCase();
            default:
                return value;
        }
    }
    
    private String formatArray(String value) {
        String[] items = value.split(",");
        return "[" + Arrays.stream(items)
            .map(item -> "\"" + item.trim() + "\"")
            .collect(Collectors.joining(", ")) + "]";
    }
}

// ============ 传染病报卡适配器 ============
@Component
public class InfectiousDiseaseAdapter implements BusinessAdapter {
    
    @Override
    public String getSceneCode() {
        return "INFECTIOUS_DISEASE_REPORT";
    }
    
    @Override
    public Map<String, Object> preProcess(Object originalData) {
        InfectiousDiseaseRequest request = (InfectiousDiseaseRequest) originalData;
        
        Map<String, Object> inputData = new HashMap<>();
        
        // 诊断数据
        inputData.put("diagnosis_code", request.getDiagnosisCode());
        inputData.put("diagnosis_name", request.getDiagnosisName());
        inputData.put("diagnosis_type", request.getDiagnosisType());
        
        // 检验数据
        inputData.put("lab_items", request.getLabItems());
        inputData.put("lab_results", request.getLabResults());
        
        // 检查数据
        inputData.put("exam_items", request.getExamItems());
        inputData.put("exam_results", request.getExamResults());
        
        // 患者数据
        inputData.put("patient_age", request.getPatientAge());
        inputData.put("patient_gender", request.getPatientGender());
        
        return inputData;
    }
    
    @Override
    public Object postProcess(RuleResult ruleResult) {
        InfectiousDiseaseResponse response = new InfectiousDiseaseResponse();
        
        if (ruleResult.isMatched()) {
            List<String> diseases = (List<String>) 
                ruleResult.getOutputData().get("report_diseases");
            response.setNeedReport(true);
            response.setReportDiseases(diseases);
            response.setReportCards(generateReportCards(diseases));
        } else {
            response.setNeedReport(false);
        }
        
        return response;
    }
    
    @Override
    public Map<String, ActionHandler> getActionHandlers() {
        Map<String, ActionHandler> handlers = new HashMap<>();
        
        // 发送报卡通知
        handlers.put("SEND_REPORT_NOTIFICATION", (context, params) -> {
            String diseaseCode = (String) params.get("disease_code");
            // 调用消息服务发送通知
            return "通知已发送";
        });
        
        // 生成报卡
        handlers.put("GENERATE_REPORT_CARD", (context, params) -> {
            // 生成报卡逻辑
            return "报卡已生成";
        });
        
        return handlers;
    }
    
    private List<ReportCard> generateReportCards(List<String> diseases) {
        // 生成报卡的具体逻辑
        return new ArrayList<>();
    }
}

// ============ 处方审核适配器 ============
@Component
public class PrescriptionAuditAdapter implements BusinessAdapter {
    
    @Override
    public String getSceneCode() {
        return "PRESCRIPTION_AUDIT";
    }
    
    @Override
    public Map<String, Object> preProcess(Object originalData) {
        PrescriptionRequest request = (PrescriptionRequest) originalData;
        
        Map<String, Object> inputData = new HashMap<>();
        
        // 药品信息
        inputData.put("drug_codes", extractDrugCodes(request.getDrugs()));
        inputData.put("drug_doses", extractDrugDoses(request.getDrugs()));
        inputData.put("drug_interactions", checkInteractions(request.getDrugs()));
        
        // 诊断信息
        inputData.put("diagnosis_codes", request.getDiagnosisCodes());
        
        // 患者信息
        inputData.put("patient_age", request.getPatientAge());
        inputData.put("patient_weight", request.getPatientWeight());
        inputData.put("patient_allergies", request.getAllergies());
        inputData.put("patient_pregnancy", request.isPregnant());
        inputData.put("patient_liver_function", request.getLiverFunction());
        inputData.put("patient_kidney_function", request.getKidneyFunction());
        
        return inputData;
    }
    
    @Override
    public Object postProcess(RuleResult ruleResult) {
        PrescriptionAuditResponse response = new PrescriptionAuditResponse();
        
        if (ruleResult.isMatched()) {
            response.setAuditPassed(false);
            response.setAuditProblems(extractProblems(ruleResult));
            response.setSuggestions(extractSuggestions(ruleResult));
        } else {
            response.setAuditPassed(true);
        }
        
        return response;
    }
    
    @Override
    public Map<String, ActionHandler> getActionHandlers() {
        Map<String, ActionHandler> handlers = new HashMap<>();
        
        // 药品相互作用检查
        handlers.put("CHECK_DRUG_INTERACTION", (context, params) -> {
            // 调用药品知识库检查相互作用
            return checkDrugInteraction(params);
        });
        
        // 剂量调整建议
        handlers.put("SUGGEST_DOSE_ADJUSTMENT", (context, params) -> {
            // 根据患者情况计算推荐剂量
            return calculateRecommendedDose(params);
        });
        
        return handlers;
    }
    
    private List<String> extractDrugCodes(List<Drug> drugs) {
        return drugs.stream()
            .map(Drug::getCode)
            .collect(Collectors.toList());
    }
    
    private Map<String, Double> extractDrugDoses(List<Drug> drugs) {
        return drugs.stream()
            .collect(Collectors.toMap(Drug::getCode, Drug::getDose));
    }
    
    private List<String> checkInteractions(List<Drug> drugs) {
        // 检查药品相互作用
        return new ArrayList<>();
    }
    
    private List<AuditProblem> extractProblems(RuleResult result) {
        // 提取审核问题
        return new ArrayList<>();
    }
    
    private List<String> extractSuggestions(RuleResult result) {
        // 提取建议
        return new ArrayList<>();
    }
    
    private Object checkDrugInteraction(Map<String, Object> params) {
        // 药品相互作用检查逻辑
        return null;
    }
    
    private Object calculateRecommendedDose(Map<String, Object> params) {
        // 剂量计算逻辑
        return null;
    }
}

// ============ 病案质控适配器 ============
@Component
public class MedicalRecordQCAdapter implements BusinessAdapter {
    
    @Override
    public String getSceneCode() {
        return "MEDICAL_RECORD_QC";
    }
    
    @Override
    public Map<String, Object> preProcess(Object originalData) {
        MedicalRecordRequest request = (MedicalRecordRequest) originalData;
        
        Map<String, Object> inputData = new HashMap<>();
        
        // 病案基本信息
        inputData.put("admission_date", request.getAdmissionDate());
        inputData.put("discharge_date", request.getDischargeDate());
        inputData.put("length_of_stay", calculateLOS(request));
        
        // 诊断信息
        inputData.put("main_diagnosis", request.getMainDiagnosis());
        inputData.put("other_diagnoses", request.getOtherDiagnoses());
        inputData.put("operation_codes", request.getOperationCodes());
        
        // 费用信息
        inputData.put("total_cost", request.getTotalCost());
        inputData.put("drug_cost_ratio", calculateDrugCostRatio(request));
        
        // 质控指标
        inputData.put("has_informed_consent", request.hasInformedConsent());
        inputData.put("has_operation_record", request.hasOperationRecord());
        inputData.put("has_discharge_summary", request.hasDischargeSummary());
        
        return inputData;
    }
    
    @Override
    public Object postProcess(RuleResult ruleResult) {
        MedicalRecordQCResponse response = new MedicalRecordQCResponse();
        
        response.setQualified(!ruleResult.isMatched());
        
        if (ruleResult.isMatched()) {
            response.setQualityProblems(extractQualityProblems(ruleResult));
            response.setQualityScore(calculateQualityScore(ruleResult));
            response.setImprovementSuggestions(
                extractImprovementSuggestions(ruleResult));
        } else {
            response.setQualityScore(100.0);
        }
        
        return response;
    }
    
    private int calculateLOS(MedicalRecordRequest request) {
        // 计算住院天数
        return 0;
    }
    
    private double calculateDrugCostRatio(MedicalRecordRequest request) {
        // 计算药占比
        return 0.0;
    }
    
    private List<QualityProblem> extractQualityProblems(RuleResult result) {
        // 提取质量问题
        return new ArrayList<>();
    }
    
    private double calculateQualityScore(RuleResult result) {
        // 计算质量分数
        return 85.0;
    }
    
    private List<String> extractImprovementSuggestions(RuleResult result) {
        // 提取改进建议
        return new ArrayList<>();
    }
}

@RestController
@RequestMapping("/api/rule-engine")
@Slf4j
public class RuleEngineController {
    
    @Autowired
    private RuleEngine ruleEngine;
    
    @Autowired
    private Map<String, BusinessAdapter> adapterMap;
    
    @Autowired
    private RuleConfigService ruleConfigService;
    
    /**
     * 通用规则执行接口
     */
    @PostMapping("/execute")
    public Result<Object> execute(@RequestBody ExecuteRequest request) {
        try {
            // 1. 获取业务适配器
            BusinessAdapter adapter = adapterMap.get(request.getSceneCode());
            if (adapter == null) {
                return Result.error("未找到场景适配器：" + request.getSceneCode());
            }
            
            // 2. 预处理数据
            Map<String, Object> inputData = adapter.preProcess(request.getBusinessData());
            
            // 3. 构建规则上下文
            RuleContext context = new RuleContext();
            context.setTraceId(UUID.randomUUID().toString());
            context.setSceneCode(request.getSceneCode());
            context.setInputData(inputData);
            context.setExtParams(request.getExtParams());
            
            // 4. 执行规则
            RuleResult ruleResult = ruleEngine.execute(context);
            
            // 5. 后处理数据
            Object businessResult = adapter.postProcess(ruleResult);
            
            return Result.success(businessResult);
        } catch (Exception e) {
            log.error("规则执行失败", e);
            return Result.error("规则执行失败：" + e.getMessage());
        }
    }
    
    /**
     * 批量执行
     */
    @PostMapping("/batch-execute")
    public Result<List<Object>> batchExecute(@RequestBody BatchExecuteRequest request) {
        // 批量执行逻辑
        return Result.success(new ArrayList<>());
    }
    
    /**
     * 规则测试
     */
    @PostMapping("/test")
    public Result<RuleTestResult> testRule(@RequestBody RuleTestRequest request) {
        // 测试逻辑
        return Result.success(new RuleTestResult());
    }
    
    /**
     * 刷新规则缓存
     */
    @PostMapping("/reload/{sceneCode}")
    public Result<Void> reloadRules(@PathVariable String sceneCode) {
        ruleEngine.reload(sceneCode);
        return Result.success();
    }
    
    // ===== 规则配置管理接口 =====
    
    /**
     * 创建规则
     */
    @PostMapping("/rule/create")
    public Result<Long> createRule(@RequestBody @Valid RuleDefinitionDTO dto) {
        Long ruleId = ruleConfigService.createRule(dto);
        return Result.success(ruleId);
    }
    
    /**
     * 更新规则
     */
    @PutMapping("/rule/update/{ruleId}")
    public Result<Void> updateRule(@PathVariable Long ruleId, 
                                  @RequestBody @Valid RuleDefinitionDTO dto) {
        ruleConfigService.updateRule(ruleId, dto);
        return Result.success();
    }
    
    /**
     * 删除规则
     */
    @DeleteMapping("/rule/delete/{ruleId}")
    public Result<Void> deleteRule(@PathVariable Long ruleId) {
        ruleConfigService.deleteRule(ruleId);
        return Result.success();
    }
    
    /**
     * 查询规则列表
     */
    @GetMapping("/rule/list")
    public Result<Page<RuleDefinitionVO>> listRules(RuleQueryDTO query) {
        Page<RuleDefinitionVO> page = ruleConfigService.queryRules(query);
        return Result.success(page);
    }
    
    /**
     * 获取场景元数据
     */
    @GetMapping("/metadata/{sceneCode}")
    public Result<SceneMetadata> getSceneMetadata(@PathVariable String sceneCode) {
        SceneMetadata metadata = ruleConfigService.getSceneMetadata(sceneCode);
        return Result.success(metadata);
    }
}