// import http = require("http");
// import type { Server as HTTPSServer } from "https";
// import type { Http2SecureServer } from "http2";
// import { createReadStream } from "fs";
// import { createDeflate, createGzip, createBrotliCompress } from "zlib";
// import accepts = require("accepts");
// import { pipeline } from "stream";
// import path = require("path");
import {
  attach,
  Server as Engine,
  ServerOptions as EngineOptions,
  AttachOptions,
  //   uServer,
} from "../engine.io";
import { Client } from "./client";
import { EventEmitter } from "events";
import { ExtendedError, Namespace, ServerReservedEventsMap } from "./namespace";
import { ParentNamespace } from "./parent-namespace";
import {
  Adapter,
  SessionAwareAdapter,
  Room,
  SocketId,
} from "../socket.io-adapter";
import * as parser from "../socket.io-parser";
import type { Encoder } from "../socket.io-parser";
// import debugModule from "debug"
import { Socket, DisconnectReason } from "./socket";
import type { BroadcastOperator, RemoteSocket } from "./broadcast-operator";
import {
  EventsMap,
  DefaultEventsMap,
  EventParams,
  StrictEventEmitter,
  EventNames,
  DecorateAcknowledgementsWithTimeoutAndMultipleResponses,
  AllButLast,
  Last,
  FirstArg,
  SecondArg,
} from "./typed-events";
// import { patchAdapter, restoreAdapter, serveFile } from "./uws"
import type { BaseServer } from "../engine.io/server";

const debug = require("../debug")("socket.io:server");

// const clientVersion = require("../package.json").version
// const dotMapRegex = /\.map/

type ParentNspNameMatchFn = (
  name: string,
  auth: { [key: string]: any },
  fn: (err: Error | null, success: boolean) => void
) => void;

type AdapterConstructor = typeof Adapter | ((nsp: Namespace) => Adapter);

interface ServerOptions extends EngineOptions, AttachOptions {
  /**
   * name of the path to capture
   * @default "/socket.io"
   */
  path: string;
  /**
   * whether to serve the client files
   * @default true
   */
  serveClient: boolean;
  /**
   * the adapter to use
   * @default the in-memory adapter (https://github.com/socketio/socket.io-adapter)
   */
  // adapter: AdapterConstructor
  adapter: any;
  /**
   * the parser to use
   * @default the default parser (https://github.com/socketio/socket.io-parser)
   */
  parser: any;
  /**
   * how many ms before a client without namespace is closed
   * @default 45000
   */
  connectTimeout: number;
  /**
   * Whether to enable the recovery of connection state when a client temporarily disconnects.
   *
   * The connection state includes the missed packets, the rooms the socket was in and the `data` attribute.
   */
  connectionStateRecovery: {
    /**
     * The backup duration of the sessions and the packets.
     *
     * @default 120000 (2 minutes)
     */
    maxDisconnectionDuration?: number;
    /**
     * Whether to skip middlewares upon successful connection state recovery.
     *
     * @default true
     */
    skipMiddlewares?: boolean;
  };
  /**
   * Whether to remove child namespaces that have no sockets connected to them
   * @default false
   */
  cleanupEmptyChildNamespaces: boolean;
}

/**
 * Represents a Socket.IO server.
 *
 * @example
 * import { Server } from "socket.io";
 *
 * const io = new Server();
 *
 * io.on("connection", (socket) => {
 *   console.log(`socket ${socket.id} connected`);
 *
 *   // send an event to the client
 *   socket.emit("foo", "bar");
 *
 *   socket.on("foobar", () => {
 *     // an event was received from the client
 *   });
 *
 *   // upon disconnection
 *   socket.on("disconnect", (reason) => {
 *     console.log(`socket ${socket.id} disconnected due to ${reason}`);
 *   });
 * });
 *
 * io.listen(3000);
 */
export class Server<
  ListenEvents extends EventsMap = DefaultEventsMap,
  EmitEvents extends EventsMap = ListenEvents,
  ServerSideEvents extends EventsMap = DefaultEventsMap,
  SocketData = any
> extends StrictEventEmitter<
  ServerSideEvents,
  EmitEvents,
  ServerReservedEventsMap<
    ListenEvents,
    EmitEvents,
    ServerSideEvents,
    SocketData
  >
> {
  public readonly sockets: Namespace<
    ListenEvents,
    EmitEvents,
    ServerSideEvents,
    SocketData
  >;
  /**
   * A reference to the underlying Engine.IO server.
   *
   * @example
   * const clientsCount = io.engine.clientsCount;
   *
   */
  public engine: BaseServer;

  /** @private */
  readonly _parser: typeof parser;
  /** @private */
  readonly encoder: Encoder;

  /**
   * @private
   */
  _nsps: Map<
    string,
    Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
  > = new Map();
  private parentNsps: Map<
    ParentNspNameMatchFn,
    ParentNamespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
  > = new Map();
  private _adapter?: AdapterConstructor;
  private _serveClient: boolean;
  private readonly opts: Partial<ServerOptions>;
  private eio: Engine;
  private _path: string;
  private clientPathRegex: RegExp;

  /**
   * @private
   */
  _connectTimeout: number;
  // private httpServer: http.Server | HTTPSServer | Http2SecureServer

  /**
   * Server constructor.
   *
   * @param srv http server, port, or options
   * @param [opts]
   */
  constructor(opts?: Partial<ServerOptions>);
  constructor(
    srv?: any /* http.Server | HTTPSServer | Http2SecureServer | number */,
    opts?: Partial<ServerOptions>
  );
  constructor(
    srv: // | undefined
    // | Partial<ServerOptions>
    // | http.Server
    // | HTTPSServer
    // | Http2SecureServer
    // | number,
    any,
    opts?: Partial<ServerOptions>
  );
  constructor(
    srv: // | undefined
    // | Partial<ServerOptions>
    // | http.Server
    // | HTTPSServer
    // | Http2SecureServer
    // | number,
    any,
    opts: Partial<ServerOptions> = {}
  ) {
    super();
    // if (
    //     "object" === typeof srv &&
    //     srv instanceof Object &&
    //     !(srv as Partial<http.Server>).listen
    // ) {
    //     opts = srv as Partial<ServerOptions>
    //     srv = undefined
    // }
    this.path(opts.path || "/socket.io");
    this.connectTimeout(opts.connectTimeout || 45000);
    this.serveClient(false !== opts.serveClient);
    this._parser = opts.parser || parser;
    this.encoder = new this._parser.Encoder();
    this.opts = opts;
    if (opts.connectionStateRecovery) {
      opts.connectionStateRecovery = Object.assign(
        {
          maxDisconnectionDuration: 2 * 60 * 1000,
          skipMiddlewares: true,
        },
        opts.connectionStateRecovery
      );
      this.adapter(opts.adapter || SessionAwareAdapter);
    } else {
      this.adapter(opts.adapter || Adapter);
    }
    opts.cleanupEmptyChildNamespaces = !!opts.cleanupEmptyChildNamespaces;
    this.sockets = this.of("/");
    // if (srv || typeof srv == "number")
    this.attach(
      srv /**as http.Server | HTTPSServer | Http2SecureServer | number */,
      this.opts
    );
  }

  get _opts() {
    return this.opts;
  }

  /**
   * Sets/gets whether client code is being served.
   *
   * @param v - whether to serve client code
   * @return self when setting or value when getting
   */
  public serveClient(v: boolean): this;
  public serveClient(): boolean;
  public serveClient(v?: boolean): this | boolean;
  public serveClient(v?: boolean): this | boolean {
    if (!arguments.length) return this._serveClient;
    this._serveClient = v!;
    return this;
  }

  /**
   * Executes the middleware for an incoming namespace not already created on the server.
   *
   * @param name - name of incoming namespace
   * @param auth - the auth parameters
   * @param fn - callback
   *
   * @private
   */
  _checkNamespace(
    name: string,
    auth: { [key: string]: any },
    fn: (
      nsp:
        | Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
        | false
    ) => void
  ): void {
    if (this.parentNsps.size === 0) return fn(false);

    const keysIterator = this.parentNsps.keys();

    const run = () => {
      const nextFn = keysIterator.next();
      if (nextFn.done) {
        return fn(false);
      }
      nextFn.value(name, auth, (err, allow) => {
        if (err || !allow) {
          return run();
        }
        if (this._nsps.has(name)) {
          // the namespace was created in the meantime
          debug("dynamic namespace %s already exists", name);
          return fn(this._nsps.get(name) as Namespace);
        }
        const namespace = this.parentNsps.get(nextFn.value)!.createChild(name);
        debug("dynamic namespace %s was created", name);
        // @ts-ignore
        this.sockets.emitReserved("new_namespace", namespace);
        fn(namespace);
      });
    };

    run();
  }

  /**
   * Sets the client serving path.
   *
   * @param {String} v pathname
   * @return {Server|String} self when setting or value when getting
   */
  public path(v: string): this;
  public path(): string;
  public path(v?: string): this | string;
  public path(v?: string): this | string {
    if (!arguments.length) return this._path;

    this._path = v!.replace(/\/$/, "");

    const escapedPath = this._path.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
    this.clientPathRegex = new RegExp(
      "^" +
        escapedPath +
        "/socket\\.io(\\.msgpack|\\.esm)?(\\.min)?\\.js(\\.map)?(?:\\?|$)"
    );
    return this;
  }

  /**
   * Set the delay after which a client without namespace is closed
   * @param v
   */
  public connectTimeout(v: number): this;
  public connectTimeout(): number;
  public connectTimeout(v?: number): this | number;
  public connectTimeout(v?: number): this | number {
    if (v === undefined) return this._connectTimeout;
    this._connectTimeout = v;
    return this;
  }

  /**
   * Sets the adapter for rooms.
   *
   * @param v pathname
   * @return self when setting or value when getting
   */
  public adapter(): AdapterConstructor | undefined;
  public adapter(v: AdapterConstructor): this;
  public adapter(
    v?: AdapterConstructor
  ): AdapterConstructor | undefined | this {
    if (!arguments.length) return this._adapter;
    this._adapter = v;
    for (const nsp of this._nsps.values()) {
      nsp._initAdapter();
    }
    return this;
  }

  /**
   * Attaches socket.io to a server or port.
   *
   * @param srv - server or port
   * @param opts - options passed to engine.io
   * @return self
   */
  public listen(
    srv: any /*http.Server | HTTPSServer | Http2SecureServer | number*/,
    opts: Partial<ServerOptions> = {}
  ): this {
    throw Error("Unsupport listen at MiaoScript Engine!");
  }

  /**
   * Attaches socket.io to a server or port.
   *
   * @param srv - server or port
   * @param opts - options passed to engine.io
   * @return self
   */
  public attach(
    srv: any /*http.Server | HTTPSServer | Http2SecureServer | number*/,
    opts: Partial<ServerOptions> = {}
  ): this {
    // if ("function" == typeof srv) {
    //   const msg =
    //     "You are trying to attach socket.io to an express " +
    //     "request handler function. Please pass a http.Server instance.";
    //   throw new Error(msg);
    // }

    // // handle a port as a string
    // if (Number(srv) == srv) {
    //   srv = Number(srv);
    // }

    // if ("number" == typeof srv) {
    //   debug("creating http server and binding to %d", srv);
    //   const port = srv;
    //   srv = http.createServer((req, res) => {
    //     res.writeHead(404);
    //     res.end();
    //   });
    //   srv.listen(port);
    // }

    // merge the options passed to the Socket.IO server
    Object.assign(opts, this.opts);
    // set engine.io path to `/socket.io`
    opts.path = opts.path || this._path;

    this.initEngine(srv, opts);

    return this;
  }

  // public attachApp(app /*: TemplatedApp */, opts: Partial<ServerOptions> = {}) {
  //   // merge the options passed to the Socket.IO server
  //   Object.assign(opts, this.opts);
  //   // set engine.io path to `/socket.io`
  //   opts.path = opts.path || this._path;

  //   // initialize engine
  //   debug("creating uWebSockets.js-based engine with opts %j", opts);
  //   const engine = new uServer(opts);

  //   engine.attach(app, opts);

  //   // bind to engine events
  //   this.bind(engine);

  //   if (this._serveClient) {
  //     // attach static file serving
  //     app.get(`${this._path}/*`, (res, req) => {
  //       if (!this.clientPathRegex.test(req.getUrl())) {
  //         req.setYield(true);
  //         return;
  //       }

  //       const filename = req
  //         .getUrl()
  //         .replace(this._path, "")
  //         .replace(/\?.*$/, "")
  //         .replace(/^\//, "");
  //       const isMap = dotMapRegex.test(filename);
  //       const type = isMap ? "map" : "source";

  //       // Per the standard, ETags must be quoted:
  //       // https://tools.ietf.org/html/rfc7232#section-2.3
  //       const expectedEtag = '"' + clientVersion + '"';
  //       const weakEtag = "W/" + expectedEtag;

  //       const etag = req.getHeader("if-none-match");
  //       if (etag) {
  //         if (expectedEtag === etag || weakEtag === etag) {
  //           debug("serve client %s 304", type);
  //           res.writeStatus("304 Not Modified");
  //           res.end();
  //           return;
  //         }
  //       }

  //       debug("serve client %s", type);

  //       res.writeHeader("cache-control", "public, max-age=0");
  //       res.writeHeader(
  //         "content-type",
  //         "application/" + (isMap ? "json" : "javascript")
  //       );
  //       res.writeHeader("etag", expectedEtag);

  //       const filepath = path.join(__dirname, "../client-dist/", filename);
  //       serveFile(res, filepath);
  //     });
  //   }

  //   patchAdapter(app);
  // }

  /**
   * Initialize engine
   *
   * @param srv - the server to attach to
   * @param opts - options passed to engine.io
   * @private
   */
  private initEngine(
    srv: any /*http.Server | HTTPSServer | Http2SecureServer | number*/,
    opts: EngineOptions & AttachOptions
  ): void {
    // initialize engine
    debug("creating engine.io instance with opts %j", opts);
    this.eio = attach(srv, opts);

    // // attach static file serving
    // if (this._serveClient) this.attachServe(srv);

    // // Export http server
    // this.httpServer = srv;

    // bind to engine events
    this.bind(this.eio);
  }

  // /**
  //  * Attaches the static file serving.
  //  *
  //  * @param srv http server
  //  * @private
  //  */
  // private attachServe(
  //   srv: http.Server | HTTPSServer | Http2SecureServer
  // ): void {
  //   debug("attaching client serving req handler");

  //   const evs = srv.listeners("request").slice(0);
  //   srv.removeAllListeners("request");
  //   srv.on("request", (req, res) => {
  //     if (this.clientPathRegex.test(req.url!)) {
  //       this.serve(req, res);
  //     } else {
  //       for (let i = 0; i < evs.length; i++) {
  //         evs[i].call(srv, req, res);
  //       }
  //     }
  //   });
  // }

  // /**
  //  * Handles a request serving of client source and map
  //  *
  //  * @param req
  //  * @param res
  //  * @private
  //  */
  // private serve(req: http.IncomingMessage, res: http.ServerResponse): void {
  //   const filename = req.url!.replace(this._path, "").replace(/\?.*$/, "");
  //   const isMap = dotMapRegex.test(filename);
  //   const type = isMap ? "map" : "source";

  //   // Per the standard, ETags must be quoted:
  //   // https://tools.ietf.org/html/rfc7232#section-2.3
  //   const expectedEtag = '"' + clientVersion + '"';
  //   const weakEtag = "W/" + expectedEtag;

  //   const etag = req.headers["if-none-match"];
  //   if (etag) {
  //     if (expectedEtag === etag || weakEtag === etag) {
  //       debug("serve client %s 304", type);
  //       res.writeHead(304);
  //       res.end();
  //       return;
  //     }
  //   }

  //   debug("serve client %s", type);

  //   res.setHeader("Cache-Control", "public, max-age=0");
  //   res.setHeader(
  //     "Content-Type",
  //     "application/" + (isMap ? "json" : "javascript")
  //   );
  //   res.setHeader("ETag", expectedEtag);

  //   Server.sendFile(filename, req, res);
  // }

  // /**
  //  * @param filename
  //  * @param req
  //  * @param res
  //  * @private
  //  */
  // private static sendFile(
  //   filename: string,
  //   req: http.IncomingMessage,
  //   res: http.ServerResponse
  // ): void {
  //   const readStream = createReadStream(
  //     path.join(__dirname, "../client-dist/", filename)
  //   );
  //   const encoding = accepts(req).encodings(["br", "gzip", "deflate"]);

  //   const onError = (err: NodeJS.ErrnoException | null) => {
  //     if (err) {
  //       res.end();
  //     }
  //   };

  //   switch (encoding) {
  //     case "br":
  //       res.writeHead(200, { "content-encoding": "br" });
  //       readStream.pipe(createBrotliCompress()).pipe(res);
  //       pipeline(readStream, createBrotliCompress(), res, onError);
  //       break;
  //     case "gzip":
  //       res.writeHead(200, { "content-encoding": "gzip" });
  //       pipeline(readStream, createGzip(), res, onError);
  //       break;
  //     case "deflate":
  //       res.writeHead(200, { "content-encoding": "deflate" });
  //       pipeline(readStream, createDeflate(), res, onError);
  //       break;
  //     default:
  //       res.writeHead(200);
  //       pipeline(readStream, res, onError);
  //   }
  // }

  /**
   * Binds socket.io to an engine.io instance.
   *
   * @param engine engine.io (or compatible) server
   * @return self
   */
  public bind(engine): this {
    this.engine = engine;
    this.engine.on("connection", this.onconnection.bind(this));
    return this;
  }

  /**
   * Called with each incoming transport connection.
   *
   * @param {engine.Socket} conn
   * @return self
   * @private
   */
  private onconnection(conn): this {
    debug("incoming connection with id %s", conn.id);
    const client = new Client(this, conn);
    if (conn.protocol === 3) {
      // @ts-ignore
      client.connect("/");
    }
    return this;
  }

  /**
   * Looks up a namespace.
   *
   * @example
   * // with a simple string
   * const myNamespace = io.of("/my-namespace");
   *
   * // with a regex
   * const dynamicNsp = io.of(/^\/dynamic-\d+$/).on("connection", (socket) => {
   *   const namespace = socket.nsp; // newNamespace.name === "/dynamic-101"
   *
   *   // broadcast to all clients in the given sub-namespace
   *   namespace.emit("hello");
   * });
   *
   * @param name - nsp name
   * @param fn optional, nsp `connection` ev handler
   */
  public of(
    name: string | RegExp | ParentNspNameMatchFn,
    fn?: (
      socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
    ) => void
  ): Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData> {
    if (typeof name === "function" || name instanceof RegExp) {
      const parentNsp = new ParentNamespace(this);
      debug("initializing parent namespace %s", parentNsp.name);
      if (typeof name === "function") {
        this.parentNsps.set(name, parentNsp);
      } else {
        this.parentNsps.set(
          (nsp, conn, next) => next(null, (name as RegExp).test(nsp)),
          parentNsp
        );
      }
      if (fn) {
        // @ts-ignore
        parentNsp.on("connect", fn);
      }
      return parentNsp;
    }

    if (String(name)[0] !== "/") name = "/" + name;

    let nsp = this._nsps.get(name);
    if (!nsp) {
      debug("initializing namespace %s", name);
      nsp = new Namespace(this, name);
      this._nsps.set(name, nsp);
      if (name !== "/") {
        // @ts-ignore
        this.sockets.emitReserved("new_namespace", nsp);
      }
    }
    if (fn) nsp.on("connect", fn);
    return nsp;
  }

  /**
   * Closes server connection
   *
   * @param [fn] optional, called as `fn([err])` on error OR all conns closed
   */
  public close(fn?: (err?: Error) => void): void {
    for (const socket of this.sockets.sockets.values()) {
      socket._onclose("server shutting down");
    }

    this.engine.close();

    // // restore the Adapter prototype
    // restoreAdapter();

    // if (this.httpServer) {
    //   this.httpServer.close(fn);
    // } else {
    fn && fn();
    // }
  }

  /**
   * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
   *
   * @example
   * io.use((socket, next) => {
   *   // ...
   *   next();
   * });
   *
   * @param fn - the middleware function
   */
  public use(
    fn: (
      socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
      next: (err?: ExtendedError) => void
    ) => void
  ): this {
    this.sockets.use(fn);
    return this;
  }

  /**
   * Targets a room when emitting.
   *
   * @example
   * // the “foo” event will be broadcast to all connected clients in the “room-101” room
   * io.to("room-101").emit("foo", "bar");
   *
   * // with an array of rooms (a client will be notified at most once)
   * io.to(["room-101", "room-102"]).emit("foo", "bar");
   *
   * // with multiple chained calls
   * io.to("room-101").to("room-102").emit("foo", "bar");
   *
   * @param room - a room, or an array of rooms
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public to(room: Room | Room[]) {
    return this.sockets.to(room);
  }

  /**
   * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
   *
   * @example
   * // disconnect all clients in the "room-101" room
   * io.in("room-101").disconnectSockets();
   *
   * @param room - a room, or an array of rooms
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public in(room: Room | Room[]) {
    return this.sockets.in(room);
  }

  /**
   * Excludes a room when emitting.
   *
   * @example
   * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
   * io.except("room-101").emit("foo", "bar");
   *
   * // with an array of rooms
   * io.except(["room-101", "room-102"]).emit("foo", "bar");
   *
   * // with multiple chained calls
   * io.except("room-101").except("room-102").emit("foo", "bar");
   *
   * @param room - a room, or an array of rooms
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public except(room: Room | Room[]) {
    return this.sockets.except(room);
  }

  /**
   * Emits an event and waits for an acknowledgement from all clients.
   *
   * @example
   * try {
   *   const responses = await io.timeout(1000).emitWithAck("some-event");
   *   console.log(responses); // one response per client
   * } catch (e) {
   *   // some clients did not acknowledge the event in the given delay
   * }
   *
   * @return a Promise that will be fulfilled when all clients have acknowledged the event
   */
  public emitWithAck<Ev extends EventNames<EmitEvents>>(
    ev: Ev,
    ...args: AllButLast<EventParams<EmitEvents, Ev>>
  ): Promise<SecondArg<Last<EventParams<EmitEvents, Ev>>>> {
    return this.sockets.emitWithAck(ev, ...args);
  }

  /**
   * Sends a `message` event to all clients.
   *
   * This method mimics the WebSocket.send() method.
   *
   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
   *
   * @example
   * io.send("hello");
   *
   * // this is equivalent to
   * io.emit("message", "hello");
   *
   * @return self
   */
  public send(...args: EventParams<EmitEvents, "message">): this {
    this.sockets.emit("message", ...args);
    return this;
  }

  /**
   * Sends a `message` event to all clients. Alias of {@link send}.
   *
   * @return self
   */
  public write(...args: EventParams<EmitEvents, "message">): this {
    this.sockets.emit("message", ...args);
    return this;
  }

  /**
   * Sends a message to the other Socket.IO servers of the cluster.
   *
   * @example
   * io.serverSideEmit("hello", "world");
   *
   * io.on("hello", (arg1) => {
   *   console.log(arg1); // prints "world"
   * });
   *
   * // acknowledgements (without binary content) are supported too:
   * io.serverSideEmit("ping", (err, responses) => {
   *  if (err) {
   *     // some servers did not acknowledge the event in the given delay
   *   } else {
   *     console.log(responses); // one response per server (except the current one)
   *   }
   * });
   *
   * io.on("ping", (cb) => {
   *   cb("pong");
   * });
   *
   * @param ev - the event name
   * @param args - an array of arguments, which may include an acknowledgement callback at the end
   */
  public serverSideEmit<Ev extends EventNames<ServerSideEvents>>(
    ev: Ev,
    ...args: EventParams<
      DecorateAcknowledgementsWithTimeoutAndMultipleResponses<ServerSideEvents>,
      Ev
    >
  ): boolean {
    return this.sockets.serverSideEmit(ev, ...args);
  }

  /**
   * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
   *
   * @example
   * try {
   *   const responses = await io.serverSideEmitWithAck("ping");
   *   console.log(responses); // one response per server (except the current one)
   * } catch (e) {
   *   // some servers did not acknowledge the event in the given delay
   * }
   *
   * @param ev - the event name
   * @param args - an array of arguments
   *
   * @return a Promise that will be fulfilled when all servers have acknowledged the event
   */
  public serverSideEmitWithAck<Ev extends EventNames<ServerSideEvents>>(
    ev: Ev,
    ...args: AllButLast<EventParams<ServerSideEvents, Ev>>
  ): Promise<FirstArg<Last<EventParams<ServerSideEvents, Ev>>>[]> {
    return this.sockets.serverSideEmitWithAck(ev, ...args);
  }

  /**
   * Gets a list of socket ids.
   *
   * @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or
   * {@link Server#fetchSockets} instead.
   */
  public allSockets(): Promise<Set<SocketId>> {
    return this.sockets.allSockets();
  }

  /**
   * Sets the compress flag.
   *
   * @example
   * io.compress(false).emit("hello");
   *
   * @param compress - if `true`, compresses the sending data
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public compress(compress: boolean) {
    return this.sockets.compress(compress);
  }

  /**
   * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
   * receive messages (because of network slowness or other issues, or because they’re connected through long polling
   * and is in the middle of a request-response cycle).
   *
   * @example
   * io.volatile.emit("hello"); // the clients may or may not receive it
   *
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public get volatile() {
    return this.sockets.volatile;
  }

  /**
   * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
   *
   * @example
   * // the “foo” event will be broadcast to all connected clients on this node
   * io.local.emit("foo", "bar");
   *
   * @return a new {@link BroadcastOperator} instance for chaining
   */
  public get local() {
    return this.sockets.local;
  }

  /**
   * Adds a timeout in milliseconds for the next operation.
   *
   * @example
   * io.timeout(1000).emit("some-event", (err, responses) => {
   *   if (err) {
   *     // some clients did not acknowledge the event in the given delay
   *   } else {
   *     console.log(responses); // one response per client
   *   }
   * });
   *
   * @param timeout
   */
  public timeout(timeout: number) {
    return this.sockets.timeout(timeout);
  }

  /**
   * Returns the matching socket instances.
   *
   * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
   *
   * @example
   * // return all Socket instances
   * const sockets = await io.fetchSockets();
   *
   * // return all Socket instances in the "room1" room
   * const sockets = await io.in("room1").fetchSockets();
   *
   * for (const socket of sockets) {
   *   console.log(socket.id);
   *   console.log(socket.handshake);
   *   console.log(socket.rooms);
   *   console.log(socket.data);
   *
   *   socket.emit("hello");
   *   socket.join("room1");
   *   socket.leave("room2");
   *   socket.disconnect();
   * }
   */
  public fetchSockets(): Promise<RemoteSocket<EmitEvents, SocketData>[]> {
    return this.sockets.fetchSockets();
  }

  /**
   * Makes the matching socket instances join the specified rooms.
   *
   * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
   *
   * @example
   *
   * // make all socket instances join the "room1" room
   * io.socketsJoin("room1");
   *
   * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
   * io.in("room1").socketsJoin(["room2", "room3"]);
   *
   * @param room - a room, or an array of rooms
   */
  public socketsJoin(room: Room | Room[]) {
    return this.sockets.socketsJoin(room);
  }

  /**
   * Makes the matching socket instances leave the specified rooms.
   *
   * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
   *
   * @example
   * // make all socket instances leave the "room1" room
   * io.socketsLeave("room1");
   *
   * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
   * io.in("room1").socketsLeave(["room2", "room3"]);
   *
   * @param room - a room, or an array of rooms
   */
  public socketsLeave(room: Room | Room[]) {
    return this.sockets.socketsLeave(room);
  }

  /**
   * Makes the matching socket instances disconnect.
   *
   * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
   *
   * @example
   * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
   * io.disconnectSockets();
   *
   * // make all socket instances in the "room1" room disconnect and close the underlying connections
   * io.in("room1").disconnectSockets(true);
   *
   * @param close - whether to close the underlying connection
   */
  public disconnectSockets(close: boolean = false) {
    return this.sockets.disconnectSockets(close);
  }
}

/**
 * Expose main namespace (/).
 */

const emitterMethods = Object.keys(EventEmitter.prototype).filter(function (
  key
) {
  return typeof EventEmitter.prototype[key] === "function";
});

emitterMethods.forEach(function (fn) {
  Server.prototype[fn] = function () {
    return this.sockets[fn].apply(this.sockets, arguments);
  };
});

module.exports = (srv?, opts?) => new Server(srv, opts);
module.exports.Server = Server;
module.exports.Namespace = Namespace;
module.exports.Socket = Socket;

export {
  Socket,
  DisconnectReason,
  ServerOptions,
  Namespace,
  BroadcastOperator,
  RemoteSocket,
};
export { Event } from "./socket";