/**
 * Database subcommands for CLI — all go through SDK.
 *
 * @module
 */

import {
  runAction,
  runList,
  runGet,
  chalk,
  formatStatus,
  getCliSdk,
} from "../actions.js";
import type {
  ICoolifyDatabase,
  ICoolifyDatabaseBackup,
} from "../../coolify/types.js";
import { resolveDbNameOrUuid } from "../name-resolver.js";

/** List all databases. */
export const dbListCommand = () =>
  runList<ICoolifyDatabase>("database(s)", (s) => s.databases.list(), [
    { header: "UUID", value: (d) => d.uuid },
    { header: "Name", value: (d) => d.name || "-" },
    { header: "Type", value: (d) => d.type || "-" },
    { header: "Status", value: (d) => formatStatus(d.status) },
  ]);

/** Get database details. */
export const dbGetCommand = (uuid: string) =>
  runGet<ICoolifyDatabase>(
    uuid,
    "database",
    (s, u) => s.databases.get(u),
    (db) => {
      console.log(chalk.cyan("Database Details:"));
      console.log(chalk.gray("UUID:    ") + db.uuid);
      console.log(chalk.gray("Name:    ") + db.name);
      console.log(chalk.gray("Type:    ") + (db.type || "-"));
      console.log(chalk.gray("Status:  ") + formatStatus(db.status));
      console.log(chalk.gray("Version: ") + (db.version || "-"));
    },
  );

/** Create a database. */
export async function dbCreateCommand(
  type: string,
  options: {
    server: string;
    project: string;
    environment?: string;
    name?: string;
  },
): Promise<void> {
  try {
    const data: Record<string, unknown> = {
      server_uuid: options.server,
      project_uuid: options.project,
    };
    if (options.environment) data.environment_name = options.environment;
    if (options.name) data.name = options.name;

    console.log(chalk.cyan(`Creating ${type} database...`));
    const result = await getCliSdk().databases.create(type, data);
    console.log(
      chalk.green(`Database created! UUID: ${chalk.cyan(result.uuid)}`),
    );
  } catch (error) {
    console.error(
      chalk.red(
        `Error: ${error instanceof Error ? error.message : String(error)}`,
      ),
    );
  }
}

/** Start a database. */
export const dbStartCommand = (uuid: string) =>
  runAction(
    uuid,
    "Starting database",
    (s, u) => s.databases.start(u),
    (u) => `Database started: ${u}`,
  );

/** Stop a database. */
export const dbStopCommand = (uuid: string) =>
  runAction(
    uuid,
    "Stopping database",
    (s, u) => s.databases.stop(u),
    (u) => `Database stopped: ${u}`,
  );

/** Restart a database. */
export const dbRestartCommand = (uuid: string) =>
  runAction(
    uuid,
    "Restarting database",
    (s, u) => s.databases.restart(u),
    (u) => `Database restarted: ${u}`,
  );

/** Delete a database. */
export const dbDeleteCommand = (uuid: string) =>
  runAction(
    uuid,
    "Deleting database",
    (s, u) => s.databases.delete(u),
    (u) => `Database deleted: ${u}`,
  );

/**
 * Update a database configuration.
 *
 * @param uuid - Database UUID
 * @param options - Update options (publicPort, isPublic)
 */
export async function dbUpdateCommand(
  uuidOrName: string,
  options: { publicPort?: string; isPublic?: boolean },
): Promise<void> {
  try {
    const uuid = await resolveDbNameOrUuid(uuidOrName) ?? uuidOrName;
    const data: Record<string, unknown> = {};

    if (options.publicPort !== undefined) data.public_port = options.publicPort;
    if (options.isPublic !== undefined) data.is_public = options.isPublic;

    if (Object.keys(data).length === 0) {
      console.warn(
        chalk.yellow("No update options provided. Use --help to see available options."),
      );
      return;
    }

    console.log(chalk.cyan(`Updating database ${chalk.bold(uuid)}...`));
    await getCliSdk().databases.update(uuid, data);
    console.log(chalk.green("Database updated successfully"));
  } catch (error) {
    console.error(
      chalk.red(
        `Error: ${error instanceof Error ? error.message : String(error)}`,
      ),
    );
  }
}

/** List backups for a database. */
export const dbBackupsCommand = (uuid: string) =>
  runList<ICoolifyDatabaseBackup>(
    "backup(s)",
    (s) => s.databases.backups(uuid),
    [
      { header: "UUID", value: (b) => b.uuid },
      { header: "Status", value: (b) => formatStatus(b.status) },
      {
        header: "Created",
        value: (b) => new Date(b.created_at).toLocaleString(),
      },
      {
        header: "Size",
        value: (b) => (b.size ? `${(b.size / 1024 / 1024).toFixed(1)}MB` : "-"),
      },
    ],
  );