import type { CloudlyApiClient } from './classes.cloudlyapiclient.js';
import * as plugins from './plugins.js';

export class Backup {
  private static requireIdentity(
    cloudlyClientRef: CloudlyApiClient,
  ): plugins.servezoneInterfaces.data.IIdentityCredential {
    if (!cloudlyClientRef.identity?.jwt) {
      throw new Error('identity JWT is required. Either provide an identity or login first.');
    }
    return { jwt: cloudlyClientRef.identity.jwt };
  }

  public static async createServiceBackup(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: {
      serviceId: string;
      clusterId?: string;
      tags?: Record<string, string>;
    },
  ) {
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<any>(
      'createServiceBackup',
    );
    return await request.fire({
      identity: cloudlyClientRef.requireIdentity(),
      ...optionsArg,
    });
  }

  public static async getServiceBackups(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: {
      serviceId?: string;
      status?: string;
    } = {},
  ) {
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<any>(
      'getServiceBackups',
    );
    return await request.fire({
      identity: cloudlyClientRef.requireIdentity(),
      ...optionsArg,
    });
  }

  public static async getBackupById(cloudlyClientRef: CloudlyApiClient, backupIdArg: string) {
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<any>('getBackupById');
    return await request.fire({
      identity: cloudlyClientRef.requireIdentity(),
      backupId: backupIdArg,
    });
  }

  public static async restoreServiceBackup(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: {
      backupId: string;
      clear?: boolean;
      resourceTypes?: Array<'volume' | 'database' | 'objectstorage'>;
    },
  ) {
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<any>(
      'restoreServiceBackup',
    );
    return await request.fire({
      identity: cloudlyClientRef.requireIdentity(),
      ...optionsArg,
    });
  }

  /**
   * Creates a restore in a server-generated scratch namespace. The explicit
   * payload construction deliberately drops undeclared runtime properties so
   * callers cannot smuggle target service or archive identifiers to Cloudly.
   */
  public static async createIsolatedRestore(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: Omit<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CreateIsolatedRestore['request'],
      'identity'
    >,
  ): Promise<
    plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CreateIsolatedRestore['response']
  > {
    const identity = Backup.requireIdentity(cloudlyClientRef);
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CreateIsolatedRestore
    >('createIsolatedRestore');
    return await request.fire({
      identity,
      sourceBackupId: optionsArg.sourceBackupId,
      targetNodeId: optionsArg.targetNodeId,
      purpose: optionsArg.purpose,
      idempotencyKey: optionsArg.idempotencyKey,
      ...(optionsArg.ttlMs === undefined ? {} : { ttlMs: optionsArg.ttlMs }),
    });
  }

  public static async getIsolatedRestores(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: Omit<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_GetIsolatedRestores['request'],
      'identity'
    > = {},
  ): Promise<
    plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_GetIsolatedRestores['response']
  > {
    const identity = Backup.requireIdentity(cloudlyClientRef);
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_GetIsolatedRestores
    >('getIsolatedRestores');
    return await request.fire({
      identity,
      ...(optionsArg.sourceBackupId === undefined
        ? {}
        : { sourceBackupId: optionsArg.sourceBackupId }),
      ...(optionsArg.sourceServiceId === undefined
        ? {}
        : { sourceServiceId: optionsArg.sourceServiceId }),
      ...(optionsArg.clusterId === undefined ? {} : { clusterId: optionsArg.clusterId }),
      ...(optionsArg.targetNodeId === undefined ? {} : { targetNodeId: optionsArg.targetNodeId }),
      ...(optionsArg.targetNodeName === undefined
        ? {}
        : { targetNodeName: optionsArg.targetNodeName }),
      ...(optionsArg.scratchNamespaceId === undefined
        ? {}
        : { scratchNamespaceId: optionsArg.scratchNamespaceId }),
      ...(optionsArg.status === undefined ? {} : { status: optionsArg.status }),
      ...(optionsArg.includeCleaned === undefined
        ? {}
        : { includeCleaned: optionsArg.includeCleaned }),
      ...(optionsArg.cursor === undefined ? {} : { cursor: optionsArg.cursor }),
      ...(optionsArg.limit === undefined ? {} : { limit: optionsArg.limit }),
    });
  }

  public static async getIsolatedRestoreById(
    cloudlyClientRef: CloudlyApiClient,
    restoreIdArg: string,
  ): Promise<
    plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_GetIsolatedRestoreById['response']
  > {
    const identity = Backup.requireIdentity(cloudlyClientRef);
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_GetIsolatedRestoreById
    >('getIsolatedRestoreById');
    return await request.fire({
      identity,
      restoreId: restoreIdArg,
    });
  }

  public static async cleanupIsolatedRestore(
    cloudlyClientRef: CloudlyApiClient,
    optionsArg: Omit<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CleanupIsolatedRestore['request'],
      'identity'
    >,
  ): Promise<
    plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CleanupIsolatedRestore['response']
  > {
    const identity = Backup.requireIdentity(cloudlyClientRef);
    const request = cloudlyClientRef.requireTypedSocket().createTypedRequest<
      plugins.servezoneInterfaces.requests.backup.IReq_Any_Cloudly_CleanupIsolatedRestore
    >('cleanupIsolatedRestore');
    return await request.fire({
      identity,
      restoreId: optionsArg.restoreId,
      reason: optionsArg.reason,
    });
  }
}