/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.vertx.rxjava.ext.auth.oauth2.providers;

import rx.Observable;
import rx.Single;
import io.vertx.rx.java.RxHelper;
import io.vertx.rx.java.WriteStreamSubscriber;
import io.vertx.rx.java.SingleOnSubscribeAdapter;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;

Simplified factory to create an  for Azure AD.
 NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen. /**
 * Simplified factory to create an  for Azure AD.
 *
 * <p/>
 * NOTE: This class has been automatically generated from the {@link io.vertx.ext.auth.oauth2.providers.AzureADAuth original} non RX-ified interface using Vert.x codegen.
 */

@RxGen(io.vertx.ext.auth.oauth2.providers.AzureADAuth.class)
public class AzureADAuth extends io.vertx.rxjava.ext.auth.oauth2.providers.OpenIDConnectAuth {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    AzureADAuth that = (AzureADAuth) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final TypeArg<AzureADAuth> __TYPE_ARG = new TypeArg<>(    obj -> new AzureADAuth((io.vertx.ext.auth.oauth2.providers.AzureADAuth) obj),
    AzureADAuth::getDelegate
  );

  private final io.vertx.ext.auth.oauth2.providers.AzureADAuth delegate;
  
  public AzureADAuth(io.vertx.ext.auth.oauth2.providers.AzureADAuth delegate) {
    super(delegate);
    this.delegate = delegate;
  }

  public AzureADAuth(Object delegate) {
    super((io.vertx.ext.auth.oauth2.providers.AzureADAuth)delegate);
    this.delegate = (io.vertx.ext.auth.oauth2.providers.AzureADAuth)delegate;
  }

  public io.vertx.ext.auth.oauth2.providers.AzureADAuth getDelegate() {
    return delegate;
  }

  
Create a OAuth2Auth provider for Microsoft Azure Active Directory
Params:
vertx – 
clientId – the client id given to you by Azure
clientSecret – the client secret given to you by Azure
guid – the guid of your application given to you by Azure
Returns:
/**
   * Create a OAuth2Auth provider for Microsoft Azure Active Directory
   * @param vertx 
   * @param clientId the client id given to you by Azure
   * @param clientSecret the client secret given to you by Azure
   * @param guid the guid of your application given to you by Azure
   * @return 
   */
  public static io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth create(io.vertx.rxjava.core.Vertx vertx, String clientId, String clientSecret, String guid) { 
    io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth ret = io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.newInstance((io.vertx.ext.auth.oauth2.OAuth2Auth)io.vertx.ext.auth.oauth2.providers.AzureADAuth.create(vertx.getDelegate(), clientId, clientSecret, guid));
    return ret;
  }

  
Create a OAuth2Auth provider for Microsoft Azure Active Directory
Params:
vertx – 
clientId – the client id given to you by Azure
clientSecret – the client secret given to you by Azure
guid – the guid of your application given to you by Azure
httpClientOptions – custom http client options
Returns:
/**
   * Create a OAuth2Auth provider for Microsoft Azure Active Directory
   * @param vertx 
   * @param clientId the client id given to you by Azure
   * @param clientSecret the client secret given to you by Azure
   * @param guid the guid of your application given to you by Azure
   * @param httpClientOptions custom http client options
   * @return 
   */
  public static io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth create(io.vertx.rxjava.core.Vertx vertx, String clientId, String clientSecret, String guid, io.vertx.core.http.HttpClientOptions httpClientOptions) { 
    io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth ret = io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.newInstance((io.vertx.ext.auth.oauth2.OAuth2Auth)io.vertx.ext.auth.oauth2.providers.AzureADAuth.create(vertx.getDelegate(), clientId, clientSecret, guid, httpClientOptions));
    return ret;
  }

  
Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
configuration options and attempt to load the well known descriptor. If a site is provided (for example when
running on a custom instance) that site will be used to do the lookup.

If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
into the OAuth provider so tokens can be decoded.

With this provider, if the given configuration is using the flow type  then
the extra parameters object will include requested_token_use = on_behalf_of as required by
https://docs.microsoft.com/en-us/azure/active-directory.
Params:
vertx – the vertx instance
config – the initial config
handler – the instantiated Oauth2 provider instance handler/**
   * Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
   * configuration options and attempt to load the well known descriptor. If a site is provided (for example when
   * running on a custom instance) that site will be used to do the lookup.
   * <p>
   * If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
   * into the OAuth provider so tokens can be decoded.
   * <p>
   * With this provider, if the given configuration is using the flow type  then
   * the extra parameters object will include <code>requested_token_use = on_behalf_of</code> as required by
   * <a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/v1-oauth2-on-behalf-of-flow">https://docs.microsoft.com/en-us/azure/active-directory</a>.
   * @param vertx the vertx instance
   * @param config the initial config
   * @param handler the instantiated Oauth2 provider instance handler
   */
  public static void discover(io.vertx.rxjava.core.Vertx vertx, io.vertx.ext.auth.oauth2.OAuth2Options config, Handler<AsyncResult<io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth>> handler) { 
    io.vertx.ext.auth.oauth2.providers.AzureADAuth.discover(vertx.getDelegate(), config, new Handler<AsyncResult<io.vertx.ext.auth.oauth2.OAuth2Auth>>() {
      public void handle(AsyncResult<io.vertx.ext.auth.oauth2.OAuth2Auth> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.newInstance((io.vertx.ext.auth.oauth2.OAuth2Auth)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

  
Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
configuration options and attempt to load the well known descriptor. If a site is provided (for example when
running on a custom instance) that site will be used to do the lookup.

If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
into the OAuth provider so tokens can be decoded.

With this provider, if the given configuration is using the flow type  then
the extra parameters object will include requested_token_use = on_behalf_of as required by
https://docs.microsoft.com/en-us/azure/active-directory.
Params:
vertx – the vertx instance
config – the initial config/**
   * Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
   * configuration options and attempt to load the well known descriptor. If a site is provided (for example when
   * running on a custom instance) that site will be used to do the lookup.
   * <p>
   * If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
   * into the OAuth provider so tokens can be decoded.
   * <p>
   * With this provider, if the given configuration is using the flow type  then
   * the extra parameters object will include <code>requested_token_use = on_behalf_of</code> as required by
   * <a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/v1-oauth2-on-behalf-of-flow">https://docs.microsoft.com/en-us/azure/active-directory</a>.
   * @param vertx the vertx instance
   * @param config the initial config
   */
  public static void discover(io.vertx.rxjava.core.Vertx vertx, io.vertx.ext.auth.oauth2.OAuth2Options config) {
    discover(vertx, config, ar -> { });
  }

    
Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
configuration options and attempt to load the well known descriptor. If a site is provided (for example when
running on a custom instance) that site will be used to do the lookup.

If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
into the OAuth provider so tokens can be decoded.

With this provider, if the given configuration is using the flow type  then
the extra parameters object will include requested_token_use = on_behalf_of as required by
https://docs.microsoft.com/en-us/azure/active-directory.
Params:
vertx – the vertx instance
config – the initial config
Returns:
/**
   * Create a OAuth2Auth provider for OpenID Connect Discovery. The discovery will use the default site in the
   * configuration options and attempt to load the well known descriptor. If a site is provided (for example when
   * running on a custom instance) that site will be used to do the lookup.
   * <p>
   * If the discovered config includes a json web key url, it will be also fetched and the JWKs will be loaded
   * into the OAuth provider so tokens can be decoded.
   * <p>
   * With this provider, if the given configuration is using the flow type  then
   * the extra parameters object will include <code>requested_token_use = on_behalf_of</code> as required by
   * <a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/v1-oauth2-on-behalf-of-flow">https://docs.microsoft.com/en-us/azure/active-directory</a>.
   * @param vertx the vertx instance
   * @param config the initial config
   * @return 
   */
  public static Single<io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth> rxDiscover(io.vertx.rxjava.core.Vertx vertx, io.vertx.ext.auth.oauth2.OAuth2Options config) { 
    return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
      discover(vertx, config, fut);
    }));
  }

  public static AzureADAuth newInstance(io.vertx.ext.auth.oauth2.providers.AzureADAuth arg) {
    return arg != null ? new AzureADAuth(arg) : null;
  }

}