/**
 * 網關過濾鏈表接口
 * 用于過濾器的鏈式調用
 * Contract to allow a {@link WebFilter} to delegate to the next in the chain.
 *
 * @author Rossen Stoyanchev
 * @since 5.0
 */
public interface GatewayFilterChain {

  /**
   * 鏈表啟動調用入口方法
   * Delegate to the next {@code WebFilter} in the chain.
   * @param exchange the current server exchange
   * @return {@code Mono<Void>} to indicate when request handling is complete
   */
  Mono<Void> filter(ServerWebExchange exchange);

}

  /**
   * 網關過濾的鏈表，用于過濾器的鏈式調用
   * 過濾器鏈表接口的默認實現，
   * 包含2個構建函數：
   * 1.集合參數構建用于初始化吧構建鏈表
   * 2. index，parent參數用于構建當前執(zhí)行過濾對應的下次執(zhí)行的鏈表 
   */
  private static class DefaultGatewayFilterChain implements GatewayFilterChain {

    /**
     * 當前過濾執(zhí)行過濾器在集合中索引
     */
    private final int index;
    /**
     * 過濾器集合
     */
    private final List<GatewayFilter> filters;

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

    /**
     * 構建
     * @param parent 上一個執(zhí)行過濾器對應的FilterChain
     * @param index 當前要執(zhí)行過濾器的索引
     */
    private DefaultGatewayFilterChain(DefaultGatewayFilterChain parent, int index) {
      this.filters = parent.getFilters();
      this.index = index;
    }

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

    /**
     * @param exchange the current server exchange
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
      return Mono.defer(() -> {
        if (this.index < filters.size()) {
          //獲取當前索引的過濾器
          GatewayFilter filter = filters.get(this.index);
          //構建當前索引的下一個過濾器的FilterChain
          DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
          //調用過濾器的filter方法執(zhí)行過濾器
          return filter.filter(exchange, chain);
        } else {
          //當前索引大于等于過濾集合大小，標識所有鏈表都已執(zhí)行完畢，返回空
          return Mono.empty(); // complete
        }
      });
    }
  }

/**
 * 網關路由過濾器，
 * Contract for interception-style, chained processing of Web requests that may
 * be used to implement cross-cutting, application-agnostic requirements such
 * as security, timeouts, and others. Specific to a Gateway
 *
 * Copied from WebFilter
 *
 * @author Rossen Stoyanchev
 * @since 5.0
 */
public interface GatewayFilter extends ShortcutConfigurable {

  String NAME_KEY = "name";
  String VALUE_KEY = "value";

  /**
   * 過濾器執(zhí)行方法
   * Process the Web request and (optionally) delegate to the next
   * {@code WebFilter} through the given {@link GatewayFilterChain}.
   * @param exchange the current server exchange
   * @param chain provides a way to delegate to the next filter
   * @return {@code Mono<Void>} to indicate when request processing is complete
   */
  Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);

}

/**
 * 排序的網關路由過濾器，用于包裝真實的網關過濾器，已達到過濾器可排序
 * @author Spencer Gibb
 */
public class OrderedGatewayFilter implements GatewayFilter, Ordered {

  //目標過濾器
  private final GatewayFilter delegate;
  //排序字段
  private final int order;

  public OrderedGatewayFilter(GatewayFilter delegate, int order) {
    this.delegate = delegate;
    this.order = order;
  }

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

  /**
   * 全局過濾器的包裝類，將全局路由包裝成統(tǒng)一的網關過濾器
   */
  private static class GatewayFilterAdapter implements GatewayFilter {

    /**
     * 全局過濾器
     */
    private final GlobalFilter delegate;

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

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

    /**
     * 全局過濾器，用戶通過HttpClient轉發(fā)請求
     * @param httpClient
     * @param headersFilters
     * @return
     */
    @Bean
    public NettyRoutingFilter routingFilter(HttpClient httpClient,
                        ObjectProvider<List<HttpHeadersFilter>> headersFilters) {
      return new NettyRoutingFilter(httpClient, headersFilters);
    }

    /**
     * 全局的過濾器，用戶將HttpClient客戶端轉發(fā)請求的響應寫入到原始的請求響應中
     * @param properties
     * @return
     */
    @Bean
    public NettyWriteResponseFilter nettyWriteResponseFilter(GatewayProperties properties) {
      return new NettyWriteResponseFilter(properties.getStreamingMediaTypes());
    }

  /**
   * 全局過濾器，用于在通過負載均衡客戶端選擇服務實例信息
   * @param client
   * @return
   */
  @Bean
  @ConditionalOnBean(LoadBalancerClient.class)
  public LoadBalancerClientFilter loadBalancerClientFilter(LoadBalancerClient client) {
    return new LoadBalancerClientFilter(client);
  }

  /**
   * 包裝加載全局的過濾器，將全局過濾器包裝成GatewayFilter
   * @param filters
   * @return
   */
  private static List<GatewayFilter> loadFilters(List<GlobalFilter> filters) {
    return filters.stream()
        .map(filter -> {
          //將所有的全局過濾器包裝成網關過濾器
          GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);
          //判斷全局過濾器是否實現了可排序接口
          if (filter instanceof Ordered) {
            int order = ((Ordered) filter).getOrder();
            //包裝成可排序的網關過濾器
            return new OrderedGatewayFilter(gatewayFilter, order);
          }
          return gatewayFilter;
        }).collect(Collectors.toList());
  }
  @Override
  public Mono<Void> handle(ServerWebExchange exchange) {
    //獲取請求上下文設置的路由實例
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    //獲取路由定義下的網關過濾器集合
    List<GatewayFilter> gatewayFilters = route.getFilters();

    //組合全局的過濾器與路由配置的過濾器
    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    //添加路由配置過濾器到集合尾部
    combined.addAll(gatewayFilters);
    //對過濾器進行排序
    //TODO: needed or cached?
    AnnotationAwareOrderComparator.sort(combined);

    logger.debug("Sorted gatewayFilterFactories: "+ combined);
    //創(chuàng)建過濾器鏈表對其進行鏈式調用
    return new DefaultGatewayFilterChain(combined).filter(exchange);
  }