import { mkdtemp, readFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { PassThrough, Writable } from 'node:stream';

import { afterEach, beforeEach, describe, expect, it } from 'vitest';

import { downloadToFile, runCommand } from '#/app/capability/host';
import type { IHostProcess, IHostProcessService } from '#/os/interface/hostProcess';

describe('capability host runCommand', () => {
  it('does not leak a rejected promise when a timed-out process fails while being killed', async () => {
    const stdout = new PassThrough();
    const stderr = new PassThrough();
    let rejectWait: ((error: Error) => void) | undefined;
    const wait = new Promise<number>((_resolve, reject) => {
      rejectWait = reject;
    });
    const proc = {
      _serviceBrand: undefined,
      pid: 1234,
      exitCode: null,
      stdin: new Writable({
        write: (_chunk, _encoding, callback) => {
          callback();
        },
      }),
      stdout,
      stderr,
      wait: () => wait,
      kill: () => {
        stdout.destroy(new Error('stream closed after timeout'));
        stderr.end();
        rejectWait?.(new Error('process killed'));
        return Promise.resolve();
      },
      dispose: () => undefined,
    } as IHostProcess;
    const host = {
      _serviceBrand: undefined,
      spawn: () => Promise.resolve(proc),
    } as IHostProcessService;
    const unhandled: unknown[] = [];
    const onUnhandled = (error: unknown): void => {
      unhandled.push(error);
    };
    process.on('unhandledRejection', onUnhandled);

    try {
      await expect(runCommand(host, 'hang', [], { timeout: 5 })).rejects.toThrow(
        'command timed out after 5ms: hang',
      );
      await new Promise<void>((resolve) => {
        setImmediate(resolve);
      });
      expect(unhandled).toEqual([]);
    } finally {
      process.off('unhandledRejection', onUnhandled);
    }
  });
});

describe('capability host downloadToFile', () => {
  let root: string;
  beforeEach(async () => {
    root = await mkdtemp(path.join(tmpdir(), 'capability-download-'));
  });
  afterEach(async () => {
    await rm(root, { recursive: true, force: true });
  });

  function fakeFetchWith(body: ReadableStream): typeof fetch {
    return (() =>
      Promise.resolve(
        new Response(body, {
          status: 200,
          headers: { 'content-length': '100' },
        }),
      )) as unknown as typeof fetch;
  }

  it('aborts a response whose byte stream goes quiet', async () => {
    const body = new ReadableStream({
      start(controller) {
        controller.enqueue(new Uint8Array([1, 2, 3]));
      },
    });

    await expect(
      downloadToFile(
        'https://cdn.example.test/blob',
        path.join(root, 'blob'),
        undefined,
        fakeFetchWith(body) as never,
        { idleTimeoutMs: 5 },
      ),
    ).rejects.toThrow(/stalled/);
  });

  it('aborts when the response headers never arrive', async () => {
    const hangingFetch = ((_url: string, init?: { signal?: AbortSignal }) =>
      new Promise((_resolve, reject) => {
        init?.signal?.addEventListener('abort', () => {
          reject(new DOMException('This operation was aborted.', 'AbortError'));
        });
      })) as never;

    await expect(
      downloadToFile(
        'https://cdn.example.test/headers',
        path.join(root, 'headers'),
        undefined,
        hangingFetch,
        { idleTimeoutMs: 5 },
      ),
    ).rejects.toThrow(/no response within 5ms/);
  });

  it('lets a slow but flowing download finish intact', async () => {
    const chunks = ['hel', 'lo ', 'wor', 'ld'];
    const body = new ReadableStream({
      async start(controller) {
        for (const chunk of chunks) {
          controller.enqueue(new TextEncoder().encode(chunk));
          await new Promise((resolve) => {
            setTimeout(resolve, 30);
          });
        }
        controller.close();
      },
    });

    const dest = path.join(root, 'hello.txt');
    const received = await downloadToFile(
      'https://cdn.example.test/hello',
      dest,
      undefined,
      fakeFetchWith(body) as never,
      { idleTimeoutMs: 50 },
    );

    expect(received).toBe(11);
    expect(await readFile(dest, 'utf-8')).toBe('hello world');
  });
});