const MODULE_NAME = 'KOMODO-SDK-PUSH-TRX.SERVER';

const config = require('komodo-sdk/config');
const logger = require('tektrans-logger');

const { createServer } = require('http');
const { WebSocketServer } = require('ws');
const uniqid = require('uniqid');

const packageJson = require('./package.json');

const defaultValues = require('./lib/default-values');
const isValidApikey = require('./lib/is-valid-apikey');
const rejectConnection = require('./lib/server/reject-connection');
const heartbeatPing = require('./lib/heartbeat-ping');
const onPing = require('./lib/on-ping');
const onPong = require('./lib/on-pong');

const PING_INTERVAL_MS = defaultValues.pingIntervalMs;

const server = createServer();

let partner;

exports.setPartner = (partnerFromCaller) => {
    logger.verbose(`${MODULE_NAME} D56C3427: Partner set`);
    partner = partnerFromCaller;
};

const wsListenPort = config.push_trx_server
    && (config.push_trx_server.port || config.push_trx_server.listen_port);

const initServer = () => {
    const pushTrxSdkVersion = packageJson.version;
    logger.verbose(`${MODULE_NAME} 70D208B2: Initializing`, { pushTrxSdkVersion });

    const wss = new WebSocketServer({ noServer: true, perMessageDeflate: true });

    wss.on('connection', (ws, req, client) => {
        // eslint-disable-next-line no-param-reassign
        ws.isAlive = true;

        const {
            xid: connectionXid,
            remoteAddress,
            apikey,
            apikeyName,
        } = client;

        logger.info(`${MODULE_NAME} F7755A03: Client connected`, {
            xid: connectionXid || uniqid(),
            client,
        });

        const heatbeatPingInterval = setInterval(() => {
            heartbeatPing(ws);
        }, PING_INTERVAL_MS);

        ws.on('ping', (data) => onPing(ws, data));
        ws.on('pong', (data) => onPong(ws, data));

        ws.on('close', (code, reason) => {
            const xid = uniqid();

            logger.verbose(`${MODULE_NAME} AB48F13F: Client disconnected`, {
                xid,
                remoteAddress,
                apikeyName,
                apikey,
                code,
                reason: reason.toString(),
            });

            logger.verbose(`${MODULE_NAME} 151CE8C0: Clearing ping interval`, {
                xid,
            });
            clearInterval(heatbeatPingInterval);
        });

        ws.on('message', (data) => {
            const xid = uniqid();

            // eslint-disable-next-line no-param-reassign
            ws.isAlive = true;

            let msg;
            try {
                msg = JSON.parse(data.toString() || '');
            } catch (e) {
                msg = data.toString();
            }

            if (!msg) return;

            const msgType = ((msg && (msg.type || msg.msgType)) || '').toUpperCase();

            logger.verbose(`${MODULE_NAME} 72D2A702: Got a message`, {
                xid,
                apikeyName,
                // apikey,
                msgType,
                msg,
                msgSize: data.toString().length,
            });

            if (msgType === 'TASK') {
                const task = msg.payload;
                if (!task) {
                    logger.verbose(`${MODULE_NAME} 79D6A683: Missing TASK data`, { xid, msg });
                    return;
                }

                logger.verbose(`${MODULE_NAME} 7FFFF91D: Got a task`, {
                    xid,
                    task,
                });

                const sdkTrxIdAdder = Number(config.sdk_trx_id_adder);
                if (sdkTrxIdAdder) {
                    const newTrxId = Number(task.trx_id) + sdkTrxIdAdder;

                    logger.verbose(`${MODULE_NAME} 6E6E200D: Fix trx_id because of config.sdk_trx_id_adder`, {
                        xid,
                        sdkTrxIdAdder,
                        originalTrxId: task.trx_id,
                        newTrxId,
                    });

                    task.trx_id = newTrxId;
                }

                const replyMessage = {
                    type: 'ACK',
                    rid: msg.rid || null,
                    ts: new Date(),
                    error: false,
                };

                ws.send(JSON.stringify(replyMessage), { compress: true });

                if (!partner || !partner.buy || (typeof partner.buy !== 'function')) {
                    logger.verbose(`${MODULE_NAME} C2136EC3: Missing partner handler`, { xid });
                    return;
                }

                logger.verbose(`${MODULE_NAME} 3D870327: Forwarding task to partner module`, {
                    xid,
                });

                partner.buy(task, xid);
            } else {
                logger.verbose(`${MODULE_NAME} CF88DC54: Unknown message type`, {
                    xid,
                    msgType,
                    msg,
                });
            }
        });

        ws.send(JSON.stringify({
            msgType: 'WELCOMEMSG',
            data: {
                msg: 'bla bla bla',
                pushTrxSdkVersion,
            },
        }));
    });

    server.on('upgrade', (req, socket, head) => {
        const xid = uniqid();

        const apikey = req.headers && (req.headers.apikey || req.headers.token);

        const matchedApikey = isValidApikey(
            apikey,
            config.push_trx_server && config.push_trx_server.apikey,
        );

        if (!matchedApikey) {
            rejectConnection(req, socket);
            return;
        }

        wss.handleUpgrade(req, socket, head, (ws) => {
            const client = {
                xid,
                remoteAddress: req.socket.remoteAddress,
                apikeyName: matchedApikey.name,
                apikey,
            };

            logger.verbose(`${MODULE_NAME} AB8BC2F4: Incoming HTTP connection`, {
                xid,
                headers: req.headers,
                client,
            });

            wss.emit('connection', ws, req, client);
        });
    });

    server.listen(wsListenPort, () => {
        logger.info(`${MODULE_NAME} 367D7DB6: Listening websocket`, { port: wsListenPort });
    });

    // const heatbeatPingInterval = setInterval(() => {
    //     wss.clients.forEach((ws) => {
    //         heartbeatPing(ws);
    //     });
    // }, PING_INTERVAL_MS);

    wss.on('close', () => {
        logger.verbose(`${MODULE_NAME} E973112F: WebSocketServer closed`);
        // clearInterval(heatbeatPingInterval);
    });
};

if (!wsListenPort) {
    logger.info(`${MODULE_NAME} 58ACCE20: Disabling PUSH_TRX_SERVER`, {
        config: {
            push_trx_server: !!config && !!config.push_trx_server && {
                port: !!config.push_trx_server.port,
                listen_port: !!config.push_trx_server.listen_port,
            },
        },
    });
} else {
    initServer();
}