var url = require('url');
var math = require('mathjs');
var request = require('request');
var xml = require("xml2js").parseString;
var winston = require('winston');

var logger;
var config;
var callbackReport;
var aaa;

var max_retry = 15;
var sleep_before_retry = 60 * 1000;

process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';

function parseSN(message, _config) {
    
    if (!_config) {
        _config = config;
    }
    
    var sn_regex = new RegExp(_config.h2h_out.sn_pattern);
    var sn_match = message.match(sn_regex);
        
    if (sn_match <= 0) {
        logger.info('SN Not found: ' + message);
        return '';
    }
    
    var sn = sn_match[0];
    var sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator);
    
    var count = sn_remove_patterns.length;
    
    for(var i = 0; i < count; i++) {
        sn = sn.replace(sn_remove_patterns[i], '');
    }
    
    return sn.trim();
}

function topupRequest(task, retry) {
    /*
    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);
    }
    */
    
    
    if (retry === undefined) {
        retry = max_retry;
    }
    
    var params = {
        userid: config.h2h_out.userid,
        pwd: config.h2h_out.password,
        memberreff: task['requestId'],
        produk: task['remoteProduct'],
        tujuan: task['destination']
    };
    logger.info('Creating http request to gateway', {params: params});
    
    request.post({url: config.h2h_out.partner, form: params}, function(err, httpResponse, httpResponseBody) {
        
        /*
        config.globals.active_requests_count--;
        */

        if (err) {
            logger.warn('HTTP Request Error (' + task['requestId'] + '): ' + err);
            
            callbackReport(task['requestId'], '91', 'Gangguan koneksi ke suplier. ' + err);
            return;
        }
        
        logger.verbose('Got response from gateway ', {response_body: httpResponseBody});
        
        if (httpResponseBody.indexOf('502 Proxy Error') >= 0) {
            logger.warn('Proxy error', {task: task, params: params});
            callbackReport(task['requestId'], '91', '502 Proxy error');
            return;
        }
        
        xml(httpResponseBody, function(err, result) {
            if (err) {
                logger.warn('Gagal parsing XML respon server', {task: task, params: params});
                //topupRequest(task, retry - 1);
                callbackReport(task['requestId'], '40', 'Gagal parsing XML pada respon server');
                return;
            } 
            
            logger.info('Response Data:', {result: result});
            
            var message = result.respon.pesan[0].replace(/\n/g, ' ');
            
            var response_code = '68';
            try {
                response_code = result.respon.response_code[0].replace(/^00/, '');
            } 
            catch(rc_error_on_parse) {
                
                logger.warn('respon.response_code tidak terdefinisi, gunakan respon.rc');
                response_code = result.respon.rc[0].replace(/^00/, '');
                
            }
            
            if (response_code == '54' || response_code == '68') {
                logger.warn('Mendapat status pending / suspect', {task: task, params: params});
                if (retry) {
                    callbackReport(task['requestId'], '68', message + '. Sistem akan mengirim advise dalam waktu ' + sleep_before_retry + ' ms.');
                    
                    setTimeout(function() {
                        
                        logger.info('Sending advice', {task: task});
                        
                        task['remoteProduct'] = 'ADVPLN';
                        topupRequest(task, retry - 1);
                        
                    }, sleep_before_retry);
                    
                } else {
                    logger.warn('Max retries exceeded', {task: task});
                    callbackReport(task['requestId'], '40', message + '. Max retries exceeded');
                }
                return;
            }
            
            var token = '';
            if (result.respon.token) {
                token = result.respon.token[0];
            }
            
            var data_pelanggan = 'NO-DATA';
            if (result.respon.data) {
                
                try {
                    var _data_pelanggan = result.respon.data[0].replace(/ /g, '-');
                    var fields = _data_pelanggan.split('/');
                    
                    data_pelanggan = [
                        fields[0], fields[1], fields[2], fields[3]
                    ].join('/');
                }
                catch(err) {
                    logger.warn('Error parsing data pelanggan', {data_pelanggan: _data_pelanggan});
                }
                
                
            }
            
            if (response_code == '00') {
                
                var sn = "";
                
                if (config.h2h_out.parse_sn == 'YES') {                    
                    sn = parseSN(message);
                } else if (token && data_pelanggan) {
                    sn = token + '/' + data_pelanggan;
                }
                
                message = 'SN=' + sn + '; ' + message;
            }
            
            callbackReport(task['requestId'], response_code, message);
        
        });
    });
}

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)()
            ]
        });
    }
}

function parseResult(message) {
    var data;
    xml(message, function(err, result) {
        data = result;
    });
    return data;
}

exports.start = start;
exports.topupRequest = topupRequest;
exports.parseResult = parseResult;
exports.parseSN = parseSN;