var fs = require('fs');
var https = require('https');
var http = require('http');
var url = require('url');
var request = require('request');
var xml2js = require('xml2js').parseString;
var strftime = require('strftime');
var math = require('mathjs');
var winston = require('winston');

var config;
var httpServer;
var aaa;
var logger;

process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';

var sleep_before_retry = 12000;

var logTag = __filename.split('/').reverse()[0];

function topupRequest(task) {
    if (config.globals.requests_count == undefined) {
        config.globals.requests_count = 1;
    } else {
        config.globals.requests_count++;
    }
    
    if (config.globals.active_requests_count == undefined) {
        config.globals.active_requests_count = 1;
    } else {
        config.globals.active_requests_count++;
    }
    
    if (config.globals.max_active_requests_count == undefined) {
        config.globals.max_active_requests_count = config.globals.active_requests_count;
    } else {
        config.globals.max_active_requests_count = math.max(config.globals.max_active_requests_count, config.globals.active_requests_count);
    }
    
    var ts = strftime('%Y%m%d%H%M%S', new Date());
    
    var data = 
        config.h2h_out.userid 
        + '|' + config.h2h_out.password 
        + '|' + task['remoteProduct'] 
        + '|' + task['destination'] + '|0';
    
    var options = {
        url: config.h2h_out.partner,
        qs: {
            ts: ts,
            data: data,
            reffid: task['requestId']
        }
    };
    logger.info('Creating http request', {options: options});

    request(options, function (error, response, body) {
        if (config.globals.active_requests_count == undefined) {
            config.globals.active_requests_count = 0;
        } else {
            config.globals.active_requests_count--;
        }
        
        var responseCode = '40';
        var responseMessage = 'Gateway Error';

        if (error) {
            
            logger.warn('HTTP REQUEST ERROR', error);
            callbackReport(task['requestId'], '89', 'HTTP REQUEST ERROR (' + error + ')');
            
        } else if (response.statusCode != 200) {
            
            var error_message = 'GATEWAY ERROR (HTTP RESPONSE CODE: ' + response.statusCode + ')';
            logger.warn(error_message);
            callbackReport(task['requestId'], '91', error_message);
            
        } else {

            logger.info('DIRECT RESPONSE', {body: body});

            xml2js(body, function (err, result) {
                if (err) {
                    callbackReport(task['requestId'], '40', body);
                } else {
                    var directResponse = result;
                    logger.info(directResponse);
                    
                    try {
                        var result_price;
                        try {
                            result_price = directResponse.Result.Price[0].trim();
                        }
                        catch(err) {
                            result_price = 0;
                        }
                        
                        var result_error_message;
                        try {
                            result_error_message = directResponse.Result.ErrorMsg[0].trim();
                        }
                        catch(err) {
                            result_error_message = '';
                        }
                        
                        var resultCode = directResponse.Result.ResultCode[0].trim();
                        
                        responseMessage = 
                            'ResultCode: ' + resultCode
                            + ' | ErrorMsg: ' + result_error_message
                            + ' | DateTime: ' + directResponse.Result.DateTime[0].trim()
                            + ' | nsm: ' + directResponse.Result.nsm[0].trim()
                            + ' | idpel: ' + directResponse.Result.idpel[0].trim()
                            + ' | reff_switching: ' + directResponse.Result.reff_switching[0].trim()
                            + ' | amount_trx: ' + directResponse.Result.amount_trx[0].trim()
                            + ' | token: ' + directResponse.Result.token[0].trim()
                            + ' | PrevBalance: ' + directResponse.Result.PrevBalance[0].trim()
                            + ' | Price: ' + result_price
                            + ' | EndBalance: ' + directResponse.Result.EndBalance[0].trim()
                            ;
                            
                        logger.info('Response message: ' + responseMessage);
                        
                        if (aaa) {
                            // update balance
                            aaa.updateBalance(directResponse.Result.EndBalance[0]);
                        }
                        
                        if (resultCode == '0000') {
                            var sn = directResponse.Result.token[0].trim() + '/' + directResponse.Result.nama_pel[0].trim() + '/' + directResponse.Result.tarif[0].trim() + '/' + directResponse.Result.daya[0].trim() + 'VA/' + directResponse.Result.jml_daya[0].trim();
                            sn = sn.replace(/\s/g, '-');
                            
                            responseMessage = 'SN=' + sn + '; ' + responseMessage;
                            logger.info('New response message: ' + responseMessage);
                        }
                        
                        var pendingResultCode = ['0005', '0012', '0068', '0090', '0063', '0018', '0096'];
                        if (pendingResultCode.indexOf(resultCode) != -1) {
                            callbackReport(task['requestId'], '68', responseMessage);
                            setTimeout(function () {
                                logger.info('Got pending status, requesting in ' + sleep_before_retry + 'ms');
                                topupRequest(task);
                            }, sleep_before_retry);
                            return;
                        }
                        
                        responseCode = resultCode.replace(/^00/, "");
                        
                        if (result_error_message == 'Inq - APLICATION SERVER RESPONSE TIMEOUT') {
                            responseCode = '91';
                        }                        
                        
                    }
                    catch(err) {
                        responseCode = '40';
                        responseMessage = 'Invalid response from gateway';
                    }
                }
                
                callbackReport(task['requestId'], responseCode, responseMessage);
            });
        }

        //callbackReport(task['requestId'], responseCode, responseMessage);
    });
}

function createHttpReportServer() {
    var httpServer = http.createServer(function(request, response) {
        var qs = url.parse(request.url, true).query;
        logger.info('Got reverse report from partner', {qs: qs});
    });
    
    httpServer.listen(config.h2h_out.listen_port, function() {
        logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port);
    });
}

function start(_config, _callbackReport, options) {
    config = _config;
    callbackReport = _callbackReport;
    
    if (options && options.aaa) {
            aaa = options.aaa;
    }
    
    if (options && options.logger) {
        logger = options.logger;
    } else {
        logger = new winston.Logger({
            transports: [
              new (winston.transports.Console)()
            ]
        });
    }
    
    createHttpReportServer();
}

exports.start = start;
exports.topupRequest = topupRequest;