/*
 * 这里注入的是RoutePredicateHandlerMapping，
 * 但SpringBoot中的WebFluxAutoConfiguration类中会自动引入RequestMappingHandlerMapping类，
 * 那么在DispatcherHandler中的handler方法中处理请求时，会不会把请求交给后者来处理？
 *
 * 虽然会自动引入RequestMappingHandlerMapping，但是在DispatcherHandler的handle方法中可以看到，会调用每个handlerMapping的getHandler方法，
 * 然后选取第一个来处理请求。
 *
 * webHandler是在上面filteringWebHandler方法中创建的。
 * routerLocator参数是名称为cachedCompositeRouteLocator的bean，参考上面的cachedCompositeRouteLocator方法。
 */
@Bean
@ConditionalOnMissingBean
public RoutePredicateHandlerMapping routePredicateHandlerMapping(FilteringWebHandler webHandler,
        RouteLocator routeLocator, GlobalCorsProperties globalCorsProperties, Environment environment) {
    return new RoutePredicateHandlerMapping(webHandler, routeLocator, globalCorsProperties, environment);
}

@Override
protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
    // don't handle requests on management port if set and different than server port
    if (this.managementPortType == DIFFERENT && this.managementPort != null
            && exchange.getRequest().getLocalAddress() != null
            && exchange.getRequest().getLocalAddress().getPort() == this.managementPort) {
        return Mono.empty();
    }
    exchange.getAttributes().put(GATEWAY_HANDLER_MAPPER_ATTR, getSimpleName());

    return Mono.deferContextual(contextView -> {
        exchange.getAttributes().put(GATEWAY_REACTOR_CONTEXT_ATTR, contextView);
        return lookupRoute(exchange) // 查找路由
                // .log("route-predicate-handler-mapping", Level.FINER) //name this
                .flatMap((Function<Route, Mono<?>>) r -> {
                    exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Mapping [" + getExchangeDesc(exchange) + "] to " + r);
                    }

                    // 将路由信息放入上下文中
                    exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, r);
                    // 返回FilteringWebHandler给DispatcherHandler
                    return Mono.just(webHandler);
                }).switchIfEmpty(Mono.empty().then(Mono.fromRunnable(() -> {
                    exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
                    if (logger.isTraceEnabled()) {
                        logger.trace("No RouteDefinition found for [" + getExchangeDesc(exchange) + "]");
                    }
                })));
    });
}

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
    return this.routeLocator.getRoutes() // 通过路由定位器获取到所有的路由
            // individually filter routes so that filterWhen error delaying is not a
            // problem
            .concatMap(route -> Mono.just(route)
                    // 过滤筛选路由
                    .filterWhen(r -> {
                        // add the current route we are testing
                        exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
                        // 根据断言获取真正的路由
                        return r.getPredicate().apply(exchange);
                    })
                    // instead of immediately stopping main flux due to error, log and
                    // swallow it
                    .doOnError(e -> logger.error("Error applying predicate for route: " + route.getId(), e))
                    .onErrorResume(e -> Mono.empty()))
            // .defaultIfEmpty() put a static Route not found
            // or .switchIfEmpty()
            // .switchIfEmpty(Mono.<Route>empty().log("noroute"))
            .next()
            // TODO: error handling
            .map(route -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("Route matched: " + route.getId());
                }
                // 校验路由
                validateRoute(route, exchange);
                return route;
            });

    /*
     * TODO: trace logging if (logger.isTraceEnabled()) {
     * logger.trace("RouteDefinition did not match: " + routeDefinition.getId()); }
     */
}

@Bean
public SimpleHandlerAdapter simpleHandlerAdapter() {
    return new SimpleHandlerAdapter();
}

public class SimpleHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return WebHandler.class.isAssignableFrom(handler.getClass());
	}

	@Override
	public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) {
		WebHandler webHandler = (WebHandler) handler;
		Mono<Void> mono = webHandler.handle(exchange);
		return mono.then(Mono.empty());
	}

}

/*
 * 会将所有GlobalFilter类型的bean封装起来，注意这里的FilteringWebHandler和Spring Framework中的同名类不是同一个，
 * 这里的是gateway模块定义的，要注意区分。
 */
@Bean
@ConditionalOnMissingBean
public FilteringWebHandler filteringWebHandler(List<GlobalFilter> globalFilters) {
    return new FilteringWebHandler(globalFilters);
}

private final List<GatewayFilter> globalFilters;

public FilteringWebHandler(List<GlobalFilter> globalFilters) {
    this.globalFilters = loadFilters(globalFilters);
}

private static List<GatewayFilter> loadFilters(List<GlobalFilter> filters) {
    return filters.stream().map(filter -> {
        // 通过适配器将GlobalFilter适配为GatewayFilter
        GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);

        // 如果过滤器实现了Ordered接口，则将GatewayFilter封装为OrderedGatewayFilter
        if (filter instanceof Ordered) {
            int order = ((Ordered) filter).getOrder();
            return new OrderedGatewayFilter(gatewayFilter, order);
        }
        return gatewayFilter;
    }).collect(Collectors.toList());
}

private static class GatewayFilterAdapter implements GatewayFilter {

    private final GlobalFilter delegate;

    GatewayFilterAdapter(GlobalFilter delegate) {
        this.delegate = delegate;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return this.delegate.filter(exchange, chain);
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("GatewayFilterAdapter{");
        sb.append("delegate=").append(delegate);
        sb.append('}');
        return sb.toString();
    }

}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    // 从上下文中获取路由信息
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    // 获取到该路由的所有filter
    List<GatewayFilter> gatewayFilters = route.getFilters();

    // 和全局过滤器合并在一起
    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    // 合并两种filter
    combined.addAll(gatewayFilters);
    // TODO: needed or cached?
    // 对filter进行排序
    AnnotationAwareOrderComparator.sort(combined);

    if (logger.isDebugEnabled()) {
        logger.debug("Sorted gatewayFilterFactories: " + combined);
    }

    // 创建filter链并执行
    return new DefaultGatewayFilterChain(combined).filter(exchange);
}

private static class DefaultGatewayFilterChain implements GatewayFilterChain {

    private final int index;

    private final List<GatewayFilter> filters;

    DefaultGatewayFilterChain(List<GatewayFilter> filters) {
        this.filters = filters;
        this.index = 0;
    }

    private DefaultGatewayFilterChain(DefaultGatewayFilterChain parent, int index) {
        this.filters = parent.getFilters();
        this.index = index;
    }

    public List<GatewayFilter> getFilters() {
        return filters;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
        return Mono.defer(() -> {
            // 判断是否已经执行过所有的过滤器了
            if (this.index < filters.size()) {
                // 取出当前所要执行的过滤器
                GatewayFilter filter = filters.get(this.index);
                // 对于每个filter，都创建一个DefaultGatewayFilterChain
                DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
                // 递归调用过滤器
                return filter.filter(exchange, chain);
            }
            else {
                return Mono.empty(); // complete
            }
        });
    }

}