"use strict";

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('komodo-sdk/logger');

let _callback;

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

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

function onRequest(req, res) {
    const method_name = 'onRequest';

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

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

    logger.verbose('Got a request from CORE' {module_name: module_name, method_name: method_name remote_address: 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) {
        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('Forwarding CORE response to partner', _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;

    return data;
}

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

    _callback = cb;

    createHttpServer();
}

function send(partner, msg, params) {
    logger.verbose('Got response from CORE', {partner: partner, msg: msg, params: params});

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


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

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

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

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

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