/// <reference types="node" />

import * as events from "events";
import * as http from "http";
import * as https from "https";
import * as net from "net";

declare class WebSocket extends events.EventEmitter {
    static CONNECTING: number;
    static OPEN: number;
    static CLOSING: number;
    static CLOSED: number;

    bytesReceived: number;
    readyState: number;
    protocolVersion: string;
    url: string;
    supports: any;
    upgradeReq: http.IncomingMessage;
    protocol: string;

    CONNECTING: number;
    OPEN: number;
    CLOSING: number;
    CLOSED: number;

    onopen: (event: { target: WebSocket }) => void;
    onerror: (err: Error) => void;
    onclose: (event: { wasClean: boolean; code: number; reason: string; target: WebSocket }) => void;
    onmessage: (event: { data: any; type: string; target: WebSocket }) => void;

    constructor(address: string, options?: WebSocket.IClientOptions);
    constructor(address: string, protocols?: string | string[], options?: WebSocket.IClientOptions);

    close(code?: number, data?: any): void;
    pause(): void;
    resume(): void;
    ping(data?: any, options?: { mask?: boolean | undefined; binary?: boolean | undefined }, dontFail?: boolean): void;
    pong(data?: any, options?: { mask?: boolean | undefined; binary?: boolean | undefined }, dontFail?: boolean): void;
    send(data: any, cb?: (err: Error) => void): void;
    send(
        data: any,
        options: { mask?: boolean | undefined; binary?: boolean | undefined },
        cb?: (err: Error) => void,
    ): void;
    stream(
        options: { mask?: boolean | undefined; binary?: boolean | undefined },
        cb?: (err: Error, final: boolean) => void,
    ): void;
    stream(cb?: (err: Error, final: boolean) => void): void;
    terminate(): void;

    // HTML5 WebSocket events
    addEventListener(method: "message", cb?: (event: { data: any; type: string; target: WebSocket }) => void): void;
    addEventListener(
        method: "close",
        cb?: (event: {
            wasClean: boolean;
            code: number;
            reason: string;
            target: WebSocket;
        }) => void,
    ): void;
    addEventListener(method: "error", cb?: (err: Error) => void): void;
    addEventListener(method: "open", cb?: (event: { target: WebSocket }) => void): void;
    addEventListener(method: string, listener?: (...args: any[]) => void): void;

    // Events
    on(event: "error", cb: (this: this, err: Error) => void): this;
    on(event: "close", cb: (this: this, code: number, message: string) => void): this;
    on(event: "message", cb: (this: this, data: any, flags: { binary: boolean }) => void): this;
    on(event: "ping", cb: (this: this, data: any, flags: { binary: boolean }) => void): this;
    on(event: "pong", cb: (this: this, data: any, flags: { binary: boolean }) => void): this;
    on(event: "open", cb: (this: this) => void): this;
    on(event: string, listener: (this: this, ...args: any[]) => void): this;

    addListener(event: "error", cb: (err: Error) => void): this;
    addListener(event: "close", cb: (code: number, message: string) => void): this;
    addListener(event: "message", cb: (data: any, flags: { binary: boolean }) => void): this;
    addListener(event: "ping", cb: (data: any, flags: { binary: boolean }) => void): this;
    addListener(event: "pong", cb: (data: any, flags: { binary: boolean }) => void): this;
    addListener(event: "open", cb: () => void): this;
    addListener(event: string, listener: (...args: any[]) => void): this;
}

declare namespace WebSocket {
    type VerifyClientCallbackSync = (info: { origin: string; secure: boolean; req: http.IncomingMessage }) => boolean;
    type VerifyClientCallbackAsync = (
        info: { origin: string; secure: boolean; req: http.IncomingMessage },
        callback: (res: boolean) => void,
    ) => void;

    export interface IClientOptions {
        protocol?: string | undefined;
        agent?: http.Agent | undefined;
        headers?: { [key: string]: string } | undefined;
        protocolVersion?: any;
        host?: string | undefined;
        origin?: string | undefined;
        pfx?: any;
        key?: any;
        passphrase?: string | undefined;
        cert?: any;
        ca?: any[] | undefined;
        ciphers?: string | undefined;
        rejectUnauthorized?: boolean | undefined;
    }

    export interface IPerMessageDeflateOptions {
        serverNoContextTakeover?: boolean | undefined;
        clientNoContextTakeover?: boolean | undefined;
        serverMaxWindowBits?: number | undefined;
        clientMaxWindowBits?: number | undefined;
        memLevel?: number | undefined;
    }

    export interface IPerMessageDeflateOptions {
        serverNoContextTakeover?: boolean | undefined;
        clientNoContextTakeover?: boolean | undefined;
        serverMaxWindowBits?: number | undefined;
        clientMaxWindowBits?: number | undefined;
        memLevel?: number | undefined;
    }

    export interface IServerOptions {
        host?: string | undefined;
        port?: number | undefined;
        server?: http.Server | https.Server | undefined;
        verifyClient?: VerifyClientCallbackAsync | VerifyClientCallbackSync | undefined;
        handleProtocols?: any;
        path?: string | undefined;
        noServer?: boolean | undefined;
        disableHixie?: boolean | undefined;
        clientTracking?: boolean | undefined;
        perMessageDeflate?: boolean | IPerMessageDeflateOptions | undefined;
    }

    export class Server extends events.EventEmitter {
        options: IServerOptions;
        path: string;
        clients: WebSocket[];

        constructor(options?: IServerOptions, callback?: Function);

        close(cb?: (err?: any) => void): void;
        handleUpgrade(
            request: http.IncomingMessage,
            socket: net.Socket,
            upgradeHead: ArrayBuffer,
            callback: (client: WebSocket) => void,
        ): void;

        // Events
        on(event: "error", cb: (err: Error) => void): this;
        on(event: "headers", cb: (headers: string[]) => void): this;
        on(event: "connection", cb: (this: WebSocket, client: WebSocket) => void): this;
        on(event: string, listener: (...args: any[]) => void): this;

        addListener(event: "error", cb: (err: Error) => void): this;
        addListener(event: "headers", cb: (headers: string[]) => void): this;
        addListener(event: "connection", cb: (client: WebSocket) => void): this;
        addListener(event: string, listener: (...args: any[]) => void): this;
    }

    export interface UwsHttp {
        createServer(
            requestListener?: (request: http.IncomingMessage, response: http.ServerResponse) => void,
        ): http.Server;
        // any to avoid express definitions
        getExpressApp(express: any): any;
        getResponsePrototype(): http.ServerResponse;
        getRequestPrototype(): http.IncomingMessage;
    }

    export const http: UwsHttp;

    export function createServer(options?: IServerOptions, connectionListener?: (client: WebSocket) => void): Server;
    export function connect(address: string, openListener?: Function): void;
    export function createConnection(address: string, openListener?: Function): void;
}

export = WebSocket;