import {
  IClusterClient,
  IClusterClientRequest,
  IClusterClientResponse
} from "../../typings/IClusterClient";

import { IAuthProvider } from "../../typings/IAuthProvider";

export interface AuthRequestProxyOptions {
  useParams?: boolean;
  useHeaders?: boolean;
}

export interface AuthRequestProxyDeps {
  clusterClient: IClusterClient;
  authProvider: IAuthProvider;
  options?: AuthRequestProxyOptions;
}

export class AuthRequestProxy {
  private _authProvider: IAuthProvider;
  private _clusterClient: IClusterClient;
  private _options: AuthRequestProxyOptions | undefined;

  constructor({ clusterClient, authProvider, options }: AuthRequestProxyDeps) {
    this._clusterClient = clusterClient;
    this._authProvider = authProvider;
    this._options = options;
  }

  async send<T>(
    request: IClusterClientRequest
  ): Promise<IClusterClientResponse<T>> {
    let response = await this._clusterClient.send<T>(
      await this._setAuthParamsToRequest(request)
    );

    // Ретраим если получили 401
    if (response.status === 401) {
      await this._authProvider.updateSid(true);

      response = await this._clusterClient.send<T>(
        await this._setAuthParamsToRequest(request)
      );
    }

    return response;
  }

  private async _setAuthParamsToRequest(request: IClusterClientRequest) {
    if (this._options && this._options.useHeaders) {
      const authHeaders = await this._authProvider.getAuthHeaders();
      request.headers = Object.assign({}, request.headers, authHeaders);
    } else {
      const authParams = await this._authProvider.getAuthParams();
      request.params = Object.assign({}, request.params, authParams);
    }

    return request;
  }
}