package com.sf.vertx.handle;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import com.hazelcast.config.Config;
import com.hazelcast.config.JoinConfig;
import com.hazelcast.config.NetworkConfig;
import com.hazelcast.config.TcpIpConfig;
import com.sf.vertx.api.pojo.ApiConfig;
import com.sf.vertx.api.pojo.AppConfig;
import com.sf.vertx.api.pojo.DataSecurity;
import com.sf.vertx.api.pojo.Node;
import com.sf.vertx.api.pojo.RouteContent;
import com.sf.vertx.api.pojo.SacService;
import com.sf.vertx.api.pojo.Strategy;
import com.sf.vertx.api.pojo.VertxConfig;
import com.sf.vertx.arithmetic.roundRobin.SacLoadBalancing;
import com.sf.vertx.constans.RedisKeyConfig;
import com.sf.vertx.enums.GatewayServiceType;
import com.sf.vertx.httpproxy.HttpProxy;
import com.sf.vertx.init.SacVertxConfig;
import com.sf.vertx.pojo.ClusterEventMsg;
import com.sf.vertx.pojo.SacCircuitBreaker;
import com.sf.vertx.pojo.SacCurrentLimiting;
import com.sf.vertx.security.MainSecurity;
import com.sf.vertx.utils.ProxyTool;

import cn.hutool.core.collection.ConcurrentHashSet;
import io.github.resilience4j.ratelimiter.RateLimiterConfig;
import io.github.resilience4j.ratelimiter.RateLimiterRegistry;
import io.vertx.circuitbreaker.CircuitBreaker;
import io.vertx.circuitbreaker.CircuitBreakerOptions;
import io.vertx.core.Future;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.net.JksOptions;
import io.vertx.core.spi.cluster.ClusterManager;
import io.vertx.ext.web.Route;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.client.WebClient;
import io.vertx.ext.web.handler.CorsHandler;
import io.vertx.ext.web.handler.HttpException;
import io.vertx.httpproxy.ProxyContext;
import io.vertx.httpproxy.ProxyInterceptor;
import io.vertx.httpproxy.ProxyResponse;
import io.vertx.spi.cluster.hazelcast.HazelcastClusterManager;
import lombok.extern.slf4j.Slf4j;

/***
 * vertx配置维护
 *
 * @author xy
 *
 */
@Slf4j
public class AppConfigHandler {
	private static VertxConfig VERTX_CONFIG = new VertxConfig();
	public static Vertx VERTX;
	private static SacVertxConfig sacVertxConfig;
	private static RedisTemplate<String, String> redisTemplate;
	private static final ConcurrentHashMap<String, AppConfig> CACHE_APP_CONFIG_MAP = new ConcurrentHashMap<>();
	// global api config appCode - RateLimiterRegistry
	private static final ConcurrentHashMap<String, SacCurrentLimiting> GLOBAL_API_CURRENT_LIMITING_MAP = new ConcurrentHashMap<>();
	// global app config appCode - Strategy
	private static final ConcurrentHashMap<String, SacCurrentLimiting> GLOBAL_APP_CURRENT_LIMITING_MAP = new ConcurrentHashMap<>();
	// appCode:apiCode:SacLoadBalancing
	private static ConcurrentHashMap<String, SacLoadBalancing> LOADBALANCING_MAP = new ConcurrentHashMap<>();
	// appCode:apiCode - ApiConfig
	private static ConcurrentHashMap<String, ApiConfig> APICODE_CONFIG_MAP = new ConcurrentHashMap<>();
	// apiCode限流配置 appCode:apiCode - RateLimiterRegistry
	private static ConcurrentHashMap<String, SacCurrentLimiting> APICODE_CONFIG_CURRENT_LIMITING_MAP = new ConcurrentHashMap<>();
	// 服务类型, apiCode限流配置 appCode:apiCode - 服务类型，SAC=SAC规范服务，OPEN=开放服务
	private static ConcurrentHashMap<String, String> APICODE_CONFIG_SERVICE_TYPE_MAP = new ConcurrentHashMap<>();

	// 负载均衡路由类型 appCode:apiCode - routerType
	// 执行流程 routerType= <br/>
	// 1、serviceNodel="NORMAL", serviceNodel="ROUTE" and RouteType = "WEIGHT_ROUTE"
	// <br/>
	// return LOADBALANCING_MAP
	// 2、serviceNodel="ROUTE", RouteType = "HEADER_ROUTE" <br/>
	// return APICODE_CONFIG_ROUTERCONENT_MAP
	private static ConcurrentHashMap<String, Integer> APICODE_CONFIG_ROUTERTYPE_MAP = new ConcurrentHashMap<>();

	private static ConcurrentHashMap<String, List<RouteContent>> APICODE_CONFIG_HEADER_ROUTERCONENT_MAP = new ConcurrentHashMap<>();
	// apiCode熔断配置 appCode:apiCode - CircuitBreaker
	private static ConcurrentHashMap<String, SacCircuitBreaker> APICODE_CONFIG_CIRCUIT_BREAKER_MAP = new ConcurrentHashMap<>();

	// apicode uri = * - appConfig
	private static ConcurrentHashMap<String, AppConfig> APICODE_APPCONFIG_MAP = new ConcurrentHashMap<>();

	// 禁用appCode
	private static ConcurrentHashSet<String> DISABLED_APPCODE = new ConcurrentHashSet<String>();

	public static AppConfig getAppConfigByDomain(String domain) {
		return APICODE_APPCONFIG_MAP.get(domain);
	}

	public static Integer routerType(String key) {
		return APICODE_CONFIG_ROUTERTYPE_MAP.get(key) != null ? APICODE_CONFIG_ROUTERTYPE_MAP.get(key) : 1;
	}

	public static List<RouteContent> routerHeaderConentList(String key) {
		return APICODE_CONFIG_HEADER_ROUTERCONENT_MAP.get(key);
	}

	public static Boolean isServiceTypeOpen(String key) {
		return APICODE_CONFIG_SERVICE_TYPE_MAP.get(key) != null
				&& StringUtils.equals(APICODE_CONFIG_SERVICE_TYPE_MAP.get(key), GatewayServiceType.OPEN.getCode());
	}

	public static Boolean isServiceTypeSac(String key) {
		return APICODE_CONFIG_SERVICE_TYPE_MAP.get(key) != null
				&& StringUtils.equals(APICODE_CONFIG_SERVICE_TYPE_MAP.get(key), GatewayServiceType.SAC.getCode());
	}

	public static String getServiceType(String key) {
		return APICODE_CONFIG_SERVICE_TYPE_MAP.get(key);
	}

	public static String sacResponseHeaderKey() {
		return sacVertxConfig.getSacResponseHeaderKey();
	}

	public static String rpcUri() {
		return sacVertxConfig.getRpcUri();
	}

	public static void removeDisabledAppcode(String appCode) {
		DISABLED_APPCODE.remove(appCode);
	}

	public static void addDisabledAppcode(String appCode) {
		DISABLED_APPCODE.add(appCode);
	}

	public static boolean isDisabledAppcode(String appCode) {
		return DISABLED_APPCODE.contains(appCode);
	}

	public static SacCurrentLimiting getGlobalAppCurrentLimitingConfig(String appCode) {
		return GLOBAL_APP_CURRENT_LIMITING_MAP.get(appCode);
	}

	public static AppConfig getAppConfig(String appCode) {
		return CACHE_APP_CONFIG_MAP.get(appCode);
	}

	public static void init(RedisTemplate<String, String> _redisTemplate, SacVertxConfig _sacVertxConfig) {
		redisTemplate = _redisTemplate;
		sacVertxConfig = _sacVertxConfig;
	}

	public static boolean isDataSecurity(String appCode) {
		return CACHE_APP_CONFIG_MAP.get(appCode) != null && CACHE_APP_CONFIG_MAP.get(appCode).getDataSecurity() != null;
	}

	public static boolean isApiCodeCircuitBreaker(String key) {
		return APICODE_CONFIG_CIRCUIT_BREAKER_MAP.get(key) != null;
	}

	public static SacCircuitBreaker getApiCodeCircuitBreaker(String key) {
		return APICODE_CONFIG_CIRCUIT_BREAKER_MAP.get(key);
	}

	/***
	 * 优先apicode配置限流、无法找到匹配全局限流
	 *
	 * @param appCode
	 * @param apiCode
	 * @return
	 */
	public static SacCurrentLimiting getApiCurrentLimiting(String appCode, String apiCode) {
		String key = appCode + ":" + apiCode;
		SacCurrentLimiting sacCurrentLimiting = APICODE_CONFIG_CURRENT_LIMITING_MAP.get(key) != null
				? APICODE_CONFIG_CURRENT_LIMITING_MAP.get(key)
				: null;
		sacCurrentLimiting = sacCurrentLimiting != null ? sacCurrentLimiting
				: (GLOBAL_API_CURRENT_LIMITING_MAP.get(appCode) != null ? GLOBAL_API_CURRENT_LIMITING_MAP.get(appCode)
						: null);
		return sacCurrentLimiting;
	}

	public static VertxConfig getVertxConfig() {
		return VERTX_CONFIG;
	}

	public static String getAppCodeHeaderKey() {
		return VERTX_CONFIG.getAppCodeHeaderKey();
	}

	public static String getApiCodeHeaderKey() {
		return VERTX_CONFIG.getApiCodeHeaderKey();
	}

	public static SacLoadBalancing getLoadBalancing(String key) {
		return LOADBALANCING_MAP.get(key);
	}

	public static ApiConfig getApicodeConfig(String key) {
		return APICODE_CONFIG_MAP.get(key);
	}

	public static Long getApicodeConfigTimeOut(String key) {
		return APICODE_CONFIG_MAP.get(key) != null ? APICODE_CONFIG_MAP.get(key).getTimeout() : 3000L;
	}

	private static RateLimiterRegistry createRateLimiter(Strategy strategy) {
		RateLimiterConfig config = RateLimiterConfig.custom()
				.limitRefreshPeriod(Duration.ofSeconds(strategy.getTimeWindow()))
				.limitForPeriod(strategy.getThreshold()).timeoutDuration(Duration.ofMillis(0)).build();
		RateLimiterRegistry registry = RateLimiterRegistry.of(config);
		return registry;
	}

	private static void initRateLimiter(String appCode, Strategy strategy,
			ConcurrentHashMap<String, SacCurrentLimiting> map) {
		RateLimiterRegistry registry = createRateLimiter(strategy);
		SacCurrentLimiting sacCurrentLimiting = new SacCurrentLimiting();
		sacCurrentLimiting.setStrategy(strategy);
		sacCurrentLimiting.setRegistry(registry);
		map.put(appCode, sacCurrentLimiting);
	}

	/***
	 * 从redis加载数据
	 *
	 * @throws Exception
	 */
	public static void initAllAppConfig() {
		Set<String> set = redisTemplate.opsForZSet().range(RedisKeyConfig.APP_CONFIG_SET_KEY, 0, -1);
		for (String appCode : set) {
			AppConfigHandler.initAppConfig(appCode, false);
		}
	}

	/***
	 * 加载vertx配置
	 */
	public static void initVertxConfig() {
		String vertxConfigKey = RedisKeyConfig.VERTX_CONFIG_STRING_KEY;
		String vertxConfigValue = redisTemplate.opsForValue().get(vertxConfigKey);
		if (StringUtils.isNotBlank(vertxConfigValue)) {
			VERTX_CONFIG = JSONObject.parseObject(vertxConfigValue, VertxConfig.class);
		}
	}

	private static void delAppConfigCache(String appCode) {
		AppConfig appConfig = CACHE_APP_CONFIG_MAP.get(appCode);
		if (appConfig != null) {
			// app、api默认限流
			GLOBAL_API_CURRENT_LIMITING_MAP.remove(appCode);
			GLOBAL_APP_CURRENT_LIMITING_MAP.remove(appCode);
			for (SacService sacService : appConfig.getService()) {
				if (sacService.getApiConfig() != null && sacService.getApiConfig().size() > 0) {
					for (ApiConfig apiConfig : sacService.getApiConfig()) {
						String key = appCode + ":" + apiConfig.getApiCode();
						APICODE_CONFIG_MAP.remove(key);
						LOADBALANCING_MAP.remove(key);
						APICODE_CONFIG_SERVICE_TYPE_MAP.remove(key);
						APICODE_CONFIG_CURRENT_LIMITING_MAP.remove(key);
						APICODE_APPCONFIG_MAP.remove(apiConfig.getApiCode());
						String keyCircuitBreaker = key + ":" + "CIRCUIT_BREAKER";
						SacCircuitBreaker sacCircuitBreaker = APICODE_CONFIG_CIRCUIT_BREAKER_MAP.get(key);
						if (sacCircuitBreaker != null) {
							if(sacCircuitBreaker.getCircuitBreaker() != null) {
								sacCircuitBreaker.getCircuitBreaker().close();
							}
							APICODE_CONFIG_CIRCUIT_BREAKER_MAP.remove(keyCircuitBreaker);
						}
					}
				}
			}
			// 应用配置
			CACHE_APP_CONFIG_MAP.remove(appCode);
		}
	}

	public static void initAppConfig(String appCode, boolean isDelLocalCache) {
		// 是否需要先删除
		if (isDelLocalCache) {
			delAppConfigCache(appCode);
		}

		String appCodeKey = RedisKeyConfig.APP_CONFIG_PREFIX_KEY + ":" + appCode;
		String appCodeValue = redisTemplate.opsForValue().get(appCodeKey);
		if (StringUtils.isNotBlank(appCodeValue)) {
			AppConfig appConfig = JSON.parseObject(appCodeValue, new TypeReference<AppConfig>() {
			});
			CACHE_APP_CONFIG_MAP.put(appCode, appConfig);

			// app、api默认限流
			if (appConfig.getApiCurrentLimitingConfig() != null) {
				initRateLimiter(appCode, appConfig.getApiCurrentLimitingConfig(), GLOBAL_API_CURRENT_LIMITING_MAP);
			}

			if (appConfig.getAppCurrentLimitingConfig() != null) {
				initRateLimiter(appCode, appConfig.getAppCurrentLimitingConfig(), GLOBAL_APP_CURRENT_LIMITING_MAP);
			}

			// app router负载均衡
			List<RouteContent> routeContentList = null;
			for (SacService sacService : appConfig.getService()) {
				int routerType = 1;
				List<Node> nodeList = new ArrayList<>();
				// 获取service模式
				if (StringUtils.equals(sacService.getServiceModel(), "NORMAL")) {
					Node node = new Node();
					node.setIp(sacService.getServerAddress().getHost());
					node.setPort(sacService.getServerAddress().getPort());
					node.setWeight(0);
					node.setProtocol(sacService.getServerAddress().getProtocol());
					nodeList.add(node);
				} else if (StringUtils.equals(sacService.getServiceModel(), "ROUTE")) {
					if (sacService.getRouteConfig() != null
							&& StringUtils.equals(sacService.getRouteConfig().getRouteType(), "WEIGHT_ROUTE")) {
						for (RouteContent routeContent : sacService.getRouteConfig().getRouteContent()) {
							Node node = new Node();
							node.setIp(routeContent.getServerAddress().getHost());
							node.setPort(routeContent.getServerAddress().getPort());
							node.setWeight(routeContent.getWeight() != null && routeContent.getWeight() > 0
									? routeContent.getWeight()
									: 1);
							node.setProtocol(routeContent.getServerAddress().getProtocol());
							nodeList.add(node);
						}
					} else if (sacService.getRouteConfig() != null
							&& StringUtils.equals(sacService.getRouteConfig().getRouteType(), "HEADER_ROUTE")) {
						routerType = 2;
						routeContentList = sacService.getRouteConfig().getRouteContent();
					}
				}

				// 初始化apiConfig
				if (sacService.getApiConfig() != null && sacService.getApiConfig().size() > 0) {
					for (ApiConfig apiConfig : sacService.getApiConfig()) {
						String key = appCode + ":" + apiConfig.getApiCode();
						APICODE_CONFIG_MAP.put(key, apiConfig);
						if (sacService.getServiceType() != null) {
							APICODE_CONFIG_SERVICE_TYPE_MAP.put(key, sacService.getServiceType());
						}

						// OPEN模式, 域名映射
						if (isServiceTypeOpen(key)) {
							APICODE_APPCONFIG_MAP.put(apiConfig.getApiCode(), appConfig);
						}

						// 负载均衡模式
						APICODE_CONFIG_ROUTERTYPE_MAP.put(key, routerType);
						switch (routerType) {
						case 1:
							if (nodeList.size() > 0) {
								// 初始化负载均衡算法
								SacLoadBalancing sacLoadBalancing = ProxyTool.roundRobin(nodeList);
								LOADBALANCING_MAP.put(key, sacLoadBalancing);
							}
							break;
						case 2:
							APICODE_CONFIG_HEADER_ROUTERCONENT_MAP.put(key, routeContentList);
						default:
							break;
						}

						if (apiConfig.getStrategy() != null && apiConfig.getStrategy().size() > 0) {
							for (Strategy strategy : apiConfig.getStrategy()) {
								if (StringUtils.equals(strategy.getType(), "CURRENT_LIMITING")) {
									RateLimiterRegistry registry = createRateLimiter(strategy);
									SacCurrentLimiting sacCurrentLimiting = new SacCurrentLimiting();
									sacCurrentLimiting.setStrategy(strategy);
									sacCurrentLimiting.setRegistry(registry);
									APICODE_CONFIG_CURRENT_LIMITING_MAP.put(key, sacCurrentLimiting);
								} else if (StringUtils.equals(strategy.getType(), "CIRCUIT_BREAKER")) {
									String keyCircuitBreaker = key + ":" + "CIRCUIT_BREAKER";
//									interfaceBreaker = CircuitBreaker.create("interfaceBreaker", VERTX,
//									  new CircuitBreakerOptions().setMaxFailures(3).setMaxRetries(5).setTimeout(2000)
//									  .setFallbackOnFailure(true)
//									).openHandler(v -> {
//									  log.info("Circuit opened");
//									}).closeHandler(v -> {
//										log.info("Circuit closed");
//									});//.retryPolicy(retryCount -> retryCount * 100L);

									// apiCode熔断
									CircuitBreaker circuitBreaker = CircuitBreaker
											.create(keyCircuitBreaker + "-circuit-breaker", VERTX,
													new CircuitBreakerOptions().setMaxFailures(strategy.getThreshold()) // 最大失败数
															.setFailuresRollingWindow(strategy.getTimeWindow() * 1000) // 毫秒
															// .setTimeout(apiConfig.getTimeout()) // 超时时间,不要开启,
															// 配置会设置接口超时, 这个参数有bug,半开超时会卡死
															.setFallbackOnFailure(true) // 失败后是否调用回退函数（fallback）
															.setResetTimeout(strategy.getRecovery_interval() * 1000) // 在开启状态下，尝试重试之前所需时间
											).openHandler(v -> {
												log.info(keyCircuitBreaker + " Circuit open");
											}).halfOpenHandler(v -> {
												log.info(keyCircuitBreaker + " Circuit halfOpen");
											}).closeHandler(v -> {
												log.info(keyCircuitBreaker + " Circuit close");
											});
									SacCircuitBreaker sacCircuitBreaker = new SacCircuitBreaker();
									sacCircuitBreaker.setCircuitBreaker(circuitBreaker);
									sacCircuitBreaker.setStrategy(strategy);
									APICODE_CONFIG_CIRCUIT_BREAKER_MAP.put(key, sacCircuitBreaker);
								}
							}
						}
					}
				}

			}
		}
	}

	public static void createVertx() {
		// TODO 编解码线程池,后面优化协程等方式
		VertxOptions vertxOptions = new VertxOptions();
		loadVertxOptions(vertxOptions);
		VERTX = Vertx.vertx(vertxOptions);
		createVertxRouter();
		consumerClusterEventMsg();
	}

	private static Config hazelcastConfig(SacVertxConfig sacVertxConfig) {
		// 集群
		Config hazelcastConfig = new Config();
		hazelcastConfig.setClusterName(sacVertxConfig.getClusterName()); // 集群名字
		NetworkConfig networkConfig = new NetworkConfig();
		networkConfig.setPort(sacVertxConfig.getNetworkPort());
		networkConfig.setPortAutoIncrement(sacVertxConfig.isPortAutoIncrement());

		JoinConfig join = new JoinConfig();
		TcpIpConfig tcpIpConfig = new TcpIpConfig();
		tcpIpConfig.setEnabled(true);
		String[] clusterIps = sacVertxConfig.getClusterIp().split(",");
		List<String> members = Arrays.asList(clusterIps);
		tcpIpConfig.setMembers(members);
		join.setTcpIpConfig(tcpIpConfig);
		networkConfig.setJoin(join);
		hazelcastConfig.setNetworkConfig(networkConfig);

		// TODO 还有问题,不会使用
//		ManagementCenterConfig managementCenterConfig = new ManagementCenterConfig();
//		Set<String> interfaces = new HashSet<>();
//		interfaces.add("http://192.168.1.68:8080/mancenter");
//		managementCenterConfig.setTrustedInterfaces(interfaces);
//		hazelcastConfig.setManagementCenterConfig(managementCenterConfig);
		return hazelcastConfig;
	}

	public static void createHazelcastClusterVertx() {
		Config hazelcastConfig = hazelcastConfig(sacVertxConfig);
		ClusterManager hazelcastClusterManager = new HazelcastClusterManager(hazelcastConfig);
		// TODO 编解码线程池,后面优化协程等方式
		VertxOptions vertxOptions = new VertxOptions();
		loadVertxOptions(vertxOptions);
		vertxOptions.setClusterManager(hazelcastClusterManager);
		Vertx.clusteredVertx(vertxOptions, res -> {
			if (res.succeeded()) {
				VERTX = res.result();
				log.info("hazelcastClusterManager create success");
				createVertxRouter();
				consumerClusterEventMsg();
			} else {
				res.cause().printStackTrace();
				log.info("hazelcastClusterManager create failure");
			}
		});
	}

	private static void consumerClusterEventMsg() {
		// 订阅消息
		VERTX.eventBus().consumer("sac_cluster_event", message -> {
			if (message.body() != null) {
				ClusterEventMsg msg = JSONObject.parseObject(message.body().toString(), ClusterEventMsg.class);
				log.info("Received message: {}", msg);
				// message.reply("我是返回数据===" + message.body());
				if (msg.getType() == 1) {
					if (msg.getOperation() == 1) {
						// 初始化AppConfig本地缓存
						AppConfigHandler.initAppConfig(msg.getAppCode(), true);
					} else if (msg.getOperation() == 3) {
						// 删除本地缓存
						delAppConfigCache(msg.getAppCode());
					} else if (msg.getOperation() == 4) {
						// 禁用app
						addDisabledAppcode(msg.getAppCode());
					} else if (msg.getOperation() == 5) {
						// 启用app
						removeDisabledAppcode(msg.getAppCode());
					}
				}
			}
		});
	}

	/***
	 * 发布消息，订阅消息
	 *
	 * @param msg
	 */
	public static void publishClusterEventMsg(ClusterEventMsg msg) {
		VERTX.eventBus().publish("sac_cluster_event", JSONObject.toJSONString(msg));
	}

	private static void createVertxRouter() {
		// consul初始化
		// ConsulHandler.init(vertx);

		// 从redis同步app配置
		initAllAppConfig();

		VertxConfig vertxConfig = AppConfigHandler.getVertxConfig();
		// 创建HTTP监听
		// 所有ip都能访问
		HttpServerOptions httpServerOptions = new HttpServerOptions().setHost("0.0.0.0");
		if (sacVertxConfig.isSSLs()) {
			httpServerOptions.setSsl(true)
					.setKeyStoreOptions(new JksOptions().setPassword("changeit").setPath("keystore.jks"));
		}
		HttpServer server = VERTX.createHttpServer(httpServerOptions);
		Router mainHttpRouter = Router.router(VERTX);
		Integer serverPort = vertxConfig.getPort() == null ? sacVertxConfig.getPort() : vertxConfig.getPort();
		log.info("serverPort:{}", serverPort);
		server.requestHandler(mainHttpRouter).listen(serverPort, h -> {
			if (h.succeeded()) {
				log.info("HTTP端口监听成功:{}", serverPort);
			} else {
				log.error("HTTP端口监听失败:{}", serverPort);
			}
		});

		HttpClient proxyClient = VERTX.createHttpClient();
		HttpProxy proxy = HttpProxy.reverseProxy(proxyClient);
		proxy.originSelector(request -> Future.succeededFuture(ProxyTool.resolveOriginAddress(request)));
		proxy.addInterceptor(new ProxyInterceptor() {
			@Override
			public Future<ProxyResponse> handleProxyRequest(ProxyContext context) {
//				if(StringUtils.equals(sacAppHeaderKey, "dsafdsfadafhappC")) {
//					// 会跳转到 RestfulFailureHandlerImpl
//					throw new HttpException(10003);
//				}
				return context.sendRequest();
			}

			@Override
			public Future<Void> handleProxyResponse(ProxyContext context) {
				// 调试代码,获取reponse body
//				Filter filter = new Filter();
//				ProxyResponse proxyResponse = context.response();
//				Body body = proxyResponse.getBody();
//				proxyResponse.setBody(Body.body(filter.init(context.request().getURI(), body.stream(), false)));
				// 继续拦截链
				return context.sendResponse();
			}
		});

		WebClient mainWebClient = WebClient.create(VERTX);
		String rateLimitModel = vertxConfig.getRateLimitModel();
		Route routeSac = mainHttpRouter.post(rpcUri());
		routeSac.handler(CorsHandler.create().addRelativeOrigin(".*"))
				.handler(ParameterCheckHandler.create(GatewayServiceType.SAC))
				.handler(AppRateLimitHandler.create(rateLimitModel))
				.handler(ApiRateLimitHandler.create(rateLimitModel))
				.handler(BodyPreCheckHandler.create())
				.handler(BodyHandler.create().setHandleFileUploads(false))
				.handler(BodyPostAnalysisHandler.create())
				.handler(BodyPostCheckHandler.create())
				.handler(SacRouteRequestHandler.create(mainWebClient))
				.handler(ProxyHandler.create(mainWebClient, proxy))
				.failureHandler(RestfulFailureHandler.create());

		Route routeOpen = mainHttpRouter.route();
		routeOpen.handler(CorsHandler.create().addRelativeOrigin(".*"))
				.handler(ParameterCheckHandler.create(GatewayServiceType.OPEN))
				.handler(AppRateLimitHandler.create(rateLimitModel))
				.handler(ApiRateLimitHandler.create(rateLimitModel))
				.handler(BodyPreCheckHandler.create())
				.handler(BodyHandler.create().setHandleFileUploads(false))
				.handler(BodyPostCheckHandler.create())
				.handler(SacRouteRequestHandler.create(mainWebClient))
				.handler(ProxyHandler.create(mainWebClient, proxy))
				.failureHandler(RestfulFailureHandler.create());
	}

	private static void loadVertxOptions(VertxOptions vertxOptions) {
		long blockedThreadCheckInterval = VERTX_CONFIG.getVertxOptionsConfig() == null ? -1
				: VERTX_CONFIG.getVertxOptionsConfig().getBlockedThreadCheckInterval();
		int workerPoolSize = VERTX_CONFIG == null || VERTX_CONFIG.getVertxOptionsConfig() == null ? -1
				: VERTX_CONFIG.getVertxOptionsConfig().getWorkerPoolSize();
		if (workerPoolSize != -1) {
			vertxOptions.setWorkerPoolSize(workerPoolSize);
		}

		// TODO
		// blockedThreadCheckInterval = 1000000L;
		if (blockedThreadCheckInterval != -1) {
			vertxOptions.setBlockedThreadCheckInterval(blockedThreadCheckInterval); // 不打印Thread blocked 阻塞日志
		}
	}

	public static String bodyEncrypt(String body, String appCode) {
		DataSecurity dataSecurity = getAppConfig(appCode).getDataSecurity();
		switch (dataSecurity.getAlgorithm()) {
		case "AES":
			return MainSecurity.aesEncrypt(body, dataSecurity.getPrivateKey());
		case "RSA":
			return MainSecurity.rsaEncrypt(body, dataSecurity.getPublicKey());
		default:
			break;
		}
		log.info(" appCode:{}, encrypt key config is error.", appCode);
		throw new HttpException(10011);
	}

	public static String bodyDecrypt(String body, String appCode) {
		DataSecurity dataSecurity = getAppConfig(appCode).getDataSecurity();
		switch (dataSecurity.getAlgorithm()) {
		case "AES":
			return MainSecurity.aesDecrypt(body, dataSecurity.getPrivateKey());
		case "RSA":
			return MainSecurity.rsaDecrypt(body, dataSecurity.getPrivateKey());
		default:
			break;
		}
		log.info(" appCode:{}, decrypt key config is error.", appCode);
		throw new HttpException(10011);
	}

}