import { request as httpRequest } from 'node:http';
import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from 'vitest';
import type { ContentHash } from '../src/asset/blob.js';
import { HttpAssetStore } from '../src/asset/http.js';
import { __setAssetIdFactoryForTesting, type AssetId } from '../src/asset/id.js';
import { PgAssetByteStore } from '../src/asset/pg-bytes.js';
import type { Queryable } from '../src/asset/pg.js';
import { createAssetHttpHandler } from '../src/server/asset.js';
import type { AssetPrincipal, AssetStore } from '../src/asset/types.js';
import {
  FOREIGN_IDS,
  commonDigestEncodings,
  expectNoDigestSubstring,
  runAssetStoreContract,
} from './asset-contract.js';
import {
  startAssetConformanceServer,
  type AssetConformanceServer,
  type AssetConformanceServerOptions,
} from './asset-conformance-server.js';
import { blobForObjectUrl } from './setup.js';

interface RawResponse {
  status: number;
  headers: Record<string, string | string[] | undefined>;
  body: Buffer;
}

let server: AssetConformanceServer;
let namespace = 0;
const stores: HttpAssetStore[] = [];

const blob = (value: string, type = 'text/plain'): Blob => new Blob([value], { type });

function makeStore(principal = 'principal-a', storeId = `asset-${namespace++}`): HttpAssetStore {
  const store = new HttpAssetStore({
    baseUrl: server.baseUrl,
    fetch: server.fetch,
    headers: () => ({
      'x-asset-store-id': storeId,
      'x-asset-principal': principal,
    }),
  });
  stores.push(store);
  return store;
}

function rawRequest(options: {
  method: string;
  path: string;
  headers?: Record<string, string>;
  body?: Buffer | string;
}): Promise<RawResponse> {
  const url = new URL(server.baseUrl);
  const body = typeof options.body === 'string' ? Buffer.from(options.body) : options.body;
  const headers = {
    ...(options.headers ?? {}),
    ...(body === undefined ? {} : { 'content-length': String(body.byteLength) }),
  };
  return new Promise((resolve, reject) => {
    const req = httpRequest(
      {
        hostname: url.hostname,
        port: url.port,
        method: options.method,
        path: options.path,
        headers,
      },
      (res) => {
        const chunks: Buffer[] = [];
        res.on('data', (chunk: Buffer) => chunks.push(chunk));
        res.on('end', () => {
          resolve({
            status: res.statusCode ?? 0,
            headers: res.headers,
            body: Buffer.concat(chunks),
          });
        });
      },
    );
    req.on('error', reject);
    if (body !== undefined) req.write(body);
    req.end();
  });
}

interface Part {
  name: string;
  value: string | Uint8Array;
  contentType?: string;
  filename?: string | null;
  extraHeaders?: Record<string, string>;
}

function multipart(parts: readonly Part[], boundary = 'asset-test-boundary'): Buffer {
  const chunks: Buffer[] = [];
  for (const part of parts) {
    const filename =
      part.filename === undefined
        ? part.name === 'meta'
          ? 'metadata.json'
          : part.name === 'bytes'
            ? 'asset'
            : undefined
        : part.filename;
    chunks.push(
      Buffer.from(
        `--${boundary}\r\nContent-Disposition: form-data; name="${part.name}"${filename === null || filename === undefined ? '' : `; filename="${filename}"`}\r\n`,
      ),
    );
    if (part.contentType !== undefined) {
      chunks.push(Buffer.from(`Content-Type: ${part.contentType}\r\n`));
    }
    for (const [name, value] of Object.entries(part.extraHeaders ?? {})) {
      chunks.push(Buffer.from(`${name}: ${value}\r\n`));
    }
    chunks.push(Buffer.from('\r\n'), Buffer.from(part.value), Buffer.from('\r\n'));
  }
  chunks.push(Buffer.from(`--${boundary}--\r\n`));
  return Buffer.concat(chunks);
}

function multipartHeaders(
  storeId: string,
  principal = 'principal-a',
  boundary = 'asset-test-boundary',
): Record<string, string> {
  return {
    'content-type': `multipart/form-data; boundary=${boundary}`,
    'x-asset-store-id': storeId,
    'x-asset-principal': principal,
  };
}

function comparable(response: RawResponse): unknown {
  return {
    status: response.status,
    headers: Object.fromEntries(
      Object.entries(response.headers).filter(([name]) => name !== 'connection'),
    ),
    body: response.body.toString('base64'),
  };
}

const ASSET_ROUTES = [
  ['POST', '/assets'],
  ['GET', '/assets/id/content'],
  ['HEAD', '/assets/id/content'],
  ['PUT', '/assets/id/content'],
  ['DELETE', '/assets/id'],
] as const;

function unreachableRegistry(): { store: AssetStore; methods: Array<ReturnType<typeof vi.fn>> } {
  const fail = () => {
    throw new Error('asset registry was reached');
  };
  const store = {
    put: vi.fn(fail),
    identify: vi.fn(fail),
    resolve: vi.fn(fail),
    remove: vi.fn(fail),
    replace: vi.fn(fail),
  } satisfies AssetStore;
  return { store, methods: Object.values(store) };
}

async function expectAuthRejection(
  options: Pick<AssetConformanceServerOptions, 'authenticate' | 'authorizeAssets'>,
  expectedStatus: number,
  expectedCode: string,
): Promise<void> {
  const registry = unreachableRegistry();
  const isolated = await startAssetConformanceServer({
    ...options,
    store: () => registry.store,
  });
  try {
    for (const [method, path] of ASSET_ROUTES) {
      const response = await isolated.fetch(`${isolated.baseUrl}${path}`, { method });
      expect(response.status, `${method} ${path}`).toBe(expectedStatus);
      if (method === 'HEAD') {
        expect(response.headers.get('x-error-code'), `${method} ${path}`).toBe(expectedCode);
      } else {
        await expect(response.json(), `${method} ${path}`).resolves.toMatchObject({
          error: { code: expectedCode },
        });
      }
      for (const registryMethod of registry.methods) {
        expect(registryMethod, `${method} ${path}`).not.toHaveBeenCalled();
      }
    }
  } finally {
    await isolated.close();
  }
}

beforeAll(async () => {
  server = await startAssetConformanceServer();
});

afterEach(async () => {
  __setAssetIdFactoryForTesting(null);
  await Promise.all(stores.splice(0).map((store) => store.close()));
});

afterAll(async () => {
  await server.close();
});

runAssetStoreContract(
  'HttpAssetStore over PgAssetStore (PGlite)',
  {
    makeStore: () => makeStore(),
    withAllocator: async (allocator, run) => {
      __setAssetIdFactoryForTesting(allocator);
      try {
        return await run();
      } finally {
        __setAssetIdFactoryForTesting(null);
      }
    },
  },
  async (url) => {
    const stored = blobForObjectUrl(url);
    if (!stored) throw new Error('object URL is not registered');
    return new Uint8Array(await stored.arrayBuffer());
  },
);

describe('asset HTTP handler contract', () => {
  test('exposes revisions on successful cross-origin writes', async () => {
    const storeId = `write-revision-${namespace++}`;
    const allocation = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(storeId),
      body: multipart([
        { name: 'meta', value: '{}', contentType: 'application/json' },
        { name: 'bytes', value: 'original', contentType: 'text/plain' },
      ]),
    });
    expect(allocation.status).toBe(201);
    expect(allocation.headers['x-asset-revision']).toBe('1');
    expect(allocation.headers['access-control-expose-headers']).toBe('X-Asset-Revision');

    const id = (JSON.parse(allocation.body.toString()) as { id: string }).id;
    const replacement = await rawRequest({
      method: 'PUT',
      path: `/assets/${encodeURIComponent(id)}/content`,
      headers: multipartHeaders(storeId),
      body: multipart([{ name: 'bytes', value: 'replacement', contentType: 'text/plain' }]),
    });
    expect(replacement.status).toBe(204);
    expect(replacement.headers['x-asset-revision']).toBe('2');
    expect(replacement.headers['access-control-expose-headers']).toBe('X-Asset-Revision');
  });

  test('rejects unauthenticated requests before reaching the registry', async () => {
    await expectAuthRejection({ authenticate: async () => undefined }, 401, 'UNAUTHENTICATED');
  });

  test('maps a malformed authenticated principal to an internal error before the registry', async () => {
    const errorLog = vi.spyOn(console, 'error').mockImplementation(() => undefined);
    try {
      await expectAuthRejection(
        { authenticate: async () => null as unknown as AssetPrincipal },
        500,
        'INTERNAL_ERROR',
      );
    } finally {
      errorLog.mockRestore();
    }
  });

  test('forbids a principal without an asset key on every route before the registry', async () => {
    await expectAuthRejection(
      { authenticate: async () => ({}) as AssetPrincipal },
      403,
      'FORBIDDEN_ASSETS',
    );
  });

  test('applies authorizeAssets denial uniformly before the registry', async () => {
    await expectAuthRejection(
      {
        authenticate: async () => ({ key: 'principal' }),
        authorizeAssets: async () => false,
      },
      403,
      'FORBIDDEN_ASSETS',
    );
  });

  test('HEAD and GET have identical outcomes and headers for owned and missing ids', async () => {
    const storeId = `head-parity-${namespace++}`;
    const owner = makeStore('owner', storeId);
    const other = makeStore('other', storeId);
    const ownId = await owner.put(blob('owned bytes', 'image/png'));
    const foreignId = await other.put(blob('foreign bytes', 'image/png'));
    const deletedId = await owner.put(blob('deleted bytes', 'image/png'));
    await owner.remove(deletedId);

    const cases = [
      ['own', ownId],
      ['foreign', foreignId],
      ['never-allocated', 'ast_never_allocated'],
      ['already-deleted', deletedId],
    ] as const;
    const requestHeaders = {
      'x-asset-store-id': storeId,
      'x-asset-principal': 'owner',
    };

    for (const [kind, id] of cases) {
      const path = `/assets/${encodeURIComponent(id)}/content`;
      const [get, head] = await Promise.all([
        rawRequest({ method: 'GET', path, headers: requestHeaders }),
        rawRequest({ method: 'HEAD', path, headers: requestHeaders }),
      ]);
      const getHeaders = get.headers;
      const headHeaders = head.headers;

      expect(head.status, kind).toBe(get.status);
      expect(headHeaders, kind).toEqual(getHeaders);
      expect(head.body, kind).toHaveLength(0);
      if (kind === 'own') {
        expect(get.status).toBe(200);
        expect(get.body).toEqual(Buffer.from('owned bytes'));
        expect(getHeaders).toEqual({
          'access-control-expose-headers': 'X-Asset-Revision, X-Error-Code',
          'cache-control': 'private, no-store',
          connection: 'keep-alive',
          'content-length': '11',
          'content-type': 'image/png',
          'keep-alive': 'timeout=5',
          vary: 'Cookie, Authorization',
          'x-asset-revision': '1',
          'x-content-type-options': 'nosniff',
        });
      } else {
        expect(get.status).toBe(404);
        expect(JSON.parse(get.body.toString())).toEqual({
          error: {
            code: 'ASSET_NOT_FOUND',
            message: '@openmaic/storage: no asset is stored under that id',
          },
        });
        expect(getHeaders).toEqual({
          'access-control-expose-headers': 'X-Asset-Revision, X-Error-Code',
          connection: 'keep-alive',
          'content-length': '100',
          'content-type': 'application/json',
          'keep-alive': 'timeout=5',
          'x-error-code': 'ASSET_NOT_FOUND',
        });
      }
    }
  });

  test('HEAD reads registry identity without reaching the byte layer', async () => {
    class FailingReadByteStore extends PgAssetByteStore {
      override async read(_hash: ContentHash): Promise<Uint8Array | null> {
        throw new Error('HEAD reached the byte layer');
      }

      override async readWith(
        _queryable: Queryable,
        _hash: ContentHash,
      ): Promise<Uint8Array | null> {
        throw new Error('HEAD reached the byte layer');
      }
    }

    const isolated = await startAssetConformanceServer({
      byteStore: (db) => new FailingReadByteStore(db),
    });
    const store = new HttpAssetStore({
      baseUrl: isolated.baseUrl,
      fetch: isolated.fetch,
      headers: () => ({ 'x-asset-principal': 'owner' }),
    });
    try {
      const id = await store.put(blob('identity only', 'image/png'));
      const response = await isolated.fetch(`${isolated.baseUrl}/assets/${id}/content`, {
        method: 'HEAD',
        headers: { 'x-asset-principal': 'owner' },
      });
      expect(response.status).toBe(200);
      expect(response.headers.get('content-type')).toBe('image/png');
      expect(response.headers.get('content-length')).toBe('13');
      expect(response.headers.get('x-asset-revision')).toBe('1');
      expect((await response.arrayBuffer()).byteLength).toBe(0);
    } finally {
      await store.close();
      await isolated.close();
    }
  });

  test('foreign, absent, deleted, and malformed-shape ids are indistinguishable on every id route', async () => {
    const storeId = `matrix-${namespace++}`;
    const owner = makeStore('owner', storeId);
    const other = makeStore('other', storeId);
    const ownId = await owner.put(blob('own'));
    const foreignId = await other.put(blob('foreign'));
    const deletedId = await owner.put(blob('deleted'));
    await owner.remove(deletedId);
    const ids = {
      other: foreignId,
      'never-allocated': 'ast_never_allocated',
      'already-deleted': deletedId,
      malformed: 'not-an-asset-id',
    };

    for (const method of ['GET', 'HEAD', 'PUT', 'DELETE'] as const) {
      const observations: unknown[] = [];
      for (const id of Object.values(ids)) {
        const path =
          method === 'DELETE'
            ? `/assets/${encodeURIComponent(id)}`
            : `/assets/${encodeURIComponent(id)}/content`;
        const write = multipart([
          { name: 'bytes', value: 'replacement', contentType: 'text/plain' },
        ]);
        const response = await rawRequest({
          method,
          path,
          headers:
            method === 'PUT'
              ? multipartHeaders(storeId, 'owner')
              : { 'x-asset-store-id': storeId, 'x-asset-principal': 'owner' },
          ...(method === 'PUT' ? { body: write } : {}),
        });
        observations.push(comparable(response));
      }
      for (const observation of observations.slice(1)) expect(observation).toEqual(observations[0]);

      const ownPath =
        method === 'DELETE'
          ? `/assets/${encodeURIComponent(ownId)}`
          : `/assets/${encodeURIComponent(ownId)}/content`;
      const own = await rawRequest({
        method,
        path: ownPath,
        headers:
          method === 'PUT'
            ? multipartHeaders(storeId, 'owner')
            : { 'x-asset-store-id': storeId, 'x-asset-principal': 'owner' },
        ...(method === 'PUT'
          ? {
              body: multipart([
                { name: 'bytes', value: 'own replacement', contentType: 'text/plain' },
              ]),
            }
          : {}),
      });
      expect(own.status).toBe(method === 'GET' || method === 'HEAD' ? 200 : 204);
    }
  });

  test('every FOREIGN_IDS value remains an ordinary HTTP miss', async () => {
    const store = makeStore();
    for (const [, id] of FOREIGN_IDS) {
      await expect(store.resolve(id)).resolves.toBeNull();
      await expect(store.remove(id)).resolves.toBeUndefined();
    }
  });

  test('query strings are rejected on all five routes', async () => {
    const storeId = `query-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const id = await store.put(blob('query target'));
    const cases = [
      ['POST', '/assets?'],
      ['GET', `/assets/${id}/content?x=1`],
      ['HEAD', `/assets/${id}/content?`],
      ['PUT', `/assets/${id}/content?x=1`],
      ['DELETE', `/assets/${id}?x=1`],
    ] as const;
    for (const [method, path] of cases) {
      const response = await rawRequest({
        method,
        path,
        headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
      });
      expect(response.status).toBe(400);
      if (method !== 'HEAD') expect(response.body.toString()).toContain('VALIDATION_FAILED');
    }
  });

  test('GET, HEAD, and DELETE reject request bodies', async () => {
    const storeId = `bodyless-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const id = await store.put(blob('bodyless'));
    for (const [method, path] of [
      ['GET', `/assets/${id}/content`],
      ['HEAD', `/assets/${id}/content`],
      ['DELETE', `/assets/${id}`],
    ] as const) {
      const response = await rawRequest({
        method,
        path,
        headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
        body: 'smuggled',
      });
      expect(response.status).toBe(400);
    }
  });

  test('rejects hostile multipart shapes without writing', async () => {
    const storeId = `multipart-${namespace++}`;
    const headers = multipartHeaders(storeId);
    const cases: Array<[string, Buffer, number]> = [
      [
        'duplicate meta parts',
        multipart([
          { name: 'meta', value: '{}', contentType: 'application/json' },
          { name: 'meta', value: '{}', contentType: 'application/json' },
          { name: 'bytes', value: 'a' },
        ]),
        400,
      ],
      [
        'duplicate bytes parts',
        multipart([
          { name: 'meta', value: '{}', contentType: 'application/json' },
          { name: 'bytes', value: 'a' },
          { name: 'bytes', value: 'b' },
        ]),
        400,
      ],
      [
        'extra part',
        multipart([
          { name: 'meta', value: '{}', contentType: 'application/json' },
          { name: 'extra', value: 'x' },
          { name: 'bytes', value: 'a' },
        ]),
        400,
      ],
      [
        'missing bytes',
        multipart([{ name: 'meta', value: '{}', contentType: 'application/json' }]),
        400,
      ],
      [
        'wrong order',
        multipart([
          { name: 'bytes', value: 'a' },
          { name: 'meta', value: '{}', contentType: 'application/json' },
        ]),
        400,
      ],
    ];
    for (const [, body, status] of cases) {
      const response = await rawRequest({ method: 'POST', path: '/assets', headers, body });
      expect(response.status).toBe(status);
    }
    const wrongType = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: { 'content-type': 'application/json', 'x-asset-store-id': storeId },
      body: '{}',
    });
    expect(wrongType.status).toBe(415);
  });

  test('enforces request, metadata, and asset byte limits independently', async () => {
    const limited = await startAssetConformanceServer({
      maxRequestBytes: 700,
      maxAssetBytes: 20,
      maxMetaBytes: 20,
    });
    try {
      const url = new URL(limited.baseUrl);
      const send = (body: Buffer): Promise<RawResponse> =>
        new Promise((resolve, reject) => {
          const req = httpRequest(
            {
              hostname: url.hostname,
              port: url.port,
              method: 'POST',
              path: '/assets',
              headers: {
                'content-type': 'multipart/form-data; boundary=asset-test-boundary',
                'content-length': String(body.byteLength),
              },
            },
            (res) => {
              const chunks: Buffer[] = [];
              res.on('data', (chunk: Buffer) => chunks.push(chunk));
              res.on('end', () =>
                resolve({
                  status: res.statusCode ?? 0,
                  headers: res.headers,
                  body: Buffer.concat(chunks),
                }),
              );
            },
          );
          req.on('error', reject);
          req.end(body);
        });
      const oversizedMeta = multipart([
        {
          name: 'meta',
          value: JSON.stringify({ x: 'm'.repeat(30) }),
          contentType: 'application/json',
        },
        { name: 'bytes', value: 'ok' },
      ]);
      const oversizedAsset = multipart([
        { name: 'meta', value: '{}', contentType: 'application/json' },
        { name: 'bytes', value: 'b'.repeat(21) },
      ]);
      const oversizedRequest = Buffer.concat([
        multipart([
          { name: 'meta', value: '{}', contentType: 'application/json' },
          { name: 'bytes', value: 'ok' },
        ]),
        Buffer.alloc(800),
      ]);
      expect((await send(oversizedMeta)).status).toBe(413);
      expect((await send(oversizedAsset)).status).toBe(413);
      expect((await send(oversizedRequest)).status).toBe(413);
    } finally {
      await limited.close();
    }
  });

  test.each([
    ['name smuggled in a quoted filename', 'form-data; filename="x; name=meta; y"'],
    ['unterminated quote', 'form-data; name="meta'],
    ['trailing text after a quote', 'form-data; name="meta"junk'],
    ['continuation parameter', 'form-data; name=meta; name*0=bytes'],
    ['non-ASCII separator', 'form-data;\u00a0name=meta'],
    ['bare LF in a quoted filename', 'form-data; name=meta; filename="a\nb"'],
  ] as const)('platform parser rejects %s', async (_label, metaDisposition) => {
    const boundary = 'asset-test-boundary';
    const body = Buffer.concat([
      Buffer.from(
        `--${boundary}\r\nContent-Disposition: ${metaDisposition}\r\n` +
          'Content-Type: application/json\r\n\r\n{}\r\n',
        'latin1',
      ),
      Buffer.from(
        `--${boundary}\r\nContent-Disposition: form-data; name="bytes"; filename="asset"\r\n\r\npayload\r\n`,
        'latin1',
      ),
      Buffer.from(`--${boundary}--\r\n`),
    ]);
    const response = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(`disposition-${namespace++}`, 'principal-a', boundary),
      body,
    });
    expect(response.status).toBe(400);
    expect(JSON.parse(response.body.toString())).toEqual({
      error: {
        code: 'VALIDATION_FAILED',
        message: '@openmaic/storage: malformed multipart body',
      },
    });
  });

  test('rejects a meta part without filename as text-decoded data', async () => {
    const response = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(`meta-string-${namespace++}`),
      body: multipart([
        { name: 'meta', value: '{}', contentType: 'application/json', filename: null },
        { name: 'bytes', value: 'payload' },
      ]),
    });
    expect(response.status).toBe(400);
    expect(response.body.toString()).toContain('meta part must be sent as a file');
  });

  test('rejects a meta file whose media type is not application/json', async () => {
    const response = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(`meta-type-${namespace++}`),
      body: multipart([
        { name: 'meta', value: '{}', contentType: 'text/plain' },
        { name: 'bytes', value: 'payload' },
      ]),
    });
    expect(response.status).toBe(400);
    expect(response.body.toString()).toContain('meta part must be application/json');
  });

  test('rejects a meta file whose bytes are not valid UTF-8', async () => {
    const response = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(`meta-utf8-${namespace++}`),
      body: multipart([
        {
          name: 'meta',
          value: Uint8Array.of(0x7b, 0x22, 0x78, 0x22, 0x3a, 0x22, 0xff, 0x22, 0x7d),
          contentType: 'application/json',
        },
        { name: 'bytes', value: 'payload' },
      ]),
    });
    expect(response.status).toBe(400);
    expect(response.body.toString()).toContain('meta part must contain valid UTF-8');
  });

  test('rejects a bytes part without filename as text-decoded data', async () => {
    const response = await rawRequest({
      method: 'POST',
      path: '/assets',
      headers: multipartHeaders(`bytes-string-${namespace++}`),
      body: multipart([
        { name: 'meta', value: '{}', contentType: 'application/json' },
        { name: 'bytes', value: 'payload', filename: null },
      ]),
    });
    expect(response.status).toBe(400);
    expect(response.body.toString()).toContain('bytes part must be sent as a file');
  });

  test('the client round-trips non-UTF-8 bytes through a file part', async () => {
    const storeId = `binary-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const original = Uint8Array.of(0x89, 0x50, 0x4e, 0x47, 0x00, 0xff, 0xfe, 0x80);
    const id = await store.put(new Blob([original], { type: 'image/png' }));
    const response = await rawRequest({
      method: 'GET',
      path: `/assets/${id}/content`,
      headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
    });
    expect(response.status).toBe(200);
    expect(response.body).toEqual(Buffer.from(original));
  });

  test('exceeding maxParts is a payload limit, not a validation failure', async () => {
    const limited = await startAssetConformanceServer({ maxParts: 2 });
    try {
      const url = new URL(limited.baseUrl);
      const body = multipart([
        { name: 'meta', value: '{}', contentType: 'application/json' },
        { name: 'bytes', value: 'ok' },
        { name: 'bytes', value: 'extra' },
      ]);
      const response = await new Promise<RawResponse>((resolve, reject) => {
        const req = httpRequest(
          {
            hostname: url.hostname,
            port: url.port,
            method: 'POST',
            path: '/assets',
            headers: {
              'content-type': 'multipart/form-data; boundary=asset-test-boundary',
              'content-length': String(body.byteLength),
            },
          },
          (res) => {
            const chunks: Buffer[] = [];
            res.on('data', (chunk: Buffer) => chunks.push(chunk));
            res.on('end', () =>
              resolve({
                status: res.statusCode ?? 0,
                headers: res.headers,
                body: Buffer.concat(chunks),
              }),
            );
          },
        );
        req.on('error', reject);
        req.end(body);
      });
      expect(response.status).toBe(413);
    } finally {
      await limited.close();
    }
  });

  test('wrong methods return 405 with Allow and /assetsfoo is ROUTE_NOT_FOUND', async () => {
    const storeId = `routes-${namespace++}`;
    for (const [path, allow] of [
      ['/assets', 'POST'],
      ['/assets/id', 'DELETE'],
      ['/assets/id/content', 'GET, HEAD, PUT'],
    ] as const) {
      const response = await rawRequest({
        method: 'PATCH',
        path,
        headers: { 'x-asset-store-id': storeId },
      });
      expect(response.status).toBe(405);
      expect(response.headers.allow).toBe(allow);
    }
    const outside = await rawRequest({ method: 'GET', path: '/assetsfoo' });
    expect(outside.status).toBe(404);
    expect(outside.body.toString()).toContain('ROUTE_NOT_FOUND');
  });

  test('byte responses enforce safe labels and required headers', async () => {
    const storeId = `labels-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const id = await store.put(blob('<svg/>', 'image/svg+xml'));
    const response = await server.fetch(`${server.baseUrl}/assets/${id}/content`, {
      headers: { 'x-asset-principal': 'principal-a', 'x-asset-store-id': storeId },
    });
    expect(response.status).toBe(200);
    expect(response.headers.get('content-type')).toBe('application/octet-stream');
    expect(response.headers.get('content-disposition')).toBe('attachment');
    expect(response.headers.get('x-content-type-options')).toBe('nosniff');
    expect(response.headers.get('cache-control')).toBe('private, no-store');
    expect(response.headers.get('vary')).toBe('Cookie, Authorization');
    expect(response.headers.get('etag')).toBeNull();
    expect(response.headers.get('last-modified')).toBeNull();
    expect(response.headers.get('accept-ranges')).toBeNull();
    const url = await store.resolve(id);
    const stored = blobForObjectUrl(url!);
    expect(stored?.type).toBe('application/octet-stream');
  });

  test('metadata-omitting PUT with an untyped blob uses the binary default media type', async () => {
    const storeId = `retained-type-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const id = await store.put(blob('before', 'image/png'), { contentType: 'image/png' });
    await store.replace(id as AssetId, blob('after', ''));
    const response = await server.fetch(`${server.baseUrl}/assets/${id}/content`, {
      headers: { 'x-asset-principal': 'principal-a', 'x-asset-store-id': storeId },
    });
    expect(response.headers.get('content-type')).toBe('application/octet-stream');
  });

  test('no digest encoding appears in response headers, bodies, ids, or error messages', async () => {
    const storeId = `digest-${namespace++}`;
    const store = makeStore('principal-a', storeId);
    const data = blob('digest scan payload', 'image/png');
    const id = await store.put(data);
    await expectNoDigestSubstring(id, data);
    const responses = await Promise.all([
      rawRequest({
        method: 'GET',
        path: `/assets/${id}/content`,
        headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
      }),
      rawRequest({
        method: 'HEAD',
        path: `/assets/${id}/content`,
        headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
      }),
      rawRequest({
        method: 'GET',
        path: '/assets/absent/content',
        headers: { 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' },
      }),
    ]);
    const observed = responses
      .map((response) => `${JSON.stringify(response.headers)}\n${response.body.toString()}`)
      .join('\n');
    for (const encoding of await commonDigestEncodings(data)) {
      expect(observed.toLowerCase()).not.toContain(encoding.slice(0, 12).toLowerCase());
    }
  });
});

describe('HttpAssetStore snapshot behavior', () => {
  test('coalesces concurrent cold resolves into one GET and one URL', async () => {
    const storeId = `coalesce-${namespace++}`;
    const writer = makeStore('principal-a', storeId);
    const id = await writer.put(blob('coalesce'));
    let gets = 0;
    const client = new HttpAssetStore({
      baseUrl: server.baseUrl,
      fetch: async (input, init) => {
        if ((init?.method ?? 'GET') === 'GET') gets += 1;
        return server.fetch(input, init);
      },
      headers: () => ({ 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' }),
    });
    stores.push(client);
    const [left, right] = await Promise.all([client.resolve(id), client.resolve(id)]);
    expect(left).toBe(right);
    expect(gets).toBe(1);
  });

  test('identical bytes under two ids mint different per-id URLs', async () => {
    const store = makeStore();
    const [leftId, rightId] = await Promise.all([store.put(blob('same')), store.put(blob('same'))]);
    const [left, right] = await Promise.all([store.resolve(leftId), store.resolve(rightId)]);
    expect(left).not.toBe(right);
  });

  test('replace retires rather than revokes an issued snapshot; release revokes both', async () => {
    const store = makeStore();
    const id = await store.put(blob('before'));
    const before = await store.resolve(id);
    expect(blobForObjectUrl(before!)).toBeDefined();
    await store.replace(id as AssetId, blob('after'));
    const after = await store.resolve(id);
    expect(after).not.toBe(before);
    expect(blobForObjectUrl(before!)).toBeDefined();
    expect(blobForObjectUrl(after!)).toBeDefined();
    await store.release(id);
    expect(blobForObjectUrl(before!)).toBeUndefined();
    expect(blobForObjectUrl(after!)).toBeUndefined();
  });

  test('warm resolves revalidate with HEAD', async () => {
    const storeId = `head-${namespace++}`;
    const writer = makeStore('principal-a', storeId);
    const id = await writer.put(blob('head'));
    const methods: string[] = [];
    const client = new HttpAssetStore({
      baseUrl: server.baseUrl,
      fetch: async (input, init) => {
        methods.push(init?.method ?? 'GET');
        return server.fetch(input, init);
      },
      headers: () => ({ 'x-asset-store-id': storeId, 'x-asset-principal': 'principal-a' }),
    });
    stores.push(client);
    const first = await client.resolve(id);
    const second = await client.resolve(id);
    expect(second).toBe(first);
    expect(methods).toEqual(['GET', 'HEAD']);
  });

  test('records the GET revision rather than the preceding HEAD revision', async () => {
    let gets = 0;
    let heads = 0;
    const fetch = vi.fn<typeof globalThis.fetch>(async (_input, init) => {
      const method = init?.method ?? 'GET';
      if (method === 'HEAD') {
        heads += 1;
        const revision = heads === 1 ? '2' : '3';
        return new Response(null, {
          status: 200,
          headers: { 'x-asset-revision': revision, 'content-type': 'image/png' },
        });
      }
      gets += 1;
      return new Response(gets === 1 ? 'one' : 'three', {
        status: 200,
        headers: {
          'x-asset-revision': gets === 1 ? '1' : '3',
          'content-type': 'image/png',
        },
      });
    });
    const store = new HttpAssetStore({ baseUrl: 'https://assets.invalid', fetch });
    stores.push(store);
    await store.resolve('asset');
    await store.resolve('asset');
    await store.resolve('asset');
    expect(gets).toBe(2);
    expect(heads).toBe(2);
  });

  test('an unclassifiable HEAD falls back to GET and is never treated as a miss', async () => {
    let requests = 0;
    const fetch = vi.fn<typeof globalThis.fetch>(async (_input, init) => {
      requests += 1;
      if (requests === 1) {
        return new Response('bytes', {
          status: 200,
          headers: { 'x-asset-revision': '1', 'content-type': 'image/png' },
        });
      }
      if (init?.method === 'HEAD') return new Response(null, { status: 404 });
      return new Response('bytes', {
        status: 200,
        headers: { 'x-asset-revision': '1', 'content-type': 'image/png' },
      });
    });
    const store = new HttpAssetStore({ baseUrl: 'https://assets.invalid', fetch });
    stores.push(store);
    const first = await store.resolve('asset');
    await expect(store.resolve('asset')).resolves.toBe(first);
    expect(requests).toBe(3);
  });

  test('only status 404 together with ASSET_NOT_FOUND is a miss', async () => {
    const store = new HttpAssetStore({
      baseUrl: 'https://assets.invalid',
      fetch: async () =>
        new Response(JSON.stringify({ error: { code: 'ROUTE_NOT_FOUND', message: 'route' } }), {
          status: 404,
          headers: { 'content-type': 'application/json' },
        }),
    });
    stores.push(store);
    await expect(store.resolve('asset')).rejects.toMatchObject({
      status: 404,
      code: 'ROUTE_NOT_FOUND',
    });
  });

  test('unaddressable ids resolve and remove locally while replace synthesizes not found', async () => {
    const fetch = vi.fn<typeof globalThis.fetch>();
    const store = new HttpAssetStore({ baseUrl: 'https://assets.invalid', fetch });
    stores.push(store);
    for (const id of ['', '.', '..', '\ud800']) {
      await expect(store.resolve(id)).resolves.toBeNull();
      await expect(store.remove(id)).resolves.toBeUndefined();
      await expect(store.replace(id as AssetId, blob('x'))).rejects.toMatchObject({
        status: 404,
        code: 'ASSET_NOT_FOUND',
      });
    }
    expect(fetch).not.toHaveBeenCalled();
  });

  test('a headers hook cannot overwrite multipart Content-Type', async () => {
    const store = new HttpAssetStore({
      baseUrl: 'https://assets.invalid',
      fetch: vi.fn<typeof globalThis.fetch>(),
      headers: () => ({ 'content-type': 'multipart/form-data' }),
    });
    stores.push(store);
    await expect(store.put(blob('x'))).rejects.toMatchObject({ code: 'CONTENT_TYPE_CONFLICT' });
  });
});

describe('asset handler construction', () => {
  const inertStore = {} as AssetStore;

  test('refuses executable renderable types', () => {
    expect(() =>
      createAssetHttpHandler(inertStore, {
        authenticate: async () => ({ key: 'principal' }),
        renderableTypes: ['image/svg+xml'],
      }),
    ).toThrow(/excluded executable type/);
  });

  test('requires outer request room beyond the decoded part limits', () => {
    expect(() =>
      createAssetHttpHandler(inertStore, {
        authenticate: async () => ({ key: 'principal' }),
        maxRequestBytes: 20,
        maxAssetBytes: 10,
        maxMetaBytes: 10,
      }),
    ).toThrow(/multipart framing/);
  });
});