import { Client } from "..";
import Backups from "./Backups";
import Maintenances from "./Maintenances";
import { BackupRestoration } from "../models/regional/backups";
import {
  Database,
  DashboardDatabase,
  ApiDatabase,
  CreateParams,
  DatabaseUpdateParams,
  DatabasePlan,
  DatabaseMetrics,
  DatabaseInstanceStatus,
  DatabasePitrRestoreResponse,
  LogsArchivesResult,
  DatabaseType,
  DatabaseTypeVersion,
  FirewallRule,
  FirewallManagedRange,
  FirewallRuleCreateParams,
  FirewallRuleUpdateParams,
  DbOperation,
  DatabaseUser,
  DatabaseUserCreateParams,
  DatabaseFeature,
} from "../models/regional/databases";
import { OrganizationScopedParams } from "../params/regional/organization";
import { unpackData } from "../utils";

/**
 * Databases API Client
 */
export default class Databases {
  /** Scalingo API Client */
  _client: Client;

  constructor(client: Client) {
    this._client = client;
  }

  /**
   * Get all databases for the current user
   * @param opts Optional query parameters
   * @param opts.dashboard Whether to return dashboard database information
   * @param opts.organization_id ID of the organization to scope the results to
   * @return Promise that when resolved returns a Database array.
   */

  all(
    opts?: { dashboard?: boolean } & OrganizationScopedParams,
  ): Promise<Database[] | DashboardDatabase[]> {
    return unpackData(
      this._client.apiClient().get("/databases", { params: opts }),
      "databases",
    );
  }

  /**
   * Get details for a specific database
   * @param id ID of the database
   * @return Promise that when resolved returns the requested database.
   */
  show(id: string): Promise<DashboardDatabase> {
    return unpackData(this._client.apiClient().get(`/databases/${id}`));
  }

  /**
   * Get detailed information for a specific database from the dbaas API
   * @param addonId ID of the database addon (e.g., 'ad-xxxx-xxxx-xxxx')
   * @return Promise that when resolved returns detailed database information.
   */
  apiShow(addonId: string): Promise<ApiDatabase> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}`),
      "database",
    );
  }

  /**
   * Update a database configuration via the dbaas API
   * @param addonId ID of the database addon (e.g., 'ad-xxxx-xxxx-xxxx')
   * @param params Database update parameters
   * @return Promise that when resolved returns the updated database.
   */
  apiUpdate(
    addonId: string,
    params: DatabaseUpdateParams,
  ): Promise<ApiDatabase> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .patch(`/databases/${addonId}`, { database: params }),
      "database",
    );
  }

  /**
   * Get the plan information for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns the database plan.
   */
  apiPlan(addonId: string): Promise<DatabasePlan> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/plan`),
      "plan",
    );
  }

  /**
   * Get plan details by plan name from the dbaas API
   * @param planId Plan name (e.g., redis-starter-512)
   * @param type Database type name (e.g., redis)
   * @return Promise that when resolved returns the plan.
   */
  apiShowPlan(planId: string, type: string): Promise<DatabasePlan> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/plans/${planId}`, { params: { type } }),
      "plan",
    );
  }

  /**
   * Get current metrics for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns database metrics.
   */
  apiMetrics(addonId: string): Promise<DatabaseMetrics> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/metrics`),
    );
  }

  /**
   * Get time-series metrics for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @param type Metric type (e.g., 'cpu', 'memory', 'swap', 'disk', 'diskio')
   * @param opts Optional parameters
   * @param opts.since Number of hours to look back (default: 3)
   * @param opts.last Whether to return only the last value
   * @return Promise that when resolved returns the metric data points.
   */
  apiMetricsType(
    addonId: string,
    type: string,
    opts?: { since?: number; last?: boolean },
  ): Promise<unknown> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/metrics/${type}`, { params: opts }),
    );
  }

  /**
   * Get time-series metrics for a specific database instance from the dbaas API
   * @param addonId ID of the database addon
   * @param instanceId ID of the database instance
   * @param type Metric type (e.g., 'cpu', 'memory', 'swap', 'disk', 'diskio')
   * @param opts Optional parameters
   * @param opts.since Number of hours to look back (default: 3)
   * @param opts.last Whether to return only the last value
   * @return Promise that when resolved returns the metric data points.
   */
  apiInstanceMetrics(
    addonId: string,
    instanceId: string,
    type: string,
    opts?: { since?: number; last?: boolean },
  ): Promise<unknown> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/instances/${instanceId}/metrics/${type}`, {
          params: opts,
        }),
    );
  }

  /**
   * Get health status for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns database health information.
   */
  apiHealth(addonId: string): Promise<Record<string, unknown>> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/health`),
    );
  }

  /**
   * Get instances status for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns instances status.
   */
  apiInstancesStatus(addonId: string): Promise<DatabaseInstanceStatus[]> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/instances_status`),
    );
  }

  /**
   * Get replication lag for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns lag information.
   */
  apiLag(addonId: string): Promise<Record<string, unknown>> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/lag`),
    );
  }

  /**
   * Get a specific backup restoration for a database from the dbaas API
   * @param addonId ID of the database addon
   * @param restorationId ID of the backup restoration
   * @return Promise that when resolved returns the backup restoration.
   */
  apiBackupRestorationShow(
    addonId: string,
    restorationId: string,
  ): Promise<BackupRestoration> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/backup_restorations/${restorationId}`),
      "backup_restoration",
    );
  }

  /**
   * Get a signed URL for accessing database logs from the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns an object with the signed URL.
   */
  apiLogs(addonId: string): Promise<string> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/logs`),
      "url",
    );
  }

  /**
   * Get logs archives for a specific database from the dbaas API
   * @param addonId ID of the database addon
   * @param opts Optional parameters
   * @param opts.cursor Pagination cursor
   * @return Promise that when resolved returns logs archives.
   */
  apiLogsArchives(
    addonId: string,
    opts?: { cursor?: number | string },
  ): Promise<LogsArchivesResult> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/logs_archives`, { params: opts }),
    );
  }

  /**
   * Get all database types from the dbaas API
   * @return Promise that when resolved returns an array of database types.
   */
  listDatabaseTypes(): Promise<DatabaseType[]> {
    return unpackData(
      this._client.dbaasApiClient().get("/database_types"),
      "database_types",
    );
  }

  /**
   * Get information for a specific database type from the dbaas API
   * @param id ID of the database type
   * @return Promise that when resolved returns database type information.
   */
  showDatabaseType(id: string): Promise<DatabaseType> {
    return unpackData(
      this._client.dbaasApiClient().get(`/database_types/${id}`),
      "database_type",
    );
  }

  /**
   * Get information for a specific database type version from the dbaas API
   * @param id ID of the database type version
   * @return Promise that when resolved returns database type version information.
   */
  showDatabaseTypeVersion(id: string): Promise<DatabaseTypeVersion> {
    return unpackData(
      this._client.dbaasApiClient().get(`/database_type_versions/${id}`),
      "database_type_version",
    );
  }

  /**
   * Ping a database via the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that resolves when the ping succeeds.
   */
  apiPing(addonId: string): Promise<Record<string, unknown>> {
    return unpackData(
      this._client.dbaasApiClient().post(`/databases/${addonId}/ping`, {}),
    );
  }

  /**
   * Upgrade a database to the next version via the dbaas API
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns upgrade information including operation_id.
   */
  apiUpgrade(addonId: string): Promise<Record<string, unknown>> {
    return unpackData(
      this._client.dbaasApiClient().post(`/databases/${addonId}/upgrade`, {}),
    );
  }

  /**
   * Get the status of a database operation via the dbaas API
   * @param addonId ID of the database addon (e.g., 'ad-xxxx-xxxx-xxxx')
   * @param operationId ID of the operation
   * @return Promise that when resolved returns the operation details.
   */
  apiOperationShow(addonId: string, operationId: string): Promise<DbOperation> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .get(`/databases/${addonId}/operations/${operationId}`),
      "operation",
    );
  }

  /**
   * Restore a database to a point in time via the dbaas API
   * @param addonId ID of the database addon
   * @param restoreTime Point-in-time restore target
   * @return Promise that when resolved returns the restore operation payload.
   */
  apiPitrRestore(
    addonId: string,
    restoreTime: string,
  ): Promise<DatabasePitrRestoreResponse> {
    return unpackData(
      this._client.dbaasApiClient().post(`/databases/${addonId}/pitr/restore`, {
        restore_time: restoreTime,
      }),
    );
  }

  /**
   * Run a database action via the dbaas API
   * @param addonId ID of the database addon
   * @param actionName Name of the action to perform
   * @param actionParams Optional parameters for the action (can be an object, string, or other JSON value)
   * @return Promise that when resolved returns the action result.
   */
  apiAction(
    addonId: string,
    actionName: string,
    actionParams?: unknown,
  ): Promise<Record<string, unknown>> {
    return unpackData(
      this._client.dbaasApiClient().post(`/databases/${addonId}/action`, {
        action_name: actionName,
        params: actionParams ?? {},
      }),
    );
  }

  apiFirewallRules(addonId: string): Promise<FirewallRule[]> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/firewall_rules`),
      "rules",
    );
  }

  apiCreateFirewallRule(
    addonId: string,
    params: FirewallRuleCreateParams,
  ): Promise<FirewallRule> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .post(`/databases/${addonId}/firewall_rules`, {
          firewall_rule: params,
        }),
      "rule",
    );
  }

  apiDeleteFirewallRule(addonId: string, ruleId: string): Promise<void> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .delete(`/databases/${addonId}/firewall_rules/${ruleId}`),
    );
  }

  apiUpdateFirewallRule(
    addonId: string,
    ruleId: string,
    params: FirewallRuleUpdateParams,
  ): Promise<FirewallRule> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .patch(`/databases/${addonId}/firewall_rules/${ruleId}`, {
          firewall_rule: params,
        }),
      "rule",
    );
  }

  apiManagedFirewallRanges(): Promise<FirewallManagedRange[]> {
    return unpackData(
      this._client.dbaasApiClient().get("/firewall/managed_ranges"),
      "ranges",
    );
  }

  /**
   * Create a new database
   * @param technology ID or slug of the technology (addon provider)
   * @param plan ID or name of the plan
   * @param name Name of the database
   * @return Promise that when resolved returns the new database.
   */

  create(
    createParams: CreateParams,
  ): Promise<Database[] | DashboardDatabase[]> {
    return unpackData(
      this._client.apiClient().post("/databases", { database: createParams }),
      "apps",
    );
  }

  /**
   * Get the maintenances client for a database
   * @param databaseId ID of the database addon (e.g., 'ad-xxxx-xxxx-xxxx')
   * @return Maintenances client for the database
   */
  maintenances(databaseId: string): Maintenances {
    return new Maintenances(this._client, databaseId);
  }

  /**
   * Get the backups client for a database
   * @param databaseId ID of the database addon (e.g., 'ad-xxxx-xxxx-xxxx')
   * @return Backups client for the database
   */
  backups(databaseId: string): Backups {
    return new Backups(this._client, databaseId);
  }

  /**
   * List all users of a database
   * @param addonId ID of the database addon
   * @return Promise that when resolved returns the list of database users.
   */
  apiDatabaseUsers(addonId: string): Promise<DatabaseUser[]> {
    return unpackData(
      this._client.dbaasApiClient().get(`/databases/${addonId}/users`),
      "database-users",
    );
  }

  /**
   * Create a new database user
   * @param addonId ID of the database addon
   * @param params User creation parameters
   * @return Promise that when resolved returns the created user.
   */
  apiDatabaseUserCreate(
    addonId: string,
    params: DatabaseUserCreateParams,
  ): Promise<DatabaseUser> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .post(`/databases/${addonId}/users`, { database_user: params }),
      "database_user",
    );
  }

  /**
   * Delete a database user
   * @param addonId ID of the database addon
   * @param username Name of the user to delete
   * @return Promise that resolves when the user is deleted.
   */
  apiDatabaseUserDelete(addonId: string, username: string): Promise<void> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .delete(`/databases/${addonId}/users/${username}`),
    );
  }

  /**
   * Reset the password of a database user
   * @param addonId ID of the database addon
   * @param username Name of the user
   * @return Promise that when resolved returns the user with new password.
   */
  apiDatabaseUserResetPassword(
    addonId: string,
    username: string,
  ): Promise<DatabaseUser> {
    return unpackData(
      this._client
        .dbaasApiClient()
        .post(`/databases/${addonId}/users/${username}/reset_password`),
      "database_user",
    );
  }

  /**
   * Enable a feature on a database
   * @param addonId ID of the database addon
   * @param featureName Name of the feature to enable (e.g., 'force-ssl')
   * @return Promise that when resolved returns the enabled feature.
   */
  apiDatabaseFeatureEnable(
    addonId: string,
    featureName: string,
  ): Promise<DatabaseFeature> {
    return unpackData(
      this._client.dbaasApiClient().post(`/databases/${addonId}/features`, {
        feature: { name: featureName },
      }),
    );
  }

  /**
   * Disable a feature on a database
   * @param addonId ID of the database addon
   * @param featureName Name of the feature to disable (e.g., 'force-ssl')
   * @return Promise that when resolved returns a message.
   */
  apiDatabaseFeatureDisable(
    addonId: string,
    featureName: string,
  ): Promise<{ message: string }> {
    return unpackData(
      this._client.dbaasApiClient().delete(`/databases/${addonId}/features`, {
        params: { feature: featureName },
      }),
    );
  }

  /**
   * Get the URL for downloading the CA Certificate
   * @returns string: the URL to download the CA Certificate from
   */
  caCertificateDownloadURL(): string {
    return this._client.dbaasApiClient().getUri({ url: "/ca_certificate" });
  }
}