package cn.novalon.manage.sys.core.util;

import cn.novalon.manage.sys.core.domain.SysConfig;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import java.util.regex.Pattern;

/**
 * 系统配置验证工具类
 * 
 * @author 张翔
 * @date 2026-03-31
 */
public class ValidationUtil {

    // 配置键正则表达式：只允许字母、数字、下划线、点号，长度1-100
    private static final Pattern CONFIG_KEY_PATTERN = Pattern.compile("^[a-zA-Z0-9_.-]{1,100}$");
    
    // 配置名称正则表达式：允许中文、字母、数字、下划线、空格，长度1-50
    private static final Pattern CONFIG_NAME_PATTERN = Pattern.compile("^[\\u4e00-\\u9fa5a-zA-Z0-9_\\\\.\\s]{1,50}$");
    
    // 配置类型正则表达式：只允许字母、数字、下划线，长度1-20
    private static final Pattern CONFIG_TYPE_PATTERN = Pattern.compile("^[a-zA-Z0-9_]{1,20}$");

    /**
     * 验证配置对象
     */
    public static Mono<SysConfig> validateConfig(SysConfig config) {
        if (config == null) {
            return Mono.error(new IllegalArgumentException("配置对象不能为空"));
        }
        
        // 验证配置键
        if (!isValidConfigKey(config.getConfigKey())) {
            return Mono.error(new IllegalArgumentException("配置键格式无效，只允许字母、数字、下划线、点号，长度1-100"));
        }
        
        // 验证配置名称
        if (!isValidConfigName(config.getConfigName())) {
            return Mono.error(new IllegalArgumentException("配置名称格式无效，允许中文、字母、数字、下划线、空格，长度1-50"));
        }
        
        // 验证配置类型
        if (config.getConfigType() != null && !isValidConfigType(config.getConfigType())) {
            return Mono.error(new IllegalArgumentException("配置类型格式无效，只允许字母、数字、下划线，长度1-20"));
        }
        
        // 验证配置值长度
        if (config.getConfigValue() != null && config.getConfigValue().length() > 5000) {
            return Mono.error(new IllegalArgumentException("配置值长度不能超过5000个字符"));
        }
        
        return Mono.just(config);
    }

    /**
     * 验证配置键
     */
    public static boolean isValidConfigKey(String configKey) {
        return configKey != null && CONFIG_KEY_PATTERN.matcher(configKey).matches();
    }

    /**
     * 验证配置名称
     */
    public static boolean isValidConfigName(String configName) {
        return configName != null && CONFIG_NAME_PATTERN.matcher(configName).matches();
    }

    /**
     * 验证配置类型
     */
    public static boolean isValidConfigType(String configType) {
        return configType == null || CONFIG_TYPE_PATTERN.matcher(configType).matches();
    }

    /**
     * 验证ID参数
     */
    public static Mono<Long> validateId(String idStr) {
        try {
            Long id = Long.valueOf(idStr);
            if (id <= 0) {
                return Mono.error(new IllegalArgumentException("ID必须大于0"));
            }
            return Mono.just(id);
        } catch (NumberFormatException e) {
            return Mono.error(new IllegalArgumentException("ID格式无效"));
        }
    }

    /**
     * 创建错误响应
     */
    public static Mono<ServerResponse> createErrorResponse(String message) {
        return ServerResponse.status(HttpStatus.BAD_REQUEST)
                .bodyValue(new ErrorResponse(message));
    }

    /**
     * 错误响应对象
     */
    public static class ErrorResponse {
        private final String message;
        private final long timestamp;

        public ErrorResponse(String message) {
            this.message = message;
            this.timestamp = System.currentTimeMillis();
        }

        public String getMessage() {
            return message;
        }

        public long getTimestamp() {
            return timestamp;
        }
    }
}