var pkginfo = require('pkginfo')(module, 'version');
var redis = require('redis');
var moment = require('moment');
var LRU = require('lru-cache');
var CircularBuffer = require('circular-buffer');
var imProbe = require('./im-probe');

var maxRegisterResendDelayRetry = 30;

var matrix;
var config;
var logger;
var aaa;
var callbackReport;
var imConfig;
var redisClient;
var isOnline = false;

var resendHandlers = LRU({max: 2000, maxAge: 1000 * 3600 * 36});
var invalidReplies = new CircularBuffer(10);
var unknownTrx = new CircularBuffer(10);

var keepAliveTimeoutHandler;

function removeResourceFromJid(jid) {
    return jid.replace(/\/.*/, '');
}

function sendKeepAlive() {
    if (!isOnline) {
        sendKeepAliveDelay();
        return;
    }

    var to = '';
    var msg = '';

    if (!config.h2h_out.keepalive_message) {
        to = config.h2h_out.im_username;
        msg = 'PING ' + moment().format('YYYYMMDDHHmmss');
    } else {
        to = getRandomPartnerId();
        msg = createMessage(config.h2h_out.keepalive_message, createReplacementKeywords());
    }

    if (!to) {
        logger.warn('No partners available, aborting send keepalive_message');
        return;
    }

    imAdaptor.sendMessage(to, msg);

    sendKeepAliveDelay();
}

function sendKeepAliveDelay() {
    try {
        clearTimeout(keepAliveTimeoutHandler);
    }
    catch(e) {}

    keepAliveTimeoutHandler = setTimeout(sendKeepAlive, 60 * 1000);
}

function dumpStats() {
    if (config.globals.auto_resend_delay_secs) {
        logger.verbose('DUMP STATS', {
            'resendHandlers:length': resendHandlers.length,
            'resendHandlers:itemCount': resendHandlers.itemCount,
            'resendHandlers:itemCount max': matrix.resend_handlers.cache_item_count_max
        });
    }
}

function dumpStatsPeriodic() {
    var dumpStatsInterval = 1000 * 120;
    if (config.globals.dump_stats_interval_secs) {
        dumpStatsInterval = config.globals.dump_stats_interval_secs * 1000;
    }
    logger.verbose('Dump stats every ' + dumpStatsInterval / 1000 + ' secs (override it with config.globals.dump_stats_interval_secs)');
    setInterval(dumpStats, dumpStatsInterval);
}

function updateMatrixResendHandlersCount() {
    if (!matrix.resend_handlers) {
        matrix.resend_handlers = {
            cache_length: resendHandlers.length,
            cache_item_count: resendHandlers.itemCount,
            cache_item_count_max: 0
        };
    }

    matrix.resend_handlers.cache_item_count_max = Math.max(matrix.resend_handlers.cache_item_count_max, resendHandlers.itemCount);
}

function init(options) {
    if (options && options.config) {
        config = options.config;
    } else {
        console.log(__filename + ': Undefined options.config. Terminating.');
        process.exit(230);
    }

    if (options && options.matrix) {
        matrix = options.matrix;
        updateMatrixResendHandlersCount();
    } else {
        console.log(__filename + ': Undefined options.matrix. Terminating.');
        process.exit(230);
    }

    if (options && options.logger) {
        logger = options.logger;
    } else {
        console.log(__filename + ': Undefined options.logger. Terminating.');
        process.exit(231);
    }

    if (options && options.aaa) {
        aaa = options.aaa;
    } else {
        logger.warn(__filename + ': Undefined options.aaa. Terminating.');
        process.exit(233);
    }

    if (options && options.aaa && options.aaa.callbackReportWithPushToMongoDb) {
        callbackReport = options.aaa.callbackReportWithPushToMongoDb;
    } else {
        logger.warn(__filename + ': Unknown options.aaa.callbackReport')
        process.exit(234);
    }

    if (options && options.imAdaptor) {
        imAdaptor = options.imAdaptor;
    } else {
        logger.warn(__filename + ': Unknown options.imAdaptor')
        process.exit(235);
    }

    var imAdaptorcallbacks = {
        onOnline: onOnline,
        onPM: onPM,
    }

    imAdaptor.init(config.h2h_out.im_username, config.h2h_out.im_password, logger, imAdaptorcallbacks);
    _setImAdaptorOptions();

    createRedisClient(config.globals.redis_host, config.globals.redis_port);
    readImConfig();

    dumpStatsPeriodic();
    sendKeepAliveDelay();
}

function _setImAdaptorOptions() {
    var opts = {};

    if (!imAdaptor.setOptions) {
        logger.warn("Old imAdaptor detected, no setOptions export available");
        return;
    }

    opts.matrix = matrix;

    try {
        imAdaptor.setOptions(opts);
    }
    catch(e) {
        logger.warn("partnerIm._setImAdaptorOptions: Exception when doing imAdaptor.setOptions");
    }
}

function createRedisClient(host, port) {
    try {
        redisClient = redis.createClient(port, host);
    } catch(err) {
        logger.warn("Error creating redis client to " + host + ':' + port);
    }
}

function readImConfig(filename) {

    if (!filename) {
        filename = process.cwd() + '/config.im.json';
    }

    try {
        imConfig = require(filename);
    }
    catch(e) {
        imConfig = {};
        console.log('Error reading ' + filename);
        process.exit(1);
    }

    logger.verbose('IM Config', {imConfig: imConfig});
    return imConfig;
}

function getPatternFromMessage(message, pattern, patternMatchIndex) {
    var re = new RegExp(pattern);
    var matches = message.match(re);

    if (!matches) {
        return null;
    }

    if (patternMatchIndex < matches.length) {
        return matches[patternMatchIndex];
    } else {
        return null;
    }
}

function getPatternsFromMessage(message, patterns) {
    if (!patterns) {
        return;
    }

    var patternCount = patterns.length;
    for (var i = 0; i < patternCount; i++) {

        var pattern = patterns[i];

        var result = getPatternFromMessage(message, pattern.pattern, pattern.matchIndex);
        if (result) {
            return result;
        }
    }
}

function isIgnoreMessage(msg) {
    patterns = imConfig.ignore_patterns;

    if (!patterns) {
        return false;
    }

    var patternCount = 0;
    try {
        patternCount = patterns.length;
    } catch (e) {}

    for (var i=0; i < patternCount; i++) {
        var re = new RegExp(patterns[i]);
        if (msg.search(re) >= 0) {
            return true;
        }
    }

    return false;
}

function getTaskKey(task, chipInfo, today) {
    if (!chipInfo && config && config.globals && config.globals.gateway_name) {
        chipInfo = config.globals.gateway_name;
    }

    if (task.timestamp && !today) {
        today = moment(task.timestamp, 'YYYYMMDDHHmmss').format('YYYYMMDD');
    }

    return chipInfo + '.trx.date:' + today + '.rProduct:' + task.remoteProduct.toUpperCase() + '.dest:' + task.destination ;
}

function saveTask(task, cb) {
    var key = getTaskKey(task, config.globals.gateway_name);
    logger.verbose('Saving task', {key: key, task: task});

    redisClient.set(key, JSON.stringify(task), function() {
        redisClient.expire(key, 3600*24);
        if (cb) {
            cb();
        }
    });
}

function getTask(remoteProduct, destination, cb) {
    _getTask(remoteProduct, destination, function(err, task) {
        if (!task && (destination.indexOf('0') != 0)) {
            _getTask(remoteProduct, '0' + destination, cb);
        } else {
            cb(err, task);
        }
    });
}

function _getTask(remoteProduct, destination, cb) {
    var dummyTask = {
        remoteProduct: remoteProduct,
        destination: destination,
    }

    var key = getTaskKey(dummyTask, config.globals.gateway_name, moment().format('YYYYMMDD'));
    redisClient.get(key, function(err, result) {
        if (err) {
            logger.verbose('getTask: task not found', {key: key, params: dummyTask});

            cb(err, null);
            return;
        }

        var task = {};

        try {
            task = JSON.parse(result);
        }
        catch(e) {
            logger.warn('getTask: Can not parse result', {key: key, params: dummyTask, data: result});
            err = "Can not parse result"
        }
        cb(err, task);
    });
}

function deleteTask(remoteProduct, destination) {
    var dummyTask = {
        remoteProduct: remoteProduct,
        destination: destination,
    }

    var key = getTaskKey(dummyTask, config.globals.gateway_name, moment().format('YYYYMMDD'));

    try {
        redisClient.del(key);
    }
    catch(e) {};
}

function createMessage(pattern, keywords) {
    var msg = pattern;

    for (var key in keywords) {
        msg = msg.replace('[' + key + ']', keywords[key]);
    }
    return msg;
}

function createReplacementKeywords(task) {
    if (!task) {
        task = {};
    }

    return keywords = {
        requestId: task.requestId,
        timestamp: task.timestamp,
        product: task.product,
        remoteProduct: task.remoteProduct,
        destination: task.destination,
        pin: config.h2h_out.pin
    }
}

function getRemoteProductFromMessage(msg) {
    return getPatternsFromMessage(msg, imConfig.product_patterns);
}

function getDestinationFromMessage(msg) {
    return getPatternsFromMessage(msg, imConfig.destination_patterns);
}

function getSnFromMessage(msg) {
    return getPatternsFromMessage(msg, imConfig.sn_patterns);
}

function getRcFromMessage(msg) {
    var rcs = imConfig.response_codes;
    var rcsCount = rcs.length;

    for (var i = 0; i < rcsCount; i++) {

        var item = rcs[i];
        var re = new RegExp(item.pattern);
        if (msg.search(re) != -1) {
            return item.rc;
        }

    }
    return '68';
}

function isOnColonSeparatedString(needle, _haystack) {
    var haystack;
    var haystackCount;

    try {
        haystack = _haystack.trim().split(/\s*,\s*/);
        haystackCount = haystack.length;
    }
    catch(e) {
        return true;
    }

    for(var i=0; i<haystackCount; i++) {
        if (needle == haystack[i]) {
            return true;
        }
    }

    return false;
}

function isAllowedFrom(sender) {
    var isPartner = isOnColonSeparatedString(sender, config.h2h_out.partner);
    if (isPartner) {
        return true;
    }

    return isOnColonSeparatedString(sender, config.h2h_out.allowed_response_from);
}

function checkForSameDayDuplicate(task, cbNoDupe, cbDupe, cbDupeWithSameReqId) {
    getTask(task.remoteProduct, task.destination, function(err, archivedTask) {
        if (err) {
            logger.warn('Error on checking same day duplicate', {task: task});
            cbNoDupe(task);
            return;
        }

        if (archivedTask && archivedTask.requestId) {
            if (cbDupeWithSameReqId && task.requestId == archivedTask.requestId) {
                logger.verbose('Duplicate trx on same day with same requestId', {task: task});
                cbDupeWithSameReqId(task, archivedTask);
                return;
            }

            logger.verbose('Duplicate trx on same day', {task: task, archivedTask: archivedTask});
            cbDupe(task, archivedTask);
            return;
        }

        cbNoDupe(task);
    });
}

function registerResendDelay(task) {
    if (!task.requestId) {
        logger.warn('Invalid task on resendDelay')
        return;
    }

    if (!config || !config.globals || !Number(config.globals.auto_resend_delay_secs)) {
        return;
    }

    var retry = maxRegisterResendDelayRetry;
    var oldHandler = resendHandlers.get(task.requestId);
    if (oldHandler) {
        retry = oldHandler.retry - 1;

        try {
            cancelResendDelay(task);
        }
        catch(e) {}
    }

    if (retry <= 0) {
        logger.verbose('Resend delay retry exceeded', {task: task});
        cancelResendDelay(task);
        return;
    }

    logger.verbose('Registering resend delay task request', {task: task, delay: config.globals.auto_resend_delay_secs, retry: retry});
    var handlerData = {
        handler: setTimeout(topupRequest, config.globals.auto_resend_delay_secs * 1000, task),
        task: task,
        retry: retry
    }

    resendHandlers.set(task.requestId, handlerData);
    updateMatrixResendHandlersCount();
}

function cancelResendDelay(task) {
    if (!task || !task.requestId) {
        logger.warn('Invalid task on cancelResendDelay');
        return;
    }

    var oldHandler = resendHandlers.get(task.requestId);
    if (!oldHandler) {
        return;
    }

    logger.verbose('Canceling resend delay', {task: task});

    try {
        if (oldHandler.handler) {
            clearTimeout(oldHandler.handler);
        }
    }
    catch(e) {};

    try {
        resendHandlers.del(task.requestId);
    }
    catch(e) {};
}

function addAllPartnersToFriendList() {
    var partners = getPartnersFromString(config.h2h_out.partner + ',' + config.h2h_out.allow_response_from);
    var partnerCount = partners.length;

    for (var i=0; i < partnerCount; i++) {
        if (!isAFriend(partners[i])) {
            addFriend(partners[i]);
        }
    }
}

function onOnline() {
    logger.info('Login successful, resuming aaa communication');
    isOnline = true;

    addAllPartnersToFriendList();

    try {
        aaa.resume();
    }
    catch(e) {
        logger.warn('Exception on resuming aaa module: ' + e);
    }

    _initProbe();
}

function onPM(from, msg) {
    sendKeepAliveDelay();

    if (from == removeResourceFromJid(config.h2h_out.im_username)) {
        return;
    }

    if (!isAllowedFrom(from)) {
        logger.verbose('Ignoring message from unknown sender', {from: from, msg: msg});
        return;
    }

    if (isIgnoreMessage(msg)) {
        logger.verbose('Ignoring message because matches with ignore_patterns', {from: from, msg: msg});
        return;
    }

    var remoteProduct = getRemoteProductFromMessage(msg);
    var destination = getDestinationFromMessage(msg);

    logger.verbose("Extract remoteProduct and destination from message", {remoteProduct: remoteProduct, destination: destination, msg: msg, from: from});

    if (!remoteProduct || !destination) {
        logger.warn('Missing remote product or destination', {remoteProduct: remoteProduct, destination: destination, msg: msg, from: from});

        try {
            invalidReplies.push({msg: msg, from: from, remoteProduct: remoteProduct, destination: destination});
            matrix.invalid_replies = invalidReplies.toarray();
        }
        catch(e) {
            logger.warn('Exception on pushing invalidReplies', {err: e});
        }

        return;
    }

    logger.info('Got report from partner', {remoteProduct: remoteProduct, destination: destination, msg: msg, from: from});
    getTask(remoteProduct, destination, function(err, task) {
        if (err) {
            logger.warn('Error getting relevant task', {remoteProduct: remoteProduct, destination: destination, msg: msg, from: from});

            try {
                unknownTrx.push({msg: msg, from: from, remoteProduct: remoteProduct, destination: destination});
                matrix.unknown_trx = unknownTrx.toarray();
            }
            catch(e) {
                logger.warn('Exception on pushing unknown trx', {err: e})
            }

            return;
        }

        if (!task) {
            logger.warn('Something wrong, undefined task without error', {msg: msg, from: from});
            return;
        }

        logger.verbose('Got relevant task', {task: task, msg: msg, from: from});

        var rc = getRcFromMessage(msg);
        if (rc == '00') {
            var sn = getSnFromMessage(msg);
            if (sn) {
                msg = 'SN=' + sn + ';' + msg;
            }
        }

        if (['00', '55', '68'].indexOf(rc) == -1) {
            deleteTask(remoteProduct, destination);
        }

        if (rc != '68') {
            cancelResendDelay(task);
        }

        callbackReport(task.requestId, rc, msg + ' (' + from + ')');
    });
}

function onSameDayDupe(task, archivedTask) {
    if (task.requestId == archivedTask.requestId) {
        logger.info('Mengulang trx untuk advice', {task: task});
        _topupRequest(task);
    } else {
        logger.info('Terdeteksi trx sama dalam satu hari yang sama', {task: task});
        callbackReport(task.requestId, '55', 'Terdeteksi trx sama dalam satu hari yang sama');
    }
}

function checkStatus(task) {
    _topupRequest(task, true);
}

function _topupRequest(task, isCheckStatus) {
    var pattern = config.h2h_out.request_pattern;

    var keywords = createReplacementKeywords(task);

    saveTask(task, function() {

        var destination = getRandomPartnerId(!isCheckStatus);

        if (!destination) {
            var rc = '91';
            var msg = 'No partner (online/health) available, returning RC ' + rc;
            logger.warn(msg, {task: task});
            callbackReport(task.requestId, rc, msg);
            return;
        }

        registerResendDelay(task);

        var msg = createMessage(pattern, keywords);
        imAdaptor.sendMessage(destination, msg, task.requestId);
        sendKeepAliveDelay();
    });
}

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

    if (!aaa.isTodayTrx(task)) {
        logger.warn('Maaf, transaksi beda hari tidak dapat dilakukan');
        callbackReport(task.requestId, '68', 'Maaf, transaksi beda hari tidak dapat dilakukan');
        cancelResendDelay(task);
        return;
    }

    checkForSameDayDuplicate(task, _topupRequest, onSameDayDupe, checkStatus);
}

function getPartnersFromString(partners) {
    var _partners = partners.trim().replace(/^[,\s]+/, '').replace(/[,\s]+$/, '').split(/[,\s]+/);
    var _partnersCount = _partners.length;

    var cleaned = [];
    for (var i=0; i<_partnersCount; i++) {

        var partner = _partners[i];
        if (!partner) { continue; }

        if (cleaned.indexOf(partner) < 0) {
            cleaned.push(partner);
        }
    }
    return cleaned;
}

function getOnlinePartners(partners) {

    if (!imAdaptor.isPartnerOffline) {
        logger.verbose('partnerIm.getOnlinePartners: imAdaptor does not have isPartnerOffline method, assuming all partners is online');
        return partners;
    }

    var onlinePartners = [];

    var partnersCount = partners.length;
    for (var i=0; i<partnersCount; i++) {
        if (!imAdaptor.isPartnerOffline(partners[i])) {
            onlinePartners.push(partners[i]);
        }
    }

    return onlinePartners;
}

function getHealthyPartners(partners) {

    if (!imAdaptor.isPartnerHealthy) {
        logger.verbose('partnerIm.getHealthyPartners: imAdaptor does not have isPartnerHealthy method, use isPartnerOnline');
        return isPartnerOnline(partners);
    }

    var filteredPartners = [];

    var partnersCount = partners.length;
    for (var i=0; i<partnersCount; i++) {
        if (imAdaptor.isPartnerHealthy(partners[i])) {
            filteredPartners.push(partners[i]);
        }
    }

    return filteredPartners;
}


function getRandomPartnerId(forceOnlyHealthPartners) {
    var _partners = getPartnersFromString(config.h2h_out.partner);

    // tambah partner ke friend list, untuk menangani perubahan config
    addAllPartnersToFriendList(_partners);

    var partners = getHealthyPartners(_partners);

    if (!partners.length) {

        if (forceOnlyHealthPartners) {
            logger.warn('Force only health parners on no available health partners, returning null');
            return null;
        } else {
            logger.warn('Don not force only health partners on no available health partners, assuming all partners is health as a fallback');
            partners = _partners;
        }

    }

    var partnerCount = partners.length;

    if (partnerCount <= 0) {
        logger.warn('getRandomPartnerId: no registered partners available');
        return null;
    }

    var selectedPartnerIdx = Math.round(Math.random() * (partnerCount - 1));
    return partners[selectedPartnerIdx];
}

function _initProbe() {
    var probeOptions = {
        config: config,
        matrix: matrix,
        logger: logger,
        sendMessage: imAdaptor.sendMessage
    }

    imProbe.init(probeOptions);
}

function isAFriend(partner) {
    if (!matrix.friends) { matrix.friends = []; };

    try {
        partner = removeResourceFromJid(partner = partner.trim().toLowerCase());
        return (matrix.friends.indexOf(partner) >= 0);
    }
    catch(e) {
        logger.warn('Exception saat pengecekan isAFriend', {partner: partner, err: e});
        return;
    }
}

function addFriend(partner) {
    if (!matrix.friends) { matrix.friends = []; };

    partner = removeResourceFromJid(partner.trim().toLowerCase());

    if (isAFriend(partner)) {
        logger.verbose('Partner is already a friend, skip adding friend', {partner: partner});
        return;
    }

    logger.verbose('Adding to friendList', {partner: partner})
    matrix.friends.push(partner);

    if (imAdaptor.addFriend) {
        imAdaptor.addFriend(partner);
    }
}

exports.init = init;
exports.start = init;
exports.getPatternFromMessage = getPatternFromMessage;
exports.getPatternsFromMessage = getPatternsFromMessage;
exports.saveTask = saveTask;
exports.getTask = getTask;
exports.readImConfig = readImConfig;
exports.createMessage = createMessage;
exports.getRemoteProductFromMessage = getRemoteProductFromMessage;
exports.getDestinationFromMessage = getDestinationFromMessage;
exports.getRcFromMessage = getRcFromMessage;
exports.getSnFromMessage = getSnFromMessage;
exports.isAllowedFrom = isAllowedFrom;
exports.checkForSameDayDuplicate = checkForSameDayDuplicate;
exports.deleteTask = deleteTask;
exports.registerResendDelay = registerResendDelay;
exports.cancelResendDelay = cancelResendDelay;
exports.onOnline = onOnline;
exports.onPM = onPM;
exports.topupRequest = topupRequest;
exports.removeResourceFromJid = removeResourceFromJid