import {
  AbortController,
  AbortSignal,
  CustomEvent,
  DOMException,
  ErrorEvent,
  Event,
  EventTarget,
  installGlobalEventTarget,
  PromiseRejectionEvent,
  reportErrorValue,
  reportException,
  reportRejectionHandled,
  reportUnhandledRejection,
} from "./events.js";
import {
  ObjectDefineProperty as define,
  SymbolFor,
} from "ext:core/primordials";
import { setEventHandlers } from "ext:core/event_hooks";
import { onRuntimeStart } from "ext:core/bootstrap";
import { required } from "./idl.js";
import { atob, btoa } from "./base64.js";
import { navigator, NavigatorUAData, WorkerNavigator } from "./navigator.js";
import { Performance, performance } from "./performance.js";
import { MessageChannel, MessageEvent, MessagePort } from "./messaging.js";
import { BroadcastChannel } from "./broadcast.js";
import { installInterface } from "./interface.js";
for (
  const ctor of [
    DOMException,
    Event,
    CustomEvent,
    ErrorEvent,
    PromiseRejectionEvent,
    MessageEvent,
    MessagePort,
    MessageChannel,
    BroadcastChannel,
    EventTarget,
    AbortSignal,
    AbortController,
    WorkerNavigator,
    NavigatorUAData,
    Performance,
  ]
) installInterface(ctor.name, ctor);

const global = globalThis;
onRuntimeStart(() => {
  // V8 restores a fresh global proxy; its WeakMap brand must be installed live.
  installGlobalEventTarget(global);
  setEventHandlers(
    reportException,
    reportUnhandledRejection,
    reportRejectionHandled,
  );
});
const reportError = (...args: unknown[]): void => {
  required(args.length, 1);
  reportErrorValue(args[0]);
};
define(reportError, "length", { value: 1 });
define(global, "reportError", {
  value: reportError,
  writable: true,
  enumerable: true,
  configurable: true,
});
for (const fn of [atob, btoa]) {
  define(global, fn.name, {
    value: fn,
    writable: true,
    enumerable: true,
    configurable: true,
  });
}
function replaceable(name: string, value: unknown): void {
  define(global, name, {
    get: () => value,
    set: (replacement) =>
      define(global, name, {
        value: replacement,
        writable: true,
        enumerable: true,
        configurable: true,
      }),
    enumerable: true,
    configurable: true,
  });
}
replaceable("self", global);
define(global, SymbolFor("runtime:avril"), {
  value: true,
  writable: false,
  enumerable: false,
  configurable: false,
});
define(global, "navigator", {
  get: () => navigator,
  enumerable: true,
  configurable: true,
});
replaceable("performance", performance);