var winston = require('winston');
var request = require('request');
var strftime = require('strftime');
var crypto = require('crypto');
var redis = require('redis');
var mongoClient = require('mongodb').MongoClient;

var config;
var callbackReport;
var aaa;
var logger;
var options;
var redisClient;
var mongodb;

var adviceDelay = 10000;


function initMongoClient() {
    if (!config.mongodbstruk || !config.mongodbstruk.url) {
        return;
    }

    try {
        var url = config.mongodbstruk.url;

        mongoClient.connect(url, function(err, db) {
            if (err) {
                logger.warn('Failed to connect to mongodb(struk)', {err: err});
                return;
            }
            mongodb = db;
            logger.info('MongoDB connected(struk)');
        });
    }
    catch(err) {
        logger.warn('Exception when connecting to mongodb(struk)', {err: err, url: url});
    }

}

function createRedisClient() {
    redisClient = redis.createClient(config.globals.redis_port, config.globals.redis_host);
}

function start(options) {
    if (!options) {
        console.log('Undefined options, terminating....');
        process.exit(1);
    }

    if (options.config) {
        config = options.config;
    } else {
        console.log('Undefined options.config, terminating....')
        process.exit(1);
    }

    if (options.aaa) {
        aaa = options.aaa;
        callbackReport = options.aaa.callbackReportWithPushToMongoDb;
    } else {
        console.log('Undefined options.aaa, terminating....')
        process.exit(1);
    }

    if (options && options.logger) {
        logger = options.logger;
    } else {
        logger = new winston.Logger({
            transports: [
              new (winston.transports.Console)()
            ]
        });
    }

    createRedisClient();
    initMongoClient();
}

function getRedisKey(task) {
    return config.globals.gateway_name + '.tid:' + task.requestId;
}

function putTaskToRedis(task) {
    var redisKey = getRedisKey(task);
    var taskInJSON = JSON.stringify(task);

    redisClient.set(redisKey, taskInJSON);
    redisClient.expire(redisKey, 3600*24*7);
}

function topupRequest(task, retry) {
    aaa.insertTaskToMongoDb(task);

    var redisKey = getRedisKey(task);

    redisClient.get(redisKey, function(err, result) {
        if (err || !result) {

            //logger.info('Redis error or not found', {redisKey: redisKey, error: err, result: result});
            putTaskToRedis(task);
            autoPay(task);

        } else {
            advice(task);
        }
    });
}

function calculateSignature(cid, secret, dt) {
    return crypto.createHash('sha256').update(cid + dt + secret).digest().toString('hex');
}

function parsePaymentResponse(message) {
    var data = message.split('#');
    var retval = {};

    if (data[0] == 'ERROR') {

        retval = {
            status: data[0],
            rc: data[1],
            rcmessage: data[2],
        }

    }
    else {

        var i = 0;
        retval = {
            status: data[i++],
            rcmessage: data[i++],
            resptext: data[i++],
            dt: data[i++]
        }

        try {
            retval.namapel = data[i++].trim();
            retval.msn = data[i++];
            retval.idpel = data[i++];
            retval.tarifdaya = data[i++];
            retval.hargapelanggan = data[i++];
            retval.jumlahkwh = data[i++];
            retval.token = data[i++];
            retval.ppn = data[i++];
            retval.ppj = data[i++];
            retval.adm = data[i++];
            retval.angsuran = data[i++];
            retval.meterai = data[i++];
        }
        catch(e) {
            logger.warn('Exception on parsePaymentResponse', {err: e, msg: message, retval: retval, stack: new Error().stack});
        }

        try {
            retval.tarif = retval.tarifdaya.split('/')[0];
        }
        catch (e) {
            retval.tarif = retval.tarifdaya;
        }

        try {
            retval.daya = retval.tarifdaya.split('/')[1];
        }
        catch (e) {
            retval.daya = retval.tarifdaya;
        }

    }

    return retval;
}

function generateSN(response) {
    return [
        response.token,
        response.namapel.replace(/\W+/g, '-').replace(/-+$/, ''),
        response.tarif, response.daya + 'VA',
        response.jumlahkwh
    ].join('/');
}

function reportPaymentSuccess(task, response, rawResponse) {
    var message = 'SN=' + generateSN(response) + ';' + response.rcmessage;

    logger.info('Report payment success to ST24', {task: task, response: response});

    saveTokenToRedis(response);
    saveTokenToMongoDb(response);

    var responseObject;
    if (rawResponse) {
        responseObject = {
            raw: rawResponse,
            parsed: response
        }

        responseObject.parsed.MESSAGE = message;
    }


    callbackReport(task['requestId'], '00', message, null, responseObject);
}

function saveTokenToRedis(response) {
    try {
        var token = response.token.replace(/\W/g, "");
        var redisKey = 'TOKENPLN.token:' + token;

        logger.info('Saving ' + redisKey + ' to redis', {redisKey: redisKey, response: response});

        redisClient.set(redisKey, JSON.stringify(response));
        redisClient.expire(redisKey, 3600*24*30);
    }
    catch(err) {
        return;
    }
}

function saveTokenToMongoDb(response) {
    if (!mongodb) {
        return;
    }

    if (!config.mongodbstruk) {
        return;
    }

    if (!config.mongodbstruk.collection) {
        return;
    }

    try {
        mongodb.collection(config.mongodbstruk.collection).insertOne(response);
    }
    catch(err) {
        logger.warn('Error inserting document to mongodb', {mongodbErr: err, response: response});
    }
}

function reportPaymentError(task, response, rawResponse) {
    var errorCode = getErrorCode(response.rcmessage);
    var st24rc = getST24ResponseCode(errorCode);

    if (response.rcmessage.indexOf('TRANSAKSI GAGAL') >= 0) {
    	st24rc = '40';
    }
    else if (response.rcmessage.indexOf('TRANSAKSI TIDAK DITEMUKAN') >= 0) {
    	st24rc = '40';
    }
    else if (response.rcmessage.indexOf('TRANSAKSI TIDAK BISA DILAKUKAN SAAT INI SILAHKAN COBA BEBERAPA SAAT LAGI') >= 0) {
    	st24rc= '40';
    }

    if (st24rc == '68') {
        logger.info('Got pending response, requesting advice in ' + adviceDelay + 'ms', {task: task, response: response});
        setTimeout(advice, adviceDelay, task);
    }

    logger.info('Report payment error/pending to ST24', {supplier_rc: errorCode, st24_rc: st24rc, task: task, response: response});

    var responseObject;
    if (rawResponse) {
        responseObject = {
            raw: rawResponse,
            parsed: response
        }

        responseObject.parsed.MESSAGE = response.rcmessage;
    }

    callbackReport(
        task['requestId'],
        st24rc,
        response.rcmessage,
        null,
        responseObject
    );
}

function getST24ResponseCode(supplierResponseCode) {
    var st24rc = '40';

    if (supplierResponseCode.length == 1) {
        supplierResponseCode = '0' + supplierResponseCode;
    }

    if (['00', '13', '14', '47', '68'].indexOf(supplierResponseCode) >= 0) {
        st24rc = supplierResponseCode;
    }
    else if (supplierResponseCode == '15') {
        st24rc = '14';
    }
    else if (['05', '18', '63', '68'].indexOf(supplierResponseCode) >= 0) {
        st24rc = '68';
    }
    else if (supplierResponseCode == '67') {
        st24rc = '91'
    }
    else if (supplierResponseCode == '46') {
        st24rc = '40'

        if (aaa && config && config.globals && config.globals.pause_on_not_enough_balance
            && (config.globals.pause_on_not_enough_balance == '1')) {

            logger.warn('Not enough balance detected. Going to pause the system.');
            aaa.pause();
        }
    }

    return st24rc;
}

function getErrorCode(rcmessage) {
    try {
        var errorCode = rcmessage.match(/\[(\d+)\]/);
        return errorCode[1];
    }
    catch(err) {
        logger.warn('Empty RCMESSAGE, returning 68 as RC for safety');
        return '68';
    }
}

function generateDt(taskTimestamp) {
    if (!taskTimestamp) {
        return strftime('%Y%m%d', new Date());
    }

    return taskTimestamp.slice(0, 8);
}

function generateRequestOptions(userid, password, partnerUrl, task) {
    var dt = generateDt(task.timestamp);
    var sign = calculateSignature(userid, password, dt);

    var requestOptions = {
        method: 'GET',
        url: partnerUrl,
        qs: {
            modul: '',
            command: '',
            msn: task['destination'],
            nominal: task['remoteProduct'],
            cid: userid,
            dt: dt,
            hc: sign,
            trxid: task['requestId'],
        }
    }

    return requestOptions;
}

function advice(task, retry) {

    if (retry === null || retry === undefined) {
        retry = 10;
    }

    var requestOptions = generateRequestOptions(config.h2h_out.userid, config.h2h_out.password, config.h2h_out.partner, task);

    requestOptions.qs.modul = 'PRE';
    requestOptions.qs.command = 'ADV';

    logger.info('Requesting advice to supplier', {requestOptions: requestOptions});
    request(requestOptions, function(requestError, requestResponse, requestResponseBody) {
        if (requestError || requestResponse.statusCode != 200) {

            var httpStatusCode = null;
            try {
                httpStatusCode = requestResponse.statusCode;
            }
            catch(e) {};

            logger.warn('Advice error', {error: requestError, http_status_code: httpStatusCode});

            if (retry > 0) {
                logger.warn('Going to retry advice in ' + adviceDelay + 'ms', {task: task, retry: retry});
                setTimeout(advice, adviceDelay, task, --retry);
            }

            return;
        }

        var paymentResponse = parsePaymentResponse(requestResponseBody);
        logger.info('Got advice payment response', {paymentResponse: paymentResponse});

        if (paymentResponse.status == 'SUCCESS') {
            reportPaymentSuccess(task, paymentResponse, requestResponseBody);
        }
        else {
            reportPaymentError(task, paymentResponse, requestResponseBody);
        }
    });

}

function autoPay(task) {
    var requestOptions = generateRequestOptions(config.h2h_out.userid, config.h2h_out.password, config.h2h_out.partner, task);

    requestOptions.qs.modul = 'PRE';
    requestOptions.qs.command = 'PAY';

    logger.info('Requesting auto payment to supplier', {requestOptions: requestOptions});
    request(requestOptions, function(requestError, requestResponse, requestResponseBody) {
        if (requestError) {
            logger.warn('Request error', {error: requestError});

            setTimeout(advice, adviceDelay, task);
            return;
        }

        if (requestResponse.statusCode != 200) {
            logger.warn('HTTP response status code is not 200', {http_response: requestResponse.statusCode});

            setTimeout(advice, adviceDelay, task);
            return;
        }

        logger.info('Supplier response: ' + requestResponseBody);

        var paymentResponse = parsePaymentResponse(requestResponseBody);
        logger.info('Got payment response', {paymentResponse: paymentResponse});

        if (paymentResponse.status == 'SUCCESS') {
            reportPaymentSuccess(task, paymentResponse, requestResponseBody);
        }
        else {
            reportPaymentError(task, paymentResponse, requestResponseBody);
        }
    });
}

exports.start = start;
exports.topupRequest = topupRequest;
exports.calculateSignature = calculateSignature;
exports.parsePaymentResponse = parsePaymentResponse;
exports.getErrorCode = getErrorCode;
exports.getST24ResponseCode = getST24ResponseCode;
exports.generateSN = generateSN;
exports.generateDt = generateDt;