const cloneWithFallback = <T>(value: T, seen = new WeakMap<object, unknown>()): T => {
  if (value === null || typeof value !== "object") {
    return value;
  }

  if (value instanceof Date) {
    return new Date(value.getTime()) as T;
  }

  if (value instanceof RegExp) {
    return new RegExp(value.source, value.flags) as T;
  }

  if (value instanceof Blob) {
    return value.slice(0, value.size, value.type) as T;
  }

  if (value instanceof ArrayBuffer) {
    return value.slice(0) as T;
  }

  if (ArrayBuffer.isView(value)) {
    if (value instanceof DataView) {
      return new DataView(value.buffer.slice(0), value.byteOffset, value.byteLength) as T;
    }

    const typedArray = value as unknown as {
      constructor: new (
        buffer: ArrayBuffer,
        byteOffset: number,
        length?: number
      ) => unknown;
      buffer: ArrayBuffer;
      byteOffset: number;
      length: number;
    };
    return new typedArray.constructor(
      typedArray.buffer.slice(0),
      typedArray.byteOffset,
      typedArray.length
    ) as T;
  }

  const objectValue = value as unknown as object;
  const cached = seen.get(objectValue);
  if (cached) {
    return cached as T;
  }

  if (Array.isArray(value)) {
    const output: unknown[] = [];
    seen.set(objectValue, output);
    for (let index = 0; index < value.length; index += 1) {
      output[index] = cloneWithFallback(value[index], seen);
    }
    return output as T;
  }

  if (value instanceof Map) {
    const output = new Map<unknown, unknown>();
    seen.set(objectValue, output);
    value.forEach((mapValue, key) => {
      output.set(cloneWithFallback(key, seen), cloneWithFallback(mapValue, seen));
    });
    return output as T;
  }

  if (value instanceof Set) {
    const output = new Set<unknown>();
    seen.set(objectValue, output);
    value.forEach((entry) => {
      output.add(cloneWithFallback(entry, seen));
    });
    return output as T;
  }

  const output = Object.create(Object.getPrototypeOf(value)) as Record<string, unknown>;
  seen.set(objectValue, output);
  for (const key of Reflect.ownKeys(value)) {
    const descriptor = Object.getOwnPropertyDescriptor(value, key);
    if (!descriptor) {
      continue;
    }

    if ("value" in descriptor) {
      descriptor.value = cloneWithFallback(descriptor.value, seen);
    }
    Object.defineProperty(output, key, descriptor);
  }

  return output as T;
};

if (typeof (globalThis as { structuredClone?: unknown }).structuredClone !== "function") {
  Object.defineProperty(globalThis, "structuredClone", {
    configurable: true,
    writable: true,
    value: cloneWithFallback,
  });
}

require("fake-indexeddb/auto");

class MockAudioWorkletNode {
  public port = {
    onmessage: null as ((event: { data: Float32Array }) => void) | null,
    postMessage: jest.fn(),
    close: jest.fn(),
  };

  constructor(
    public readonly context: AudioContext,
    public readonly name: string
  ) {}
}

class MockAudioContext {
  public readonly audioWorklet = {
    addModule: jest.fn().mockResolvedValue(undefined),
  };

  public readonly createMediaStreamSource = jest.fn(() => ({
    connect: jest.fn(),
    disconnect: jest.fn(),
  }));

  public state: AudioContextState = "running";
  public readonly suspend = jest.fn().mockImplementation(async () => {
    this.state = "suspended";
  });
  public readonly close = jest.fn().mockResolvedValue(undefined);

  constructor(public readonly options?: { sampleRate?: number }) {}
}

Object.defineProperty(global, "AudioContext", {
  value: MockAudioContext,
  writable: true,
});

Object.defineProperty(global, "AudioWorkletNode", {
  value: MockAudioWorkletNode,
  writable: true,
});

Object.defineProperty(global.URL, "createObjectURL", {
  value: jest.fn(() => "blob:mock"),
  writable: true,
});

Object.defineProperty(global.URL, "revokeObjectURL", {
  value: jest.fn(),
  writable: true,
});

Object.defineProperty(global.navigator, "mediaDevices", {
  value: {
    getUserMedia: jest.fn(),
  },
  configurable: true,
});

// fake-indexeddb/auto provides indexedDB + IDBKeyRange globals for Dexie-based tests.