import ApiClient from './ApiClient';
import * as DM from './types/Domain';
import * as R from './types/Resource';
import urls from './urls';
import { mapResourceProfileResponse } from './ResourceClient';

const mapDomainResponse = (dm: DM.DomainResponse): DM.Domain => ({
  id: dm.id,
  name: dm.name,
  description: dm.description,
  mfaRequired: dm.mfa_required,
  adminProfileId: dm.admin_profile_id,
  createdAt: dm.created_at,
  r: {
    adminProfile: mapResourceProfileResponse(dm.r.admin_profile),
    profiles: dm.r.profiles.map(mapResourceProfileResponse),
  },
  isMultiTimezoneEnabled: dm.is_multitimezone_enabled,
  isSsoEnabled: dm.is_sso_enabled || false,
  defaultPresentationDuration: dm.default_presentation_duration ?? null,
});

const mapEnterpriseUserResponse = (
  user: DM.EnterpriseUserResponse,
): DM.EnterpriseUser => ({
  id: user?.id || '',
  email: user.email,
  name: user.name,
  domainRole: user.domain_role,
  locations: user?.locations,
});

const mapDomainUserResponse = (user: DM.DomainUserResponse): DM.DomainUser => ({
  id: user?.id || '',
  email: user.email,
  name: user.name,
  domainRole: user.domain_role,
  createdAt: user.created_at,
  locations: user?.locations,
});

const mapPendingDomainUserResponse = (
  user: DM.PendingDomainUserResponse,
): DM.PendingDomainUser => ({
  id: user?.id || '',
  email: user.email,
  name: user.name,
  domainRole: user.domain_role,
  lastSentAt: user.last_send_at,
  locations: user?.locations,
});

export default class DomainClient {
  async getDomain(this: ApiClient): Promise<DM.Domain | null> {
    const data = await this.requestProtected<
      DM.GetDomainRequest,
      DM.GetDomainResponse
    >({
      method: 'GET',
      url: urls.domain(),
    });

    return data ? mapDomainResponse(data) : null;
  }

  async updateDomain(this: ApiClient, domain: DM.Domain): Promise<DM.Domain> {
    const data = await this.requestProtected<
      DM.UpdateDomainRequest,
      DM.UpdateDomainResponse
    >({
      method: 'PATCH',
      url: urls.domain(),
      body: {
        name: domain.name,
        description: domain.description,
        mfa_required: domain.mfaRequired,
        default_presentation_duration: domain.defaultPresentationDuration,
      },
    });

    return mapDomainResponse(data);
  }

  async inviteToDomain(this: ApiClient, email: string): Promise<void> {
    await this.requestProtected<
      DM.InviteDomainRequest,
      DM.InviteDomainResponse
    >({
      method: 'POST',
      url: urls.domainInvite(),
      body: { email },
    });
  }

  async setProfileDomainRole(
    this: ApiClient,
    profileId: string,
    domainRole: DM.DomainRole,
  ): Promise<R.ResourceProfile> {
    const data = await this.requestProtected<
      DM.SetProfileDomainRoleRequest,
      DM.SetProfileDomainRoleResponse
    >({
      method: 'POST',
      url: urls.domainProfileSetRole(profileId),
      body: { domain_role: domainRole },
    });

    return mapResourceProfileResponse(data);
  }

  async getDomainUsers(this: ApiClient): Promise<DM.DomainUser[]> {
    const response = await this.requestProtected<
      DM.GetDomainUsersRequest,
      DM.GetDomainUsersResponse
    >({
      method: 'GET',
      url: urls.getDomainUsers(),
    });

    return response.map((user) => mapDomainUserResponse(user));
  }

  async getPendingDomainUsers(
    this: ApiClient,
  ): Promise<DM.PendingDomainUser[]> {
    const response = await this.requestProtected<
      DM.GetPendingDomainUsersRequest,
      DM.GetPendingDomainUsersResponse
    >({
      method: 'GET',
      url: urls.getPendingDomainUsers(),
    });

    return response.map((user) => mapPendingDomainUserResponse(user));
  }

  async validateEmail(
    this: ApiClient,
    data: DM.ValidateEmailRequest,
  ): Promise<DM.ValidateEmailResponse> {
    const response = await this.requestProtected<
      DM.ValidateEmailRequest,
      DM.ValidateEmailResponse
    >({
      method: 'POST',
      url: urls.validateEmail(),
      body: { email: data.email },
    });

    return response;
  }

  async inviteDomainUser(
    this: ApiClient,
    data: DM.InviteDomainUser,
  ): Promise<DM.EnterpriseUser> {
    const response = await this.requestProtected<
      DM.InviteDomainUserRequest,
      DM.InviteDomainUserResponse
    >({
      method: 'POST',
      url: urls.inviteDomainUser(),
      body: {
        email: data.email,
        name: data.name,
        domain_role: data.domainRole,
        location_ids: data.locationIds,
      },
    });

    return mapEnterpriseUserResponse(response);
  }

  async updateDomainInvite(
    this: ApiClient,
    inviteId: string,
    data: DM.UpdateDomainInvite,
  ): Promise<DM.PendingDomainUser> {
    const response = await this.requestProtected<
      DM.UpdateDomainInviteRequest,
      DM.UpdateDomainInviteResponse
    >({
      method: 'PATCH',
      url: urls.updateDomainInvite(inviteId),
      body: {
        domain_role: data.domainRole,
        location_ids: data.locationIds,
      },
    });

    return mapPendingDomainUserResponse(response);
  }

  async resendDomainInvite(
    this: ApiClient,
    data: { inviteId: string },
  ): Promise<DM.PendingDomainUser> {
    const response = await this.requestProtected<
      DM.ResendDomainInviteRequest,
      DM.ResendDomainInviteResponse
    >({
      method: 'POST',
      url: urls.resendDomainInvite(data.inviteId),
    });

    return mapPendingDomainUserResponse(response);
  }

  async cancelDomainInvite(
    this: ApiClient,
    data: { inviteId: string },
  ): Promise<void> {
    await this.requestProtected<
      DM.CancelDomainInviteRequest,
      DM.CancelDomainInviteResponse
    >({
      method: 'DELETE',
      url: urls.cancelDomainInvite(data.inviteId),
    });
  }

  async acceptDomainInvite(this: ApiClient): Promise<void> {
    await this.requestProtected<
      DM.AcceptDomainInviteRequest,
      DM.AcceptDomainInviteResponse
    >({
      method: 'GET',
      url: urls.acceptDomainInvite(),
    });
  }

  async updateDomainUser(
    this: ApiClient,
    profileId: string,
    data: DM.UpdateDomainUser,
  ): Promise<DM.EnterpriseUser> {
    const response = await this.requestProtected<
      DM.UpdateDomainUserRequest,
      DM.UpdateDomainUserResponse
    >({
      method: 'PATCH',
      url: urls.updateDomainUser(profileId),
      body: {
        name: data.name,
        domain_role: data.domainRole,
        location_ids: data.locationIds,
      },
    });

    return mapEnterpriseUserResponse(response);
  }
}