package com.ruoyi.credit.service.impl;

import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.credit.config.ValidationRuleConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.credit.mapper.ValidationRuleMapper;
import com.ruoyi.credit.domain.ValidationRule;
import com.ruoyi.credit.service.IValidationRuleService;

/**
 * 验证规则配置Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-12-30
 */
@Service
public class ValidationRuleServiceImpl implements IValidationRuleService 
{
    @Autowired
    private ValidationRuleMapper validationRuleMapper;
    
    @Autowired
    private ValidationRuleConfig validationRuleConfig;

    /**
     * 查询验证规则配置
     * 
     * @param ruleId 验证规则配置主键
     * @return 验证规则配置
     */
    @Override
    public ValidationRule selectValidationRuleByRuleId(Long ruleId)
    {
        return validationRuleMapper.selectValidationRuleByRuleId(ruleId);
    }

    /**
     * 根据规则名称查询验证规则
     * 
     * @param ruleName 规则名称
     * @return 验证规则配置
     */
    @Override
    public ValidationRule selectValidationRuleByRuleName(String ruleName)
    {
        return validationRuleMapper.selectValidationRuleByRuleName(ruleName);
    }

    /**
     * 查询验证规则配置列表
     * 
     * @param validationRule 验证规则配置
     * @return 验证规则配置
     */
    @Override
    public List<ValidationRule> selectValidationRuleList(ValidationRule validationRule)
    {
        return validationRuleMapper.selectValidationRuleList(validationRule);
    }

    /**
     * 查询激活状态的验证规则列表（按优先级排序）
     * 
     * @return 激活的验证规则集合
     */
    @Override
    public List<ValidationRule> selectActiveValidationRules()
    {
        return validationRuleMapper.selectActiveValidationRules();
    }

    /**
     * 根据规则类型查询验证规则
     * 
     * @param ruleType 规则类型
     * @return 验证规则集合
     */
    @Override
    public List<ValidationRule> selectValidationRulesByType(String ruleType)
    {
        return validationRuleMapper.selectValidationRulesByType(ruleType);
    }

    /**
     * 新增验证规则配置
     * 
     * @param validationRule 验证规则配置
     * @return 结果
     */
    @Override
    public int insertValidationRule(ValidationRule validationRule)
    {
        // 验证规则配置有效性
        String validationMessage = validateRuleConfiguration(validationRule);
        if (validationMessage != null) {
            throw new IllegalArgumentException(validationMessage);
        }
        
        // 检查规则名称是否已存在
        if (checkRuleNameExists(validationRule.getRuleName(), null)) {
            throw new IllegalArgumentException("规则名称已存在: " + validationRule.getRuleName());
        }
        
        // 如果没有设置优先级，自动分配
        if (validationRule.getPriority() == null) {
            validationRule.setPriority(getNextAvailablePriority());
        }
        
        // 设置默认状态
        if (StringUtils.isEmpty(validationRule.getRuleStatus())) {
            validationRule.setRuleStatus(ValidationRule.STATUS_ACTIVE);
        }
        
        validationRule.setCreateTime(DateUtils.getNowDate());
        int result = validationRuleMapper.insertValidationRule(validationRule);
        
        // 插入成功后重新加载配置
        if (result > 0) {
            validationRuleConfig.reloadConfig();
        }
        
        return result;
    }

    /**
     * 修改验证规则配置
     * 
     * @param validationRule 验证规则配置
     * @return 结果
     */
    @Override
    public int updateValidationRule(ValidationRule validationRule)
    {
        // 验证规则配置有效性
        String validationMessage = validateRuleConfiguration(validationRule);
        if (validationMessage != null) {
            throw new IllegalArgumentException(validationMessage);
        }
        
        // 检查规则名称是否已存在（排除当前规则）
        if (checkRuleNameExists(validationRule.getRuleName(), validationRule.getRuleId())) {
            throw new IllegalArgumentException("规则名称已存在: " + validationRule.getRuleName());
        }
        
        validationRule.setUpdateTime(DateUtils.getNowDate());
        int result = validationRuleMapper.updateValidationRule(validationRule);
        
        // 更新成功后重新加载配置
        if (result > 0) {
            validationRuleConfig.reloadConfig();
        }
        
        return result;
    }

    /**
     * 批量删除验证规则配置
     * 
     * @param ruleIds 需要删除的验证规则配置主键集合
     * @return 结果
     */
    @Override
    public int deleteValidationRuleByRuleIds(Long[] ruleIds)
    {
        int result = validationRuleMapper.deleteValidationRuleByRuleIds(ruleIds);
        
        // 删除成功后重新加载配置
        if (result > 0) {
            validationRuleConfig.reloadConfig();
        }
        
        return result;
    }

    /**
     * 删除验证规则配置信息
     * 
     * @param ruleId 验证规则配置主键
     * @return 结果
     */
    @Override
    public int deleteValidationRuleByRuleId(Long ruleId)
    {
        int result = validationRuleMapper.deleteValidationRuleByRuleId(ruleId);
        
        // 删除成功后重新加载配置
        if (result > 0) {
            validationRuleConfig.reloadConfig();
        }
        
        return result;
    }

    /**
     * 重新加载验证规则配置
     * 
     * @return 重新加载的规则数量
     */
    @Override
    public int reloadValidationRules()
    {
        validationRuleConfig.reloadConfig();
        return validationRuleConfig.getAllRules().size();
    }

    /**
     * 验证规则配置的有效性
     * 
     * @param validationRule 验证规则配置
     * @return 验证结果消息，null表示验证通过
     */
    @Override
    public String validateRuleConfiguration(ValidationRule validationRule)
    {
        if (validationRule == null) {
            return "验证规则不能为空";
        }
        
        // 验证规则名称
        if (StringUtils.isEmpty(validationRule.getRuleName())) {
            return "规则名称不能为空";
        }
        
        if (validationRule.getRuleName().length() > 100) {
            return "规则名称长度不能超过100个字符";
        }
        
        // 规则名称格式验证（只允许字母、数字、下划线）
        if (!Pattern.matches("^[a-zA-Z0-9_]+$", validationRule.getRuleName())) {
            return "规则名称只能包含字母、数字和下划线";
        }
        
        // 验证规则类型
        if (StringUtils.isEmpty(validationRule.getRuleType())) {
            return "规则类型不能为空";
        }
        
        if (!isValidRuleType(validationRule.getRuleType())) {
            return "无效的规则类型: " + validationRule.getRuleType();
        }
        
        // 验证规则表达式
        if (StringUtils.isEmpty(validationRule.getRuleExpression())) {
            return "规则表达式不能为空";
        }
        
        if (validationRule.getRuleExpression().length() > 2000) {
            return "规则表达式长度不能超过2000个字符";
        }
        
        // 验证优先级
        if (validationRule.getPriority() != null && validationRule.getPriority() <= 0) {
            return "规则优先级必须大于0";
        }
        
        // 验证规则状态
        if (StringUtils.isNotEmpty(validationRule.getRuleStatus()) && 
            !isValidRuleStatus(validationRule.getRuleStatus())) {
            return "无效的规则状态: " + validationRule.getRuleStatus();
        }
        
        // 验证描述长度
        if (StringUtils.isNotEmpty(validationRule.getDescription()) && 
            validationRule.getDescription().length() > 1000) {
            return "规则描述长度不能超过1000个字符";
        }
        
        // 验证配置JSON长度
        if (StringUtils.isNotEmpty(validationRule.getConfigJson()) && 
            validationRule.getConfigJson().length() > 4000) {
            return "规则配置长度不能超过4000个字符";
        }
        
        // 验证创建人长度
        if (StringUtils.isNotEmpty(validationRule.getCreatedBy()) && 
            validationRule.getCreatedBy().length() > 100) {
            return "创建人长度不能超过100个字符";
        }
        
        return null; // 验证通过
    }

    /**
     * 检查规则名称是否已存在
     * 
     * @param ruleName 规则名称
     * @param excludeRuleId 排除的规则ID（用于更新时检查）
     * @return 是否存在
     */
    @Override
    public boolean checkRuleNameExists(String ruleName, Long excludeRuleId)
    {
        int count = validationRuleMapper.checkRuleNameExists(ruleName, excludeRuleId);
        return count > 0;
    }

    /**
     * 获取下一个可用的优先级值
     * 
     * @return 下一个优先级值
     */
    @Override
    public Integer getNextAvailablePriority()
    {
        Integer nextPriority = validationRuleMapper.getNextAvailablePriority();
        return nextPriority != null ? nextPriority : 1;
    }

    /**
     * 批量更新规则状态
     * 
     * @param ruleIds 规则ID列表
     * @param ruleStatus 新状态
     * @return 更新的记录数
     */
    @Override
    public int batchUpdateRuleStatus(Long[] ruleIds, String ruleStatus)
    {
        // 验证状态有效性
        if (!isValidRuleStatus(ruleStatus)) {
            throw new IllegalArgumentException("无效的规则状态: " + ruleStatus);
        }
        
        int result = validationRuleMapper.batchUpdateRuleStatus(Arrays.asList(ruleIds), ruleStatus);
        
        // 更新成功后重新加载配置
        if (result > 0) {
            validationRuleConfig.reloadConfig();
        }
        
        return result;
    }

    /**
     * 检查规则状态是否有效
     */
    private boolean isValidRuleStatus(String status) {
        return ValidationRule.STATUS_ACTIVE.equals(status) ||
               ValidationRule.STATUS_INACTIVE.equals(status) ||
               ValidationRule.STATUS_DRAFT.equals(status) ||
               ValidationRule.STATUS_DEPRECATED.equals(status);
    }

    /**
     * 检查规则类型是否有效
     */
    private boolean isValidRuleType(String type) {
        return ValidationRule.TYPE_CREDIT_EXISTENCE.equals(type) ||
               ValidationRule.TYPE_CREDIT_VALIDITY.equals(type) ||
               ValidationRule.TYPE_CONTRACT_MATCH.equals(type) ||
               ValidationRule.TYPE_AMOUNT_CONSISTENCY.equals(type) ||
               ValidationRule.TYPE_DATE_CONSISTENCY.equals(type) ||
               ValidationRule.TYPE_STATUS_VALIDATION.equals(type);
    }
}