import { invoke } from "@tauri-apps/api/core";
import { listen, type UnlistenFn } from "@tauri-apps/api/event";

export type PaneId = number;

/** What to spawn into a fresh PTY. Mirrors the Rust `SpawnSpec` enum. */
export type SpawnSpec =
  | { kind: "wsl"; distro?: string; cwd?: string }
  | { kind: "powershell" }
  | {
      kind: "ssh";
      host: string;
      user?: string;
      port?: number;
      identityFile?: string;
      jumpHost?: string;
      extraArgs?: string[];
      /** Backend uses this to look up a saved password from keyring at
       *  spawn time. Never echoed back to the frontend. */
      hostId?: string;
    };

/** One saved SSH host. Mirrors the Rust `SshHost` struct (plus the
 *  `hasPassword` flag that the backend sets when listing). */
export interface SshHost {
  id: string;
  label: string;
  hostname: string;
  user?: string;
  port?: number;
  identityFile?: string;
  jumpHost?: string;
  extraArgs?: string[];
  /** True iff a credential is stored under this host's id in the system
   *  keyring. Set by the backend on `list_ssh_hosts`; the field is
   *  ignored on `save_ssh_hosts` (use the password commands below). */
  hasPassword?: boolean;
}

export const listDistros = (): Promise<string[]> => invoke("list_distros");

export const spawnPane = (args: {
  spec: SpawnSpec;
  cols: number;
  rows: number;
}): Promise<PaneId> => invoke("spawn_pane", args);

export const writeToPane = (id: PaneId, dataB64: string): Promise<void> =>
  invoke("write_to_pane", { id, dataB64 });

export const resizePane = (id: PaneId, cols: number, rows: number): Promise<void> =>
  invoke("resize_pane", { id, cols, rows });

export const killPane = (id: PaneId): Promise<void> => invoke("kill_pane", { id });

export const onPaneData = (
  id: PaneId,
  cb: (b64: string) => void,
): Promise<UnlistenFn> =>
  listen<{ b64: string }>(`pane://${id}/data`, (e) => cb(e.payload.b64));

export const onPaneExit = (
  id: PaneId,
  cb: () => void,
): Promise<UnlistenFn> => listen(`pane://${id}/exit`, () => cb());

// ---- workspace persistence -------------------------------------------------

export const saveWorkspace = (json: string): Promise<void> =>
  invoke("save_workspace", { json });

export const loadWorkspace = (): Promise<string | null> =>
  invoke("load_workspace");

// ---- SSH hosts -------------------------------------------------------------

export const listSshHosts = (): Promise<SshHost[]> => invoke("list_ssh_hosts");

export const saveSshHosts = (hosts: SshHost[]): Promise<void> =>
  invoke("save_ssh_hosts", { hosts });

/** Store / replace the saved password for this host id. Plaintext is
 *  IPC'd to the Rust side (in-process, no disk hop) and immediately
 *  written to Windows Credential Manager (DPAPI). */
export const setHostPassword = (hostId: string, password: string): Promise<void> =>
  invoke("set_host_password", { hostId, password });

export const deleteHostPassword = (hostId: string): Promise<void> =>
  invoke("delete_host_password", { hostId });

export const hasHostPassword = (hostId: string): Promise<boolean> =>
  invoke("has_host_password", { hostId });