import { mapResourceResponse, mapResourceV2Response } from './ResourceClient';
import ApiClient from './ApiClient';
import * as A from './types/Application';
import urls from './urls';

export const mapApplicationVersionResponse = (
  av: A.ApplicationVersionResponse,
): A.ApplicationVersion => ({
  id: av.id,
  name: av.name,
  description: av.description,
  thumbnailUrl: av.thumbnail_url,
  iconUrl: av.icon_url,
  sourceUrl: av.source_url,
  applicationId: av.application_id,
  presentationProperties: av.presentation_properties,
  majorVersion: av.major_version,
  minorVersion: av.minor_version,
  patchVersion: av.patch_version,
  previewResolution: av.preview_resolution,
  previewOrientation: av.preview_orientation,
  strings: av.strings,
  dynamicThumbnails: av.has_dynamic_thumbnails,
  configurableDuration: av.configurable_duration,
  defaultDuration: av.default_duration,
  embeddedUrlFormat: av.embedded_url_format,
  reviewStatus: av.review_status,
  createdAt: av.created_at,
  updatedAt: av.updated_at,
  helperLinkText: av.helper_link_text,
  helperLinkUrl: av.helper_link_url,
  scopes: av.scopes ?? [],
});

export const mapApplicationCategoryResponse = (
  applicationCategory: A.ApplicationCategoryResponse,
): A.ApplicationCategory => ({
  id: applicationCategory.id,
  name: applicationCategory.name,
  createdAt: applicationCategory.created_at,
  updatedAt: applicationCategory.updated_at,
});

export const mapApplicationResponse = (
  a: A.ApplicationResponse,
): A.Application => ({
  id: a.id,
  applicationCategory: a.application_category
    ? mapApplicationCategoryResponse(a.application_category)
    : null,
  applicationCategoryId: a.application_category_id,
  currentDeploymentId: a.current_deployment_id,
  currentAppVersion: mapApplicationVersionResponse(a.current_app_version),
  isDeprecated: a.is_deprecated,
  isMarketplace: a.is_marketplace,
  resource: mapResourceResponse(a.resource),
  name: a.name,
  websiteUrl: a.website_url,
});

export const mapApplicationV2Response = (
  a: A.ApplicationV2Response,
): A.ApplicationV2 => ({
  id: a.id,
  name: a.name,
  description: a.description,
  isDeprecated: a.is_deprecated,
  isPubliclyAvailable: a.is_publicly_available,
  resourceId: a.resource_id,
  r: {
    resource: mapResourceV2Response(a.r.resource),
  },
});

export const mapPurchasedSubscriptionDetailsResponse = (
  ps: A.PurchasedSubscriptionDetailsResponse,
): A.PurchasedSubscriptionDetails => ({
  quantity: ps.quantity,
  term: ps.term,
  billingTerm: ps.billing_term,
  startDate: ps.start_date,
  transactionId: ps.transaction_id,
});

const mapGetProductListResponse = ({
  response,
  ...otherValues
}: A.GetProductListResponse): A.GetProductList => ({
  response: response?.map(({ grant_scope, product_list }) => ({
    grantScope: grant_scope,
    productList: product_list?.map<A.ProductListDetails>(
      ({
        term,
        reach_out_to_sales,
        purchased_subscription_details,
        purchased_asset_details,
        product_subscription_type,
        product_name,
        product_line,
        product_id,
        product_family,
        product_default_quantity,
        product_code,
        product_app_plan,
        net_price,
        marketplace_quantity_editable,
        manual_enablement_required,
        is_quantity_required,
        client_facing_pricing,
        client_facing_plan_description,
        business_use_case,
      }) => ({
        term: term,
        reachOutToSales: reach_out_to_sales,
        purchasedSubscriptionDetails: purchased_subscription_details?.map(
          (subscription) =>
            mapPurchasedSubscriptionDetailsResponse(subscription),
        ),
        purchasedAssetDetails: purchased_asset_details?.map((asset) =>
          mapPurchasedSubscriptionDetailsResponse(asset),
        ),
        productSubscriptionType: product_subscription_type,
        productName: product_name,
        productLine: product_line,
        productId: product_id,
        productFamily: product_family,
        productDefaultQuantity: product_default_quantity,
        productCode: product_code,
        productAppPlan: product_app_plan,
        netPrice: net_price,
        marketplaceQuantityEditable: marketplace_quantity_editable,
        manualEnablementRequired: manual_enablement_required,
        isQuantityRequired: is_quantity_required,
        clientFacingPricing: client_facing_pricing,
        clientFacingPlanDescription: client_facing_plan_description,
        businessUseCase: business_use_case,
      }),
    ),
  })),
  ...otherValues,
});

const mapPurchaseProductResponse = ({
  response,
  ...otherValues
}: A.PurchaseProductResponse): A.PurchaseProduct => ({
  response: {
    quoteId: response?.quote_id,
    oppId: response?.opp_id,
    message: response?.message,
  },
  ...otherValues,
});

export default class ApplicationClient {
  async getApplications(this: ApiClient): Promise<A.Application[]> {
    const data = await this.requestProtected<
      A.GetApplicationsRequest,
      A.GetApplicationsResponse
    >({
      method: 'GET',
      url: urls.applications(),
    });

    return data.map((a) => ({
      id: a.id,
      applicationCategory: a.application_category
        ? mapApplicationCategoryResponse(a.application_category)
        : null,
      applicationCategoryId: a.application_category_id,
      currentDeploymentId: a.current_deployment_id,
      currentAppVersion: mapApplicationVersionResponse(a.current_app_version),
      isDeprecated: a.is_deprecated,
      isMarketplace: a.is_marketplace,
      resource: mapResourceResponse(a.resource),
      name: a.name,
      websiteUrl: a.website_url,
    }));
  }

  async getApplicationVersions(
    this: ApiClient,
    applicationId: string,
  ): Promise<A.ApplicationVersion[]> {
    const data = await this.requestProtected<
      A.GetApplicationVersionsRequest,
      A.GetApplicationVersionsResponse
    >({
      method: 'GET',
      url: urls.applicationVersions(applicationId),
    });

    return data.map(mapApplicationVersionResponse);
  }

  async createApplication(
    this: ApiClient,
    params: Partial<A.Application>,
  ): Promise<A.Application> {
    const data = await this.requestProtected<
      A.CreateApplicationRequest,
      A.CreateApplicationResponse
    >({
      method: 'POST',
      url: urls.applications(),
      body: {
        name: params.name,
      },
    });

    return mapApplicationResponse(data);
  }

  async updateApplication(
    this: ApiClient,
    id: string,
    params: A.UpdateApplication,
  ): Promise<A.Application> {
    const data = await this.requestProtected<
      A.UpdateApplicationRequest,
      A.UpdateApplicationResponse
    >({
      method: 'PATCH',
      url: urls.application(id),
      body: {
        current_deployment_id: params.currentDeploymentId,
      },
    });
    return mapApplicationResponse(data);
  }

  async createApplicationVersion(
    this: ApiClient,
    applicationId: string,
    params: A.CreateApplicationVersion,
  ): Promise<A.ApplicationVersion> {
    const response = await this.requestProtected<
      A.CreateApplicationVersionRequest,
      A.CreateApplicationVersionResponse
    >({
      method: 'POST',
      url: urls.applicationVersions(applicationId),

      body: {
        name: params.name,
        major_version: params.majorVersion,
        minor_version: params.minorVersion,
        patch_version: params.patchVersion,
        description: params.description,
        icon_url: params.iconUrl,
        thumbnail_url: params.thumbnailUrl,
        embedded_url_format: params.embeddedUrlFormat,
        presentation_properties: params.presentationProperties,
        preview_orientation: params.previewOrientation,
        preview_resolution: params.previewResolution,
        strings: params.strings,
        configurable_duration: params.configurableDuration,
        default_duration: params.defaultDuration,
        has_dynamic_thumbnails: params.hasDynamicThumbnails,
        helper_link_text: params.helperLinkText,
        helper_link_url: params.helperLinkUrl,
        scopes: params.scopes,
      },
    });

    return mapApplicationVersionResponse(response);
  }

  async getMarketPlaceApplications(this: ApiClient): Promise<A.Application[]> {
    const response = await this.requestProtected<
      A.GetApplicationsRequest,
      A.GetApplicationsResponse
    >({
      method: 'GET',
      url: urls.marketPlaceApplications(),
    });

    return response.map(mapApplicationResponse);
  }

  async sendMarketPlaceInquiry(
    this: ApiClient,
    params: A.SendMarketPlaceInquiryRequest,
  ): Promise<A.SendMarketPlaceInquiryRequest> {
    const data = await this.requestProtected<
      A.SendMarketPlaceInquiryRequest,
      A.SendMarketPlaceInquiryResponse
    >({
      method: 'POST',
      url: urls.sendMarketPlaceInquiry(),
      body: params,
    });

    return data;
  }

  async getProductList(
    this: ApiClient,
    params: A.GetProductListRequest,
  ): Promise<A.GetProductList> {
    const response = await this.requestProtected<
      A.GetProductListRequest,
      A.GetProductListResponse
    >({
      method: 'GET',
      url: urls.getProductList(params.grant_scope),
    });

    return mapGetProductListResponse(response);
  }

  async getEXLicenses(this: ApiClient): Promise<A.GetEXLicenses> {
    const response = await this.requestProtected<
      A.GetEXLicensesRequest,
      A.GetExLicensesResponse
    >({
      method: 'GET',
      url: urls.getEXLicenses(),
    });

    return mapGetProductListResponse(response);
  }

  async purchaseProduct(
    this: ApiClient,
    data: A.PurchaseProductRequest,
  ): Promise<A.PurchaseProduct> {
    const response = await this.requestProtected<
      A.PurchaseProductRequest,
      A.PurchaseProductResponse
    >({
      method: 'POST',
      url: urls.purchaseProduct(),
      body: data,
    });

    return mapPurchaseProductResponse(response);
  }

  async generateApplicationVersionToken(
    this: ApiClient,
    applicationVersionId: string,
  ): Promise<string> {
    const response = await this.requestProtected<void, { token: string }>({
      method: 'POST',
      url: urls.applicationVersionToken(applicationVersionId),
    });

    return response.token;
  }
}