/**
 * IPFS pinning, direct uploads, IPNS names and customer gateway domains
 * (which can serve your pins directly at /ipfs/<cid>). Prepaid hourly
 * billing per pinned MiB plus gateway egress; deletes are always free. The
 * standard IPFS Pinning Service API lives in `pins`.
 *
 * For uploading local content use `addFile`, which drives the whole
 * grant → upload → pin flow.
 */
import type { Client } from './client.js';
import { uploadFailed } from './errors.js';
import { checkGate } from './gate.js';
import * as http from './http.js';
import type { Body, Query, Res } from './types.js';

/** GET /ipfs/pins — List your pins (offset-paginated). */
export const listPins = (client: Client, query?: Query<'/ipfs/pins', 'get'>) =>
  http.get(client, '/ipfs/pins', { query });

/** Every pin, following offset pagination (page `limit` defaults to 100). */
export const listAllPins = (client: Client, query?: Query<'/ipfs/pins', 'get'>) =>
  http.paginateOffset(client, '/ipfs/pins', 'pins', { query });

/** POST /ipfs/pins — Pin by CID (202; billing starts once pinned). */
export const pin = (client: Client, body: Body<'/ipfs/pins', 'post'>) => http.post(client, '/ipfs/pins', { body });

/** GET /ipfs/pins/{id} — Pin detail. */
export const getPin = (client: Client, id: string) => http.get(client, '/ipfs/pins/{id}', { params: { id } });

/** DELETE /ipfs/pins/{id} — Unpin (202; free). */
export const unpin = (client: Client, id: string) => http.del(client, '/ipfs/pins/{id}', { params: { id } });

/**
 * POST /ipfs/uploads — Start a direct upload. Issues a short-lived
 * single-use grant `{ upload: { url, token, ... } }`; POST the raw bytes to
 * that URL (see `http.uploadBytes`) then poll `getUpload`.
 */
export const startUpload = (client: Client, body?: Body<'/ipfs/uploads', 'post'>) =>
  http.post(client, '/ipfs/uploads', { body });

/** GET /ipfs/uploads/{id} — Upload status (issued/completed/failed/expired). */
export const getUpload = (client: Client, id: string) =>
  http.get(client, '/ipfs/uploads/{id}', { params: { id } });

/** GET /ipfs/names — List your IPNS names. */
export const listNames = (client: Client) => http.get(client, '/ipfs/names');

/** POST /ipfs/names — Create an IPNS name. */
export const createName = (client: Client, body?: Body<'/ipfs/names', 'post'>) =>
  http.post(client, '/ipfs/names', { body });

/** GET /ipfs/names/{id} — IPNS name detail. */
export const getName = (client: Client, id: string) => http.get(client, '/ipfs/names/{id}', { params: { id } });

/** DELETE /ipfs/names/{id} — Delete an IPNS name (202). */
export const deleteName = (client: Client, id: string) => http.del(client, '/ipfs/names/{id}', { params: { id } });

/** PUT /ipfs/names/{id}/target — Publish a new target for an IPNS name. */
export const publishTarget = (client: Client, id: string, body: Body<'/ipfs/names/{id}/target', 'put'>) =>
  http.put(client, '/ipfs/names/{id}/target', { params: { id }, body });

/** GET /ipfs/domains — List your gateway domains. */
export const listDomains = (client: Client) => http.get(client, '/ipfs/domains');

/**
 * POST /ipfs/domains — Attach your own domain as an IPFS gateway. Gated on
 * `domain`. The response's `dns_target` is the gateway IPv4 the domain's A
 * record must point at on manually mapped rows.
 */
export const attachDomain = async (client: Client, body: Body<'/ipfs/domains', 'post'>) => {
  await checkGate(client, 'POST /ipfs/domains', { domain: body.domain });
  return http.post(client, '/ipfs/domains', { body });
};

/** GET /ipfs/domains/{id} — Gateway domain detail. */
export const getDomain = (client: Client, id: string) => http.get(client, '/ipfs/domains/{id}', { params: { id } });

/** GET /ipfs/domains/{id}/pins — The pins a gateway domain serves, oldest attachment first. */
export const listDomainPins = (client: Client, id: string, query?: Query<'/ipfs/domains/{id}/pins', 'get'>) =>
  http.get(client, '/ipfs/domains/{id}/pins', { params: { id }, query });

/** Every pin a gateway domain serves, following offset pagination. */
export const listAllDomainPins = (client: Client, id: string, query?: Query<'/ipfs/domains/{id}/pins', 'get'>) =>
  http.paginateOffset(client, '/ipfs/domains/{id}/pins', 'pins', { params: { id }, query });

/** Resolve the gateway's domain name (only when gated) and run the gate. */
const checkGatewayGate = async (client: Client, op: string, id: string): Promise<void> => {
  if (!client.gate) return;
  const { domain } = await getDomain(client, id);
  await checkGate(client, op, { domain: domain?.domain });
};

/**
 * POST /ipfs/domains/{id}/pins — Attach or detach the pins a gateway
 * domain serves (`add` / `remove` pin ids; idempotent delta). Gated on the
 * gateway's domain (resolved via `getDomain` when a gate is set).
 */
export const updateDomainPins = async (
  client: Client,
  id: string,
  body: Body<'/ipfs/domains/{id}/pins', 'post'>,
) => {
  await checkGatewayGate(client, 'POST /ipfs/domains/{id}/pins', id);
  return http.post(client, '/ipfs/domains/{id}/pins', { params: { id }, body });
};

/** DELETE /ipfs/domains/{id} — Detach a gateway domain (202). Gated on the gateway's domain. */
export const detachDomain = async (client: Client, id: string) => {
  await checkGatewayGate(client, 'DELETE /ipfs/domains/{id}', id);
  return http.del(client, '/ipfs/domains/{id}', { params: { id } });
};

/** GET /ipfs/usage — Storage usage and cost. */
export const usage = (client: Client) => http.get(client, '/ipfs/usage');

export type Upload = Res<'/ipfs/uploads/{id}', 'get'>['upload'];

export type AddFileOptions = Readonly<{
  /** Display name for the pin. */
  name?: string;
  /** 'file' (default) or 'car' for a client-packed CAR archive. */
  format?: 'file' | 'car';
  /** string → string metadata. */
  meta?: Readonly<Record<string, string>>;
  /** Initial poll interval (default 1000, backing off to an 8 s cap). */
  intervalMs?: number;
  /** Overall deadline (default 300000). */
  timeoutMs?: number;
}>;

const UPLOAD_TERMINAL = new Set(['completed', 'failed', 'expired']);

const toUploadSource = async (source: string | http.UploadSource): Promise<http.UploadSource> => {
  if (typeof source !== 'string') return source;
  const { readFile } = await import('node:fs/promises');
  return new Uint8Array(await readFile(source));
};

/**
 * Upload local content to IPFS end to end: start an upload grant, POST the
 * bytes to the grant URL, poll until the upload completes, and return the
 * final upload (with `cid` and `pin_id`). SOURCE is a file path, bytes, a
 * Blob, or a ReadableStream. Throws an uploadFailed error when the upload
 * fails or expires, or a timeout error when the deadline passes first.
 */
export const addFile = async (
  client: Client,
  source: string | http.UploadSource,
  options: AddFileOptions = {},
): Promise<Upload> => {
  const { name, format, meta } = options;
  const startBody = {
    ...(name === undefined ? {} : { name }),
    ...(format === undefined ? {} : { format }),
    ...(meta === undefined ? {} : { meta: { ...meta } }),
  };
  const { upload } = await startUpload(client, Object.keys(startBody).length === 0 ? undefined : startBody);
  await http.uploadBytes(upload.url, upload.token, await toUploadSource(source), { format, fetch: client.fetch });
  const { upload: final } = await http.pollUntil(
    () => getUpload(client, upload.id),
    (r) => UPLOAD_TERMINAL.has(r.upload.status),
    {
      intervalMs: options.intervalMs,
      timeoutMs: options.timeoutMs ?? 300000,
      message: `Timed out waiting for IPFS upload ${upload.id}`,
      sleep: client.sleep,
    },
  );
  if (final.status === 'completed') return final;
  throw uploadFailed(`IPFS upload ${final.id} ${final.status}`, final);
};