/**
 * Subscription API Module
 *
 * HTTP client methods for subscription, billing, and usage operations.
 * Uses endpoint constants and Zod-inferred types from @archer/api-interface.
 *
 * @layer Infrastructure - API Client
 */

import { apiClient } from '../../ApiClient';
import {
  SUBSCRIPTION_GET,
  SUBSCRIPTION_PLANS_LIST,
  SUBSCRIPTION_CHECKOUT,
  SUBSCRIPTION_CREATE_PAYMENT_INTENT,
  SUBSCRIPTION_CONFIRM_PAYMENT,
  SUBSCRIPTION_SUBSCRIBE,
  SUBSCRIPTION_CONFIRM,
  SUBSCRIPTION_CHANGE_PLAN,
  SUBSCRIPTION_CANCEL,
  SUBSCRIPTION_RESUME,
  SUBSCRIPTION_USAGE,
  SUBSCRIPTION_INVOICES_LIST,
  SUBSCRIPTION_INVOICE_PDF,
  SUBSCRIPTION_COMMAND_STATS,
  SUBSCRIPTION_PURCHASE_COMMANDS,
  SUBSCRIPTION_CONFIGURE,
  SUBSCRIPTION_CONFIGURABLE_CAPS,
  SUBSCRIPTION_CONFIRM_COMMAND_PURCHASE,
  SUBSCRIPTION_SET_AUTO_BUY,
  SUBSCRIPTION_REDEEM_CODE,
  SUBSCRIPTION_VALIDATE_CODE,
  PAYMENT_COMPLETE,
} from '@archer/api-interface/endpoints/customer-api';
import type {
  SubscriptionResponse,
  AvailablePlanResponse,
  CheckoutResponse,
  CreatePaymentIntentResponse,
  ConfirmPaymentResponse,
  SubscribeResponse,
  ConfirmSubscriptionResponse,
  ChangePlanResponse,
  CancelSubscriptionResponse,
  ResumeSubscriptionResponse,
  UsageResponse,
  InvoiceResponse,
  CommandStatsResponse,
  PurchaseCommandsResponse,
  ConfirmCommandPurchaseResponse,
  SetAutoBuyResponse,
  RedeemCodeResponse,
  ValidateCodeResponse,
  ConfigurableCapsResponse,
} from '@archer/api-interface/schemas/customer-api/response';
import type { PaginatedResponse } from '@archer/api-interface/schemas/shared/paginated.response';

export const subscriptionApi = {
  async getSubscription(): Promise<SubscriptionResponse> {
    return apiClient.get<SubscriptionResponse>(SUBSCRIPTION_GET.path);
  },

  async listPlans(channel?: string): Promise<AvailablePlanResponse[]> {
    const params = channel ? `?channel=${channel}` : '';
    return apiClient.get<AvailablePlanResponse[]>(`${SUBSCRIPTION_PLANS_LIST.path}${params}`);
  },

  /** Reserved for single purchase flow — no backend route yet */
  async checkout(paymentProvider: string, planId?: string): Promise<CheckoutResponse> {
    return apiClient.post<CheckoutResponse>(SUBSCRIPTION_CHECKOUT.path, {
      paymentProvider,
      ...(planId && { planId }),
    });
  },

  async createPaymentIntent(planId: string): Promise<CreatePaymentIntentResponse> {
    return apiClient.post<CreatePaymentIntentResponse>(SUBSCRIPTION_CREATE_PAYMENT_INTENT.path, { planId });
  },

  async confirmPayment(paymentIntentId: string): Promise<ConfirmPaymentResponse> {
    return apiClient.post<ConfirmPaymentResponse>(SUBSCRIPTION_CONFIRM_PAYMENT.path, { paymentIntentId });
  },

  async subscribe(planId: string): Promise<SubscribeResponse> {
    return apiClient.post<SubscribeResponse>(SUBSCRIPTION_SUBSCRIBE.path, { planId });
  },

  async confirmSubscription(subscriptionId: string): Promise<ConfirmSubscriptionResponse> {
    return apiClient.post<ConfirmSubscriptionResponse>(SUBSCRIPTION_CONFIRM.path, { subscriptionId });
  },

  async changePlan(planId: string): Promise<ChangePlanResponse> {
    return apiClient.post<ChangePlanResponse>(SUBSCRIPTION_CHANGE_PLAN.path, { planId });
  },

  async cancel(): Promise<CancelSubscriptionResponse> {
    return apiClient.post<CancelSubscriptionResponse>(SUBSCRIPTION_CANCEL.path);
  },

  async resume(): Promise<ResumeSubscriptionResponse> {
    return apiClient.post<ResumeSubscriptionResponse>(SUBSCRIPTION_RESUME.path);
  },

  async getUsage(): Promise<UsageResponse> {
    return apiClient.get<UsageResponse>(SUBSCRIPTION_USAGE.path);
  },

  async getInvoices(page: number = 1, limit: number = 20): Promise<PaginatedResponse<InvoiceResponse>> {
    return apiClient.get<PaginatedResponse<InvoiceResponse>>(`${SUBSCRIPTION_INVOICES_LIST.path}?page=${page}&limit=${limit}`);
  },

  async downloadInvoicePdf(transactionId: string): Promise<Blob> {
    return apiClient.get<Blob>(
      SUBSCRIPTION_INVOICE_PDF.path.replace(':id', transactionId),
      { responseType: 'blob' },
    );
  },

  async getCommandStats(): Promise<CommandStatsResponse> {
    return apiClient.get<CommandStatsResponse>(SUBSCRIPTION_COMMAND_STATS.path);
  },

  async purchaseCommands(packageSize: 100 | 1000, quantity = 1): Promise<PurchaseCommandsResponse> {
    return apiClient.post<PurchaseCommandsResponse>(SUBSCRIPTION_PURCHASE_COMMANDS.path, { packageSize, quantity });
  },

  async confirmCommandPurchase(paymentIntentId: string): Promise<ConfirmCommandPurchaseResponse> {
    return apiClient.post<ConfirmCommandPurchaseResponse>(SUBSCRIPTION_CONFIRM_COMMAND_PURCHASE.path, { paymentIntentId });
  },

  async setAutoBuy(enabled: boolean): Promise<SetAutoBuyResponse> {
    return apiClient.post<SetAutoBuyResponse>(SUBSCRIPTION_SET_AUTO_BUY.path, { enabled });
  },

  async completePayment(transactionId: string): Promise<{ clientSecret: string; paymentIntentId: string; transactionId: string; amount: number; currency: string }> {
    return apiClient.post(PAYMENT_COMPLETE.path.replace(':transactionId', transactionId), {});
  },

  async redeemCode(code: string, paymentOnly?: boolean): Promise<RedeemCodeResponse> {
    const res = await apiClient.post<{ data: RedeemCodeResponse }>(SUBSCRIPTION_REDEEM_CODE.path, { code, paymentOnly });
    return res.data;
  },

  async validateCode(code: string, planId: string): Promise<ValidateCodeResponse> {
    return apiClient.post<ValidateCodeResponse>(SUBSCRIPTION_VALIDATE_CODE.path, { code, planId });
  },

  async getConfigurableCaps(): Promise<ConfigurableCapsResponse> {
    return apiClient.get<ConfigurableCapsResponse>(SUBSCRIPTION_CONFIGURABLE_CAPS.path);
  },

  async configure(items: Array<{ capabilityKey: string; quantity: number }>): Promise<ConfigurableCapsResponse> {
    return apiClient.post<ConfigurableCapsResponse>(SUBSCRIPTION_CONFIGURE.path, { items });
  },
};