/**
 * HTTP core: typed requests against the API base, requests against absolute
 * node URLs (upload grants, mailboxes), pagination and polling helpers.
 * Every function here is pure apart from the injected `fetch`/`sleep`.
 */
import type { Client } from './client.js';
import { apiError, configError, timeoutError, transportError } from './errors.js';
import type { Body, ElementOf, Method, MethodKey, Params, PathsWith, Query, Res } from './types.js';

export type HttpRequest = Readonly<{
  method: Method;
  url: string;
  headers: Readonly<Record<string, string>>;
  body?: BodyInit;
}>;

export type RequestOptions<P extends PathsWith<M>, M extends MethodKey> = Readonly<{
  /** Values for the `{name}` placeholders in the path. */
  params?: Params<P, M>;
  /** Query-string parameters; undefined/null values are skipped. */
  query?: Query<P, M>;
  /** JSON request body (some DELETEs carry one). */
  body?: Body<P, M>;
}>;

export type UrlRequestOptions = Readonly<{
  /** Bearer token for the endpoint (from the grant or the mint). */
  token?: string | null;
  query?: Readonly<Record<string, string | number | boolean | null | undefined>>;
  /** Extra headers, merged over the computed ones. */
  headers?: Readonly<Record<string, string>>;
  /** Raw body, sent as-is. */
  body?: BodyInit;
  fetch?: typeof fetch;
  timeoutMs?: number;
}>;

export type PollOptions = Readonly<{
  /** Initial interval between polls (default 1000). */
  intervalMs?: number;
  /** Backoff cap: the interval doubles up to this (default 8000). */
  maxIntervalMs?: number;
  /** Overall deadline (default 120000). */
  timeoutMs?: number;
  /** Message for the timeout error. */
  message?: string;
  sleep?: (ms: number) => Promise<void>;
}>;

export type UploadSource = Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array>;

/** Percent-encode one URL component, using %20 (never +) for spaces. */
export const encode = (value: string): string =>
  encodeURIComponent(value).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);

/** Build a query string with its leading `?`, or '' when nothing is set. */
export const queryString = (query?: object | null): string => {
  if (!query) return '';
  const pairs = Object.entries(query)
    .filter(([, value]) => value !== undefined && value !== null)
    .map(([key, value]) => `${encode(key)}=${encode(String(value))}`);
  return pairs.length === 0 ? '' : `?${pairs.join('&')}`;
};

const fillPath = (template: string, params?: object): string =>
  template.replace(/\{([^}]+)\}/g, (_, name: string) => {
    const value = (params as Record<string, unknown> | undefined)?.[name];
    if (value === undefined || value === null) {
      throw configError(`Missing path parameter {${name}} for ${template}`, { template, params });
    }
    return encode(String(value));
  });

const baseHeaders = (token: string | null | undefined, jsonBody: boolean): Record<string, string> => ({
  Accept: 'application/json',
  ...(token?.trim() ? { Authorization: `Bearer ${token}` } : {}),
  ...(jsonBody ? { 'Content-Type': 'application/json' } : {}),
});

/** Build the request for an API call without sending it. */
export const buildRequest = <M extends MethodKey, P extends PathsWith<M>>(
  client: Client,
  method: M,
  path: P,
  options: RequestOptions<P, M> = {},
): HttpRequest => {
  const hasBody = options.body !== undefined;
  return {
    method: method.toUpperCase() as Method,
    url: `${client.apiUrl}${fillPath(path, options.params)}${queryString(options.query)}`,
    headers: { ...baseHeaders(client.apiKey, hasBody), ...client.headers },
    ...(hasBody ? { body: JSON.stringify(options.body) } : {}),
  };
};

type ErrorEnvelope = { error?: string | { code?: string; message?: string } };

const envelope = (parsed: unknown): ErrorEnvelope['error'] =>
  typeof parsed === 'object' && parsed !== null ? (parsed as ErrorEnvelope).error : undefined;

/** The ird API envelope is {error:{code,message}}; the node-hosted mailbox uses a bare {error:"code"}. */
const errorMessage = (parsed: unknown, text: string): string => {
  const error = envelope(parsed);
  if (typeof error === 'string') return error;
  return error?.message ?? text;
};

const errorCode = (parsed: unknown): string | null => {
  const error = envelope(parsed);
  if (typeof error === 'string') return error;
  return error?.code ?? null;
};

/**
 * Turn a raw status + body into the parsed JSON value, throwing an api error
 * on non-2xx statuses and a transport error on unparseable success bodies.
 * An empty 2xx body decodes to `{}`.
 */
export const decodeResponse = (status: number, body: string): unknown => {
  const ok = status >= 200 && status <= 299;
  const text = body.trim();
  if (text === '') {
    if (ok) return {};
    throw apiError('Empty error response', null, status, null);
  }
  let parsed: unknown;
  let parsable = true;
  try {
    parsed = JSON.parse(text);
  } catch (e) {
    if (ok) throw transportError('Failed to parse JSON response', text, e);
    parsable = false;
  }
  if (!ok) {
    const response = parsable && typeof parsed === 'object' ? parsed : null;
    throw apiError(errorMessage(response, text), errorCode(response), status, response);
  }
  return parsed;
};

const describe = (e: unknown): string => (e instanceof Error ? e.message : String(e));

const isStream = (body: BodyInit | undefined): boolean =>
  typeof ReadableStream !== 'undefined' && body instanceof ReadableStream;

const send = async (
  fetchFn: typeof fetch,
  req: HttpRequest,
  timeoutMs: number | undefined,
): Promise<unknown> => {
  const init: RequestInit & { duplex?: 'half' } = {
    method: req.method,
    headers: req.headers,
    ...(req.body === undefined ? {} : { body: req.body }),
    ...(timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {}),
    ...(isStream(req.body) ? { duplex: 'half' } : {}),
  };
  let response: Response;
  let text: string;
  try {
    response = await fetchFn(req.url, init);
    text = await response.text();
  } catch (e) {
    throw transportError(`Request failed: ${describe(e)}`, { url: req.url }, e);
  }
  return decodeResponse(response.status, text);
};

/**
 * Execute an API request. METHOD and PATH are spec keys, so the options and
 * the result are typed from the OpenAPI document:
 *
 *   await request(client, 'get', '/domains/check', { query: { domain: 'x.ro' } })
 *
 * Throws an api error on non-2xx responses and a transport error on
 * connection/parse failures.
 */
export const request = <M extends MethodKey, P extends PathsWith<M>>(
  client: Client,
  method: M,
  path: P,
  options?: RequestOptions<P, M>,
): Promise<Res<P, M>> =>
  send(client.fetch, buildRequest(client, method, path, options), client.timeoutMs) as Promise<Res<P, M>>;

export const get = <P extends PathsWith<'get'>>(client: Client, path: P, options?: RequestOptions<P, 'get'>) =>
  request(client, 'get', path, options);
export const post = <P extends PathsWith<'post'>>(client: Client, path: P, options?: RequestOptions<P, 'post'>) =>
  request(client, 'post', path, options);
export const put = <P extends PathsWith<'put'>>(client: Client, path: P, options?: RequestOptions<P, 'put'>) =>
  request(client, 'put', path, options);
export const patch = <P extends PathsWith<'patch'>>(client: Client, path: P, options?: RequestOptions<P, 'patch'>) =>
  request(client, 'patch', path, options);
export const del = <P extends PathsWith<'delete'>>(client: Client, path: P, options?: RequestOptions<P, 'delete'>) =>
  request(client, 'delete', path, options);

/**
 * Execute a request against an absolute URL rather than the API base — for
 * the node-hosted endpoints the API hands out (an IPFS upload grant, a p2p
 * app's mailbox). Throws like `request`.
 */
export const requestUrl = <T = unknown>(
  method: Method,
  url: string,
  options: UrlRequestOptions = {},
): Promise<T> =>
  send(
    options.fetch ?? globalThis.fetch,
    {
      method,
      url: `${url}${queryString(options.query)}`,
      headers: { ...baseHeaders(options.token, false), ...options.headers },
      ...(options.body === undefined ? {} : { body: options.body }),
    },
    options.timeoutMs,
  ) as Promise<T>;

type PageOptions<P extends PathsWith<'get'>> = Readonly<{
  params?: Params<P, 'get'>;
  query?: Query<P, 'get'>;
}>;

/**
 * Follow cursor pagination for a list endpoint, collecting every item under
 * KEY (e.g. 'registrations'). `cursor` is advanced from each response's
 * `next_cursor` until it is absent.
 */
export const paginate = async <P extends PathsWith<'get'>, K extends keyof Res<P, 'get'> & string>(
  client: Client,
  path: P,
  key: K,
  options: PageOptions<P> = {},
): Promise<readonly ElementOf<Res<P, 'get'>[K]>[]> => {
  const items: ElementOf<Res<P, 'get'>[K]>[] = [];
  let cursor: string | undefined;
  do {
    const query = { ...(options.query as object | undefined), ...(cursor ? { cursor } : {}) } as Query<P, 'get'>;
    const page = (await get(client, path, { params: options.params, query } as RequestOptions<P, 'get'>)) as Record<
      string,
      unknown
    >;
    items.push(...((page[key] as ElementOf<Res<P, 'get'>[K]>[] | undefined) ?? []));
    cursor = (page.next_cursor as string | null | undefined) ?? undefined;
  } while (cursor);
  return items;
};

/**
 * Follow offset pagination for a list endpoint, collecting every item under
 * KEY (e.g. 'pins'). The page `limit` defaults to 100; `offset` advances by
 * the rows each page actually returns and paging stops on the first short
 * or empty page. The response's `total` is deliberately ignored — it can
 * move while the pages are walked.
 */
export const paginateOffset = async <P extends PathsWith<'get'>, K extends keyof Res<P, 'get'> & string>(
  client: Client,
  path: P,
  key: K,
  options: PageOptions<P> = {},
): Promise<readonly ElementOf<Res<P, 'get'>[K]>[]> => {
  const base = (options.query ?? {}) as Record<string, unknown>;
  const limit = typeof base.limit === 'number' ? base.limit : 100;
  const items: ElementOf<Res<P, 'get'>[K]>[] = [];
  let offset = typeof base.offset === 'number' ? base.offset : 0;
  for (;;) {
    const query = { ...base, limit, offset } as Query<P, 'get'>;
    const page = (await get(client, path, { params: options.params, query } as RequestOptions<P, 'get'>)) as Record<
      string,
      unknown
    >;
    const rows = (page[key] as ElementOf<Res<P, 'get'>[K]>[] | undefined) ?? [];
    items.push(...rows);
    if (rows.length < limit) return items;
    offset += rows.length;
  }
};

const defaultSleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));

/**
 * Poll STEP until DONE holds for its result, sleeping between attempts with
 * exponential backoff (the interval doubles up to `maxIntervalMs`). Returns
 * the first result that satisfies DONE; throws a timeout error (carrying the
 * last result) when the deadline passes first.
 */
export const pollUntil = async <T>(
  step: () => Promise<T>,
  done: (result: T) => boolean,
  options: PollOptions = {},
): Promise<T> => {
  const { intervalMs = 1000, maxIntervalMs = 8000, timeoutMs = 120000, sleep = defaultSleep } = options;
  const deadline = Date.now() + timeoutMs;
  let interval = intervalMs;
  for (;;) {
    const result = await step();
    if (done(result)) return result;
    if (Date.now() >= deadline) throw timeoutError(options.message ?? 'Timed out polling', result);
    await sleep(interval);
    interval = Math.min(maxIntervalMs, interval * 2);
  }
};

const isUploadSource = (source: unknown): source is UploadSource =>
  source instanceof Uint8Array ||
  source instanceof ArrayBuffer ||
  (typeof Blob !== 'undefined' && source instanceof Blob) ||
  (typeof ReadableStream !== 'undefined' && source instanceof ReadableStream);

/**
 * POST raw bytes to an IPFS upload-grant URL (from `ipfs.startUpload`). The
 * token is single-use and may be null once consumed. `format: 'car'`
 * appends ?format=car for a client-packed CAR archive.
 */
export const uploadBytes = (
  url: string,
  token: string | null | undefined,
  source: UploadSource,
  options: Readonly<{ format?: 'file' | 'car'; fetch?: typeof fetch; timeoutMs?: number }> = {},
): Promise<unknown> => {
  if (!isUploadSource(source)) {
    throw transportError('Unsupported upload source; expected bytes, an ArrayBuffer, a Blob, or a ReadableStream', {
      source: typeof source,
    });
  }
  return requestUrl('POST', url, {
    token,
    query: options.format === 'car' ? { format: 'car' } : undefined,
    headers: { 'Content-Type': 'application/octet-stream' },
    body: source as BodyInit,
    fetch: options.fetch,
    timeoutMs: options.timeoutMs,
  });
};