// Enhanced REPRL worker script with all API bindings exposed
import { default as Stdin } from 'workerd:stdin';
import crypto from 'crypto';
import * as fs from 'node:fs';
import { Buffer } from 'node:buffer';
import {
  ok,
  match,
  rejects,
  strictEqual,
  throws,
  deepStrictEqual,
  notStrictEqual,
} from 'node:assert';
import { mock } from 'node:test';
import { Writable, Readable, Transform } from 'node:stream';
import { text } from 'node:stream/consumers';
import { pipeline } from 'node:stream/promises';
import { StringDecoder } from 'node:string_decoder';
import { EventEmitter } from 'node:events';
import { env } from 'node:process';
import zlib from 'node:zlib';
import { AsyncLocalStorage } from 'node:async_hooks';
import {
  channel,
  hasSubscribers,
  subscribe,
  unsubscribe,
  tracingChannel,
} from 'node:diagnostics_channel';
import dns from 'node:dns';
import path from 'node:path';

// Expose all APIs to the global scope for fuzzing
export default {
  async fetch(request, env, ctx) {
    return new Response('REPRL mode active');
  },

  async test(request, env, ctx) {
    // fuzzilli is already globally available when compiled with WORKERD_FUZZILLI
    // Expose bindings
    //globalThis.CONSUMER_FETCH = env.CONSUMER.fetch;

    globalThis.env = env;
    process = undefined;
    globalThis.process = undefined;

    // used for scheduler.await
    globalThis.scheduler = scheduler;

    // zlib
    globalThis.zlib = zlib;

    // Expose Web Crypto API
    globalThis.crypto = crypto;

    globalThis.AsyncLocalStorage = AsyncLocalStorage;

    //path
    globalThis.path = path;

    // dns
    globalThis.dns = dns;

    // diagnostics
    globalThis.channel = channel;
    globalThis.hasSubscribers = hasSubscribers;
    globalThis.subscribe = subscribe;
    globalThis.unsubscribe = unsubscribe;
    globalThis.tracingChannel = tracingChannel;

    // Expose Web Standards
    globalThis.Response = Response;
    globalThis.Request = Request;
    globalThis.Headers = Headers;
    globalThis.URL = URL;
    globalThis.URLPattern = URLPattern;
    globalThis.URLSearchParams = URLSearchParams;
    globalThis.TextEncoder = TextEncoder;
    globalThis.TextDecoder = TextDecoder;

    // Expose streams
    globalThis.ReadableStream = ReadableStream;
    globalThis.WritableStream = WritableStream;
    globalThis.TransformStream = TransformStream;
    globalThis.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
    globalThis.CountQueuingStrategy = CountQueuingStrategy;

    // Expose compression/decompression streams
    globalThis.CompressionStream = CompressionStream;
    globalThis.DecompressionStream = DecompressionStream;

    // Expose text encoding/decoding streams
    globalThis.TextEncoderStream = TextEncoderStream;
    globalThis.TextDecoderStream = TextDecoderStream;

    // Expose identity/fixed-length streams
    globalThis.IdentityTransformStream = IdentityTransformStream;
    globalThis.FixedLengthStream = FixedLengthStream;

    // Expose fetch API
    globalThis.fetch = fetch;

    // Expose WebSocket and EventSource APIs
    globalThis.WebSocket = WebSocket;
    globalThis.EventSource = EventSource;

    // Expose Encoding APIs
    globalThis.atob = atob;
    globalThis.btoa = btoa;

    // Expose Blob and FormData APIs
    globalThis.Blob = Blob;
    globalThis.File = File;
    globalThis.FormData = FormData;

    // Expose HTML Rewriter
    globalThis.HTMLRewriter = HTMLRewriter;

    // Expose MessageChannel APIs
    globalThis.MessageChannel = MessageChannel;
    globalThis.MessagePort = MessagePort;

    // Expose AbortController for fetch
    globalThis.AbortController = AbortController;
    globalThis.AbortSignal = AbortSignal;

    // Expose Node.js APIs
    globalThis.fs = fs;
    globalThis.Buffer = Buffer;
    globalThis.Writable = Writable;
    globalThis.Readable = Readable;
    globalThis.Transform = Transform;
    globalThis.EventEmitter = EventEmitter;
    globalThis.StringDecoder = StringDecoder;

    // Expose testing APIs
    globalThis.ok = ok;
    globalThis.match = match;
    globalThis.rejects = rejects;
    globalThis.throws = throws;
    globalThis.strictEqual = strictEqual;
    globalThis.deepStrictEqual = deepStrictEqual;
    globalThis.notStrictEqual = notStrictEqual;
    globalThis.mock = mock;

    // Mock Cloudflare APIs for fuzzing
    globalThis.MOCK_KV = {
      get: (key, options) =>
        Promise.resolve(
          options?.type === 'json' ? { test: 'value' } : 'test-value'
        ),
      put: (key, value, options) => Promise.resolve(),
      delete: (key) => Promise.resolve(),
      list: (options) =>
        Promise.resolve({ keys: [{ name: 'key1' }], list_complete: true }),
    };

    globalThis.MOCK_D1 = {
      prepare: (query) => ({
        bind: (...params) => ({
          first: () => Promise.resolve({ id: 1, name: 'test' }),
          all: () => Promise.resolve({ results: [{ id: 1 }], meta: {} }),
          run: () => Promise.resolve({ success: true, meta: { changes: 1 } }),
        }),
      }),
      batch: (stmts) => Promise.resolve(stmts.map(() => ({ success: true }))),
    };

    globalThis.MOCK_R2 = {
      get: (key) =>
        Promise.resolve({
          body: new ReadableStream(),
          text: () => Promise.resolve('content'),
          json: () => Promise.resolve({ data: 'test' }),
          arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
        }),
      put: (key, value, options) => Promise.resolve({ etag: 'test-etag' }),
      delete: (keys) =>
        Promise.resolve({
          deleted: Array.isArray(keys)
            ? keys.map((k) => ({ key: k }))
            : [{ key: keys }],
        }),
      list: (options) =>
        Promise.resolve({ objects: [{ key: 'test.txt', size: 100 }] }),
    };

    // Enter the REPRL loop
    Stdin.reprl();
  },
};