const qs = require("querystring")
const parse = require("url").parse
// const base64id = require("base64id")
import transports from './transports'
import { EventEmitter } from 'events'
// const EventEmitter = require("events").EventEmitter
import { Socket } from './socket'
// const debug = require("debug")("engine")
const debug = function (...args) { }
// const cookieMod = require("cookie")

// const DEFAULT_WS_ENGINE = require("ws").Server;
import { WebSocketServer } from '../server'
import { Transport } from './transport'
const DEFAULT_WS_ENGINE = WebSocketServer

import { Request } from '../server/request'
import { WebSocketClient } from '../server/client'

export class Server extends EventEmitter {
    public static errors = {
        UNKNOWN_TRANSPORT: 0,
        UNKNOWN_SID: 1,
        BAD_HANDSHAKE_METHOD: 2,
        BAD_REQUEST: 3,
        FORBIDDEN: 4,
        UNSUPPORTED_PROTOCOL_VERSION: 5
    }

    public static errorMessages = {
        0: "Transport unknown",
        1: "Session ID unknown",
        2: "Bad handshake method",
        3: "Bad request",
        4: "Forbidden",
        5: "Unsupported protocol version"
    }

    private clients = {}
    private clientsCount = 0
    public opts: any

    private corsMiddleware: any

    private ws: any
    private perMessageDeflate: any

    constructor(opts: any = {}) {
        super()
        this.opts = Object.assign(
            {
                wsEngine: DEFAULT_WS_ENGINE,
                pingTimeout: 20000,
                pingInterval: 25000,
                upgradeTimeout: 10000,
                maxHttpBufferSize: 1e6,
                transports: Object.keys(transports),
                allowUpgrades: true,
                httpCompression: {
                    threshold: 1024
                },
                cors: false,
                allowEIO3: false
            },
            opts
        )

        // if (opts.cookie) {
        //     this.opts.cookie = Object.assign(
        //         {
        //             name: "io",
        //             path: "/",
        //             httpOnly: opts.cookie.path !== false,
        //             sameSite: "lax"
        //         },
        //         opts.cookie
        //     )
        // }

        // if (this.opts.cors) {
        //     this.corsMiddleware = require("cors")(this.opts.cors)
        // }

        // if (opts.perMessageDeflate) {
        //     this.opts.perMessageDeflate = Object.assign(
        //         {
        //             threshold: 1024
        //         },
        //         opts.perMessageDeflate
        //     )
        // }

        // this.init()
    }

    // /**
    //  * Initialize websocket server
    //  *
    //  * @api private
    //  */
    // init() {
    //     if (!~this.opts.transports.indexOf("websocket")) return

    //     if (this.ws) this.ws.close()

    //     this.ws = new this.opts.wsEngine({
    //         noServer: true,
    //         clientTracking: false,
    //         perMessageDeflate: this.opts.perMessageDeflate,
    //         maxPayload: this.opts.maxHttpBufferSize
    //     })

    //     if (typeof this.ws.on === "function") {
    //         this.ws.on("headers", (headersArray, req) => {
    //             // note: 'ws' uses an array of headers, while Engine.IO uses an object (response.writeHead() accepts both formats)
    //             // we could also try to parse the array and then sync the values, but that will be error-prone
    //             const additionalHeaders = {}

    //             const isInitialRequest = !req._query.sid
    //             if (isInitialRequest) {
    //                 this.emit("initial_headers", additionalHeaders, req)
    //             }

    //             this.emit("headers", additionalHeaders, req)

    //             Object.keys(additionalHeaders).forEach(key => {
    //                 headersArray.push(`${key}: ${additionalHeaders[key]}`)
    //             })
    //         })
    //     }
    // }

    /**
     * Returns a list of available transports for upgrade given a certain transport.
     *
     * @return {Array}
     * @api public
     */
    upgrades(transport): Array<any> {
        if (!this.opts.allowUpgrades) return []
        return transports[transport].upgradesTo || []
    }

    // /**
    //  * Verifies a request.
    //  *
    //  * @param {http.IncomingMessage}
    //  * @return {Boolean} whether the request is valid
    //  * @api private
    //  */
    // verify(req, upgrade, fn) {
    //     // transport check
    //     const transport = req._query.transport
    //     if (!~this.opts.transports.indexOf(transport)) {
    //         debug('unknown transport "%s"', transport)
    //         return fn(Server.errors.UNKNOWN_TRANSPORT, { transport })
    //     }

    //     // 'Origin' header check
    //     const isOriginInvalid = checkInvalidHeaderChar(req.headers.origin)
    //     if (isOriginInvalid) {
    //         const origin = req.headers.origin
    //         req.headers.origin = null
    //         debug("origin header invalid")
    //         return fn(Server.errors.BAD_REQUEST, {
    //             name: "INVALID_ORIGIN",
    //             origin
    //         })
    //     }

    //     // sid check
    //     const sid = req._query.sid
    //     if (sid) {
    //         if (!this.clients.hasOwnProperty(sid)) {
    //             debug('unknown sid "%s"', sid)
    //             return fn(Server.errors.UNKNOWN_SID, {
    //                 sid
    //             })
    //         }
    //         const previousTransport = this.clients[sid].transport.name
    //         if (!upgrade && previousTransport !== transport) {
    //             debug("bad request: unexpected transport without upgrade")
    //             return fn(Server.errors.BAD_REQUEST, {
    //                 name: "TRANSPORT_MISMATCH",
    //                 transport,
    //                 previousTransport
    //             })
    //         }
    //     } else {
    //         // handshake is GET only
    //         if ("GET" !== req.method) {
    //             return fn(Server.errors.BAD_HANDSHAKE_METHOD, {
    //                 method: req.method
    //             })
    //         }

    //         if (!this.opts.allowRequest) return fn()

    //         return this.opts.allowRequest(req, (message, success) => {
    //             if (!success) {
    //                 return fn(Server.errors.FORBIDDEN, {
    //                     message
    //                 })
    //             }
    //             fn()
    //         })
    //     }

    //     fn()
    // }

    /**
     * Prepares a request by processing the query string.
     *
     * @api private
     */
    prepare(req) {
        // try to leverage pre-existing `req._query` (e.g: from connect)
        if (!req._query) {
            req._query = ~req.url.indexOf("?") ? qs.parse(parse(req.url).query) : {}
        }
    }

    /**
     * Closes all clients.
     *
     * @api public
     */
    close() {
        debug("closing all open clients")
        for (let i in this.clients) {
            if (this.clients.hasOwnProperty(i)) {
                this.clients[i].close(true)
            }
        }
        if (this.ws) {
            debug("closing webSocketServer")
            this.ws.close()
            // don't delete this.ws because it can be used again if the http server starts listening again
        }
        return this
    }

    // /**
    //  * Handles an Engine.IO HTTP request.
    //  *
    //  * @param {http.IncomingMessage} request
    //  * @param {http.ServerResponse|http.OutgoingMessage} response
    //  * @api public
    //  */
    // handleRequest(req, res) {
    //     debug('handling "%s" http request "%s"', req.method, req.url)
    //     this.prepare(req)
    //     req.res = res

    //     const callback = (errorCode, errorContext) => {
    //         if (errorCode !== undefined) {
    //             this.emit("connection_error", {
    //                 req,
    //                 code: errorCode,
    //                 message: Server.errorMessages[errorCode],
    //                 context: errorContext
    //             })
    //             abortRequest(res, errorCode, errorContext)
    //             return
    //         }

    //         if (req._query.sid) {
    //             debug("setting new request for existing client")
    //             this.clients[req._query.sid].transport.onRequest(req)
    //         } else {
    //             const closeConnection = (errorCode, errorContext) =>
    //                 abortRequest(res, errorCode, errorContext)
    //             this.handshake(req._query.transport, req, closeConnection)
    //         }
    //     }

    //     if (this.corsMiddleware) {
    //         this.corsMiddleware.call(null, req, res, () => {
    //             this.verify(req, false, callback)
    //         })
    //     } else {
    //         this.verify(req, false, callback)
    //     }
    // }

    /**
     * generate a socket id.
     * Overwrite this method to generate your custom socket id
     *
     * @param {Object} request object
     * @api public
     */
    generateId(req) {
        return req.id
    }

    /**
     * Handshakes a new client.
     *
     * @param {String} transport name
     * @param {Object} request object
     * @param {Function} closeConnection
     *
     * @api private
     */
    // @java-patch sync handshake
    handshake(transportName, req, closeConnection: (code: number) => void) {
        console.debug('engine.io server handshake transport', transportName, 'from', req.url)
        const protocol = req._query.EIO === "4" ? 4 : 3 // 3rd revision by default
        if (protocol === 3 && !this.opts.allowEIO3) {
            debug("unsupported protocol version")
            this.emit("connection_error", {
                req,
                code: Server.errors.UNSUPPORTED_PROTOCOL_VERSION,
                message:
                    Server.errorMessages[Server.errors.UNSUPPORTED_PROTOCOL_VERSION],
                context: {
                    protocol
                }
            })
            closeConnection(Server.errors.UNSUPPORTED_PROTOCOL_VERSION)
            return
        }

        let id
        try {
            id = this.generateId(req)
        } catch (e) {
            console.debug("error while generating an id")
            this.emit("connection_error", {
                req,
                code: Server.errors.BAD_REQUEST,
                message: Server.errorMessages[Server.errors.BAD_REQUEST],
                context: {
                    name: "ID_GENERATION_ERROR",
                    error: e
                }
            })
            closeConnection(Server.errors.BAD_REQUEST)
            return
        }

        console.debug('engine.io server handshaking client "' + id + '"')

        try {
            var transport: Transport = new transports[transportName](req)
            if ("websocket" !== transportName) {
                throw new Error('Unsupport polling at MiaoScript!')
            }
            // if ("polling" === transportName) {
            //     transport.maxHttpBufferSize = this.opts.maxHttpBufferSize
            //     transport.httpCompression = this.opts.httpCompression
            // } else if ("websocket" === transportName) {
            transport.perMessageDeflate = this.opts.perMessageDeflate
            // }

            if (req._query && req._query.b64) {
                transport.supportsBinary = false
            } else {
                transport.supportsBinary = true
            }
        } catch (e) {
            console.ex(e)
            this.emit("connection_error", {
                req,
                code: Server.errors.BAD_REQUEST,
                message: Server.errorMessages[Server.errors.BAD_REQUEST],
                context: {
                    name: "TRANSPORT_HANDSHAKE_ERROR",
                    error: e
                }
            })
            closeConnection(Server.errors.BAD_REQUEST)
            return
        }
        console.debug(`engine.io server create socket ${id} from transport ${transport.name} protocol ${protocol}`)
        const socket = new Socket(id, this, transport, req, protocol)

        transport.on("headers", (headers, req) => {
            const isInitialRequest = !req._query.sid

            if (isInitialRequest) {
                if (this.opts.cookie) {
                    headers["Set-Cookie"] = [
                        // cookieMod.serialize(this.opts.cookie.name, id, this.opts.cookie)
                    ]
                }
                this.emit("initial_headers", headers, req)
            }
            this.emit("headers", headers, req)
        })

        transport.onRequest(req)

        this.clients[id] = socket
        this.clientsCount++

        socket.once("close", () => {
            delete this.clients[id]
            this.clientsCount--
        })
        this.emit("connection", socket)
    }

    // /**
    //  * Handles an Engine.IO HTTP Upgrade.
    //  *
    //  * @api public
    //  */
    // handleUpgrade(req, socket, upgradeHead) {
    //     this.prepare(req)

    //     this.verify(req, true, (errorCode, errorContext) => {
    //         if (errorCode) {
    //             this.emit("connection_error", {
    //                 req,
    //                 code: errorCode,
    //                 message: Server.errorMessages[errorCode],
    //                 context: errorContext
    //             })
    //             abortUpgrade(socket, errorCode, errorContext)
    //             return
    //         }

    //         const head = Buffer.from(upgradeHead) // eslint-disable-line node/no-deprecated-api
    //         upgradeHead = null

    //         // delegate to ws
    //         this.ws.handleUpgrade(req, socket, head, websocket => {
    //             this.onWebSocket(req, socket, websocket)
    //         })
    //     })
    // }

    /**
     * Called upon a ws.io connection.
     *
     * @param {ws.Socket} websocket
     * @api private
     */
    onWebSocket(req: Request, socket, websocket: WebSocketClient) {
        websocket.on("error", onUpgradeError)

        if (
            transports[req._query.transport] !== undefined &&
            !transports[req._query.transport].prototype.handlesUpgrades
        ) {
            console.debug("transport doesnt handle upgraded requests")
            websocket.close()
            return
        }

        // get client id
        const id = req._query.sid

        // keep a reference to the ws.Socket
        req.websocket = websocket

        if (id) {
            const client = this.clients[id]
            if (!client) {
                console.debug("upgrade attempt for closed client")
                websocket.close()
            } else if (client.upgrading) {
                console.debug("transport has already been trying to upgrade")
                websocket.close()
            } else if (client.upgraded) {
                console.debug("transport had already been upgraded")
                websocket.close()
            } else {
                console.debug("upgrading existing transport")

                // transport error handling takes over
                websocket.removeListener("error", onUpgradeError)

                const transport = new transports[req._query.transport](req)
                if (req._query && req._query.b64) {
                    transport.supportsBinary = false
                } else {
                    transport.supportsBinary = true
                }
                transport.perMessageDeflate = this.perMessageDeflate
                client.maybeUpgrade(transport)
            }
        } else {
            // transport error handling takes over
            websocket.removeListener("error", onUpgradeError)

            // const closeConnection = (errorCode, errorContext) =>
            //     abortUpgrade(socket, errorCode, errorContext)
            this.handshake(req._query.transport, req, () => { })
        }

        function onUpgradeError() {
            console.debug("websocket error before upgrade")
            // websocket.close() not needed
        }
    }

    /**
     * Captures upgrade requests for a http.Server.
     *
     * @param {http.Server} server
     * @param {Object} options
     * @api public
     */
    attach(server, options: any = {}) {
        // let path = (options.path || "/engine.io").replace(/\/$/, "")

        // const destroyUpgradeTimeout = options.destroyUpgradeTimeout || 1000

        // // normalize path
        // path += "/"

        // function check(req) {
        //     return path === req.url.substr(0, path.length)
        // }

        // cache and clean up listeners
        // const listeners = server.listeners("request").slice(0)
        // server.removeAllListeners("request")
        server.on("close", this.close.bind(this))
        // server.on("listening", this.init.bind(this))
        // @java-patch transfer to Netty Server
        server.on("connect", (request: Request, websocket: WebSocketClient) => {
            console.debug('Engine.IO connect client from', request.url)
            this.prepare(request)
            this.onWebSocket(request, undefined, websocket)
        })
        // set server as ws server
        this.ws = server

        // // add request handler
        // server.on("request", (req, res) => {
        //     if (check(req)) {
        //         debug('intercepting request for path "%s"', path)
        //         this.handleRequest(req, res)
        //     } else {
        //         let i = 0
        //         const l = listeners.length
        //         for (; i < l; i++) {
        //             listeners[i].call(server, req, res)
        //         }
        //     }
        // })

        // if (~this.opts.transports.indexOf("websocket")) {
        //     server.on("upgrade", (req, socket, head) => {
        //         if (check(req)) {
        //             this.handleUpgrade(req, socket, head)
        //         } else if (false !== options.destroyUpgrade) {
        //             // default node behavior is to disconnect when no handlers
        //             // but by adding a handler, we prevent that
        //             // and if no eio thing handles the upgrade
        //             // then the socket needs to die!
        //             setTimeout(function () {
        //                 if (socket.writable && socket.bytesWritten <= 0) {
        //                     return socket.end()
        //                 }
        //             }, destroyUpgradeTimeout)
        //         }
        //     })
        // }
    }
}

// /**
//  * Close the HTTP long-polling request
//  *
//  * @param res - the response object
//  * @param errorCode - the error code
//  * @param errorContext - additional error context
//  *
//  * @api private
//  */

// function abortRequest(res, errorCode, errorContext) {
//     const statusCode = errorCode === Server.errors.FORBIDDEN ? 403 : 400
//     const message =
//         errorContext && errorContext.message
//             ? errorContext.message
//             : Server.errorMessages[errorCode]

//     res.writeHead(statusCode, { "Content-Type": "application/json" })
//     res.end(
//         JSON.stringify({
//             code: errorCode,
//             message
//         })
//     )
// }

// /**
//  * Close the WebSocket connection
//  *
//  * @param {net.Socket} socket
//  * @param {string} errorCode - the error code
//  * @param {object} errorContext - additional error context
//  *
//  * @api private
//  */

// function abortUpgrade(socket, errorCode, errorContext: any = {}) {
//     socket.on("error", () => {
//         debug("ignoring error from closed connection")
//     })
//     if (socket.writable) {
//         const message = errorContext.message || Server.errorMessages[errorCode]
//         const length = Buffer.byteLength(message)
//         socket.write(
//             "HTTP/1.1 400 Bad Request\r\n" +
//             "Connection: close\r\n" +
//             "Content-type: text/html\r\n" +
//             "Content-Length: " +
//             length +
//             "\r\n" +
//             "\r\n" +
//             message
//         )
//     }
//     socket.destroy()
// }

// module.exports = Server

/* eslint-disable */

// /**
//  * From https://github.com/nodejs/node/blob/v8.4.0/lib/_http_common.js#L303-L354
//  *
//  * True if val contains an invalid field-vchar
//  *  field-value    = *( field-content / obs-fold )
//  *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
//  *  field-vchar    = VCHAR / obs-text
//  *
//  * checkInvalidHeaderChar() is currently designed to be inlinable by v8,
//  * so take care when making changes to the implementation so that the source
//  * code size does not exceed v8's default max_inlined_source_size setting.
//  **/
// // prettier-ignore
// const validHdrChars = [
//     0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 - 15
//     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 - 47
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 - 63
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 95
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 - 127
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 ...
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
//     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  // ... 255
// ]

// function checkInvalidHeaderChar(val) {
//     val += ""
//     if (val.length < 1) return false
//     if (!validHdrChars[val.charCodeAt(0)]) {
//         debug('invalid header, index 0, char "%s"', val.charCodeAt(0))
//         return true
//     }
//     if (val.length < 2) return false
//     if (!validHdrChars[val.charCodeAt(1)]) {
//         debug('invalid header, index 1, char "%s"', val.charCodeAt(1))
//         return true
//     }
//     if (val.length < 3) return false
//     if (!validHdrChars[val.charCodeAt(2)]) {
//         debug('invalid header, index 2, char "%s"', val.charCodeAt(2))
//         return true
//     }
//     if (val.length < 4) return false
//     if (!validHdrChars[val.charCodeAt(3)]) {
//         debug('invalid header, index 3, char "%s"', val.charCodeAt(3))
//         return true
//     }
//     for (let i = 4; i < val.length; ++i) {
//         if (!validHdrChars[val.charCodeAt(i)]) {
//             debug('invalid header, index "%i", char "%s"', i, val.charCodeAt(i))
//             return true
//         }
//     }
//     return false
// }