process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

const module_name = require('path').basename(__filename);

const http = require('http');
const url = require('url');
const request = require('request');

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

let _callback;

const maxSendRetry = Number(config.max_send_retry) || 5;
const sleepBeforeRetryMs = (Number(config.sleep_before_retry_secs) || 60) * 1000;

function sleep(ms) {
    new Promise((resolve) => {
        setTimeout(() => {
            resolve(null);
        }, ms)
    });
};

function createHttpServer() {
    let listenPort = config.center_port;

    http.createServer(onRequestFromPartner).listen(listenPort, function() {
        logger.info('Center HTTP server listen on port ' + listenPort);
    });;
}

function onRequestFromPartner(req, res) {
    const xid = uniqid();

    const method_name = 'onRequestFromPartner';

    let remote_address = req.connection.remoteAddress.replace(/^::ffff:/, '');

    let qs = url.parse(req.url, true).query;

    logger.verbose('Got a request from partner', {
        xid,
        module_name,
        method_name,
        remote_address,
        url: req.url,
        qs: qs
    });

    let partner = qs.terminal_name + '@' + remote_address;
    let password = qs.password;
    let reverse_url = qs.reverse_url;

    let product_name = qs.product_name;
    let destination = qs.destination;
    let request_id = qs.request_id;

    if (!qs.terminal_name || !password || !reverse_url || ! product_name || !destination || !request_id) {
        logger.verbose('Invalid request from partner', {
            xid,
            hasTerminalName: !!qs.terminal_name,
            hasPassword: !!password,
            hasProductName: !!product_name,
            hasDestination: !!hasDestination,
            hasRequestId: !!request_id,

        })
        res.end('INVALID REQUEST');
        return;
    }

    let msg = [ product_name, destination, password, request_id ].join('.');

    _callback.onIncomingMessage(
        {
            me: config.username,
            partner: partner,
            msg: msg.trim(),
            reverse_url: reverse_url
        },

        function(err, _result) {
            let result = cleanResponseToPartner(_result);

            logger.verbose('C2DEEE9D Forwarding CORE response to partner as direct response', {
                xid,
                result: _result
            });

            res.end(JSON.stringify(result));
        }
    )
}

function cleanResponseToPartner(_data) {
    let data = JSON.parse(JSON.stringify(_data));

    delete data.origin;
    delete data.origin_report_ip;
    delete data.origin_report_port;
    delete data.reverse_url;
    delete data.misc;
    delete data.inquiry_only;

    for (let key in data) {

        if (data.hasOwnProperty(key)) {

            if (key.indexOf('[') >= 0) { delete data[key]; }

        }
    }

    return data;
}

function init(cb) {
    if (!cb) {
        logger.warn('Callback is not defined');
        console.trace();
        process.exit(1);
        return;
    }

    _callback = cb;

    createHttpServer();
}

async function sleepAndResend(xid, partner, msg, params, retry) {
    if (retry > maxSendRetry) {
        logger.verbose('Retry exceeded', {
            xid,
            retry: retry || 0,
            params,
        });
        return;
    }

    logger.verbose('Sleep before resend', { xid, sleepBeforeRetryMs });

    await sleep(sleepBeforeRetryMs);
    send(partner, msg, params, retry + 1);
}

function send(partner, msg, params, retry) {
    const xid = uniqid();

    if (retry) {
        logger.verbose('F39C9082: Resending', {
            xid,
            partner,
            msg,
            params,
            retry,
        })
    } else {
        logger.verbose('Got response from CORE', {
            xid,
            partner,
            msg,
            params,
            retried: retry || 0,
        });
    }

    if (!params || !params.reverse_url) {
        logger.verbose('Undefined reverse_url, not forwarding message to partner',  { xid });
        return;
    }

    if (params.reverse_url.indexOf('http') < 0) {
        logger.verbose('Invalid reverse_url, not forwarding message to partner', { xid });
        return;
    }

    if (params.rc === '68') {
        logger.verbose('Ignoring RC 68 reverse report', { xid });
        return;
    }

    let reqOptions = {
        url: params.reverse_url,
        qs: cleanResponseToPartner(params)
    }

    logger.verbose('Sending reverse report to partner', {
        xid,
        request: reqOptions
    });

    request(reqOptions, function(err, res, body) {
        if (err) {
            logger.warn('Error sending reverse report to partner', {
                xid,
                request: reqOptions,
                err: err,
            });

            sleepAndResend(xid, partner, msg, params, retry || 0);
            return;
        }

        /*
        if (res.statusCode != 200) {
            logger.warn('Partner not returning HTTP status code 200 on reverse report', {
                request: reqOptions, http_status: res.statusCode,
            });

            _sleepAndResend(partner, msg, params, retry);
            return;
        }
        */

        logger.verbose('Reverse report has been sent to partner', {
            xid,
            request: reqOptions,
            httpStatus: res && res.statusCode
        });
    })
}

exports.init = init;
exports.send = send;