import AuthRequestProxy = require("../../portalAuthorization/AuthRequestProxy");
import { IAuthProvider } from "../../typings/IAuthProvider";
import { IClusterClientProvider } from "../../typings/IClusterClientProvider";
import { User } from "./User";
import { SearchResponse } from "./SearchResponse";
import { IClusterClientResponse } from "../../typings/IClusterClient";
import { Requisites } from './Requisites';
import topologyConstants from '../../topologyConstants';

const {requisitesVersion} = topologyConstants;

export interface UserRequisitesDeps {
  clusterClientProvider: IClusterClientProvider;
  authProvider: IAuthProvider;
}

export class UserRequisites {
  private _http: AuthRequestProxy;

  constructor({ clusterClientProvider, authProvider }: UserRequisitesDeps) {
    const clusterClient = clusterClientProvider.createClusterClient(
      topologyConstants.requisites
    );
    this._http = new AuthRequestProxy({ clusterClient, authProvider });
  }

  getUser(userId: string) {
    return this._http.send<User>({
      method: "GET",
      url: `${requisitesVersion}/users/${userId}`
    });
  }

  batchGet(
    userIds: Array<string> = [],
    ignoreDeleted: boolean = true,
    ignoreAlias: boolean = true
  ) {
    const data = { ids: userIds };

    return this._http.send<User[]>({
      url: `${requisitesVersion}/users/batch`,
      method: "POST",
      data,
      params: {
        ignoredeleted: ignoreDeleted,
        ignorealias: ignoreAlias
      }
    });
  }

  async setUsersParams(userId: string, updates: Object, deletes?: string[]) {
    return this._http.send({
      method: "PATCH",
      url: `${requisitesVersion}/users/${userId}`,
      data: { updates, deletes }
    });
  }

  async deletePermanently(userId: string) {
    return this._http.send({
      method: "POST",
      url: `${requisitesVersion}/users/${userId}/deletePermanently`,
    });
  }

  async create(userId: string,requisites:Requisites) {
    return this._http.send({
      method: "PUT",
      url: `${requisitesVersion}/users/${userId}`,
      data:{
        requisites
      }
    });
  }

  searchUsers(params: {
    skip?: number;
    take?: number;
    fields?: Array<string>;
    sortBy?: string;
    sortDirection?: string;
    filter: string;
  }) {
    const { skip, take, fields, sortBy, sortDirection, filter } = params;

    return this._http.send<SearchResponse<User>>({
      method: "GET",
      url: `${requisitesVersion}/users`,
      params: {
        skip,
        take,
        fields,
        "sort-by": sortBy,
        "sort-direction": sortDirection,
        filter
      }
    });
  }
}