import ApiClient from './ApiClient';
import * as U from './types/User';
import urls from './urls';

const mapProfileResponse = (data: U.ProfileResponse): U.Profile => ({
  analyticsOnboardingEnabled: data.analytics_onboarding_enabled,
  id: data.id,
  email: data.email,
  name: data.name,
  createdAt: data.created_at,
  updatedAt: data.updated_at,
  thumbnailUrl: data.thumbnail_url,
  domainId: data.domain_id,
  customerId: data.customer_id,
  enableDeviceOfflineNotifications: data.enable_device_offline_notifications,
  enableApiV3: data.enable_api_v3,
  mfaEnabled: data.mfa_enabled,
  domainRole: data.domain_role,
  remoteAssistanceGrantLevel: data.remote_assistance_grant_level,
  remoteAssistanceExpiresAt: data.remote_assistance_expires_at,
  polyServiceLevel: data.poly_service_level,
  isMultiTimezoneEnabled: data.is_multitimezone_enabled,
  isFreetrialUser: data.is_freetrial_user,
  isLocationEnabled: data.is_location_enabled,
  isStripePaymentMethodAdded: data.is_stripe_payment_method_added || false,
});

const mapOnboardingResponse = (data: U.OnboardingResponse): U.Onboarding => ({
  name: data.name,
  completedAt: data.completed_at,
});

const mapDeviceLicenseResponse = (
  data: U.DeviceLicenseResponse,
): U.DeviceLicense => ({
  licenseType: data.license_type,
  count: data.count,
});

export interface UserCredentials {
  username: string;
  password: string;
}

export default class UserClient {
  async masquerade(this: ApiClient, email: string) {
    const data = await this.requestProtected<
      U.MasqueradeRequest,
      U.MasqueradeResponse
    >({
      method: 'POST',
      url: urls.masquerade(),
      body: { email },
    });

    return data;
  }

  async remoteAssist(this: ApiClient, email: string) {
    const data = await this.requestProtected<
      U.RemoteAssistRequest,
      U.RemoteAssistResponse
    >({
      method: 'POST',
      url: urls.supportRemoteAssist(),
      body: { email },
    });

    return data;
  }

  async unsubscribe(
    this: ApiClient,
    userId: string,
    email = 'device_connectivity_notifications',
  ) {
    await this.requestPublic<U.UnsubscribeRequest, U.UnsubscribeResponse>({
      method: 'POST',
      url: `${urls.unsubscribe(userId)}?email=${email}`,
    });
  }

  async getProfile(this: ApiClient): Promise<U.Profile> {
    const data = await this.requestProtected<
      U.GetProfileRequest,
      U.GetProfileResponse
    >({
      method: 'GET',
      url: urls.profile(),
    });

    return mapProfileResponse(data);
  }

  async updateProfile(
    this: ApiClient & UserClient,
    profile: U.Profile,
  ): Promise<U.Profile> {
    const data = await this.requestProtected<
      U.UpdateProfileRequest,
      U.UpdateProfileResponse
    >({
      method: 'PATCH',
      url: urls.profile(),
      body: {
        analytics_onboarding_enabled: profile.analyticsOnboardingEnabled,
        name: profile.name,
        enable_device_offline_notifications:
          profile.enableDeviceOfflineNotifications,
        mfa_enabled: profile.mfaEnabled,
        remote_assistance_expires_at: profile.remoteAssistanceExpiresAt,
        remote_assistance_grant_level: profile.remoteAssistanceGrantLevel,
      },
    });

    return mapProfileResponse(data);
  }

  async getUserStatus(
    this: ApiClient & UserClient,
    email: string,
  ): Promise<void> {
    await this.requestPublic<void, void>({
      method: 'GET',
      url: urls.userStatus(email),
    });
  }

  async setRemoteAssistance(
    this: ApiClient & UserClient,
    grantLevel: string | null,
    expiresAt: string | null,
  ): Promise<void> {
    await this.requestProtected<
      U.SetRemoteAssistanceRequest,
      U.SetRemoteAssistanceResponse
    >({
      method: 'POST',
      url: urls.setRemoteAssistance(),
      body: {
        remote_assistance_grant_level: grantLevel,
        remote_assistance_expires_at: expiresAt,
      },
    });
  }

  async changeEmail(
    this: ApiClient & UserClient,
    email: string,
    password: string,
  ) {
    await this.requestProtected<U.ChangeEmailRequest, U.ChangeEmailResponse>({
      method: 'POST',
      url: urls.changeEmail(),
      body: {
        email,
        password,
      },
    });
  }

  async getOnboardingStatus(
    this: ApiClient,
    query?: string,
  ): Promise<U.Onboarding[]> {
    const data = await this.requestProtected<
      U.GetOnboardingRequest,
      U.GetOnboardingResponse
    >({
      method: 'GET',
      url: urls.onboarding(query),
    });

    return data.map(mapOnboardingResponse);
  }

  async updateOnboardingStatus(this: ApiClient, name: string): Promise<void> {
    await this.requestProtected<
      U.UpdateOnboardingRequest,
      U.UpdateOnboardingResponse
    >({
      method: 'POST',
      url: `${urls.onboarding()}`,
      body: {
        name,
      },
    });
  }

  async getProfileDeviceLicenses(
    this: ApiClient,
  ): Promise<U.GetProfileDeviceLicenses> {
    const data = await this.requestProtected<
      U.GetProfileDeviceLicensesRequest,
      U.GetProfileDeviceLicensesResponse
    >({
      method: 'GET',
      url: urls.profileDeviceLicenses(),
    });

    return data.map(mapDeviceLicenseResponse);
  }

  async getBillingAccounts(this: ApiClient): Promise<U.BillingAccount[]> {
    const data = await this.requestProtected<
      U.GetBillingAccountsRequest,
      U.GetBillingAccountsResponse
    >({
      method: 'GET',
      url: urls.profileBillingAccounts(),
    });

    return data;
  }

  async createBillingPortalSession(
    this: ApiClient,
    accountId: string,
  ): Promise<U.CreateBillingPortalSessionResponse> {
    const data = await this.requestProtected<
      U.CreateBillingPortalSessionRequest,
      U.CreateBillingPortalSessionResponse
    >({
      method: 'POST',
      url: urls.profileBillingPortalSession(),
      body: { account_id: accountId },
    });

    return data;
  }
}