process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
  
  var request = require('request');
  var xml2js = require('xml2js');
  
  var resendDelay = require('sate24/resend-delay.js');
  var taskHistory = require('./task-history.js');
  var antiSameDayDupe = require('./anti-same-day-dupe.js');
  
  var config;
  var aaa;
  var _callbackReport;
  var logger;

  var xmlBuilder = new xml2js.Builder({rootName: 'xml', headless: true});

  
  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 {
          console.log('Undefined options.logger, terminating....')
          process.exit(1);
      }
  
      resendDelay.init({
          config: config,
          topupRequest: _topupStatus,
          logger: logger
      });
  
      taskHistory.init(options);
      antiSameDayDupe.init(options);
  }
  
  function callbackReport(requestId, responseCode, msg) {
      if (responseCode != '68') {
          resendDelay.cancel(requestId);
  
      } else {
          taskHistory.get(requestId, function(err, task) {
              if (task) {
                  resendDelay.register(task);
              }
          });
      }
  
      _callbackReport(requestId, responseCode, msg);
  }
  
  function parseResponse(task, response) {
      var xmlParser = xml2js.parseString;
  
      xmlParser(response, function(err, result) {
          if (err) {
              var msg = 'Error parsing response. ' + err;
              logger.warn(msg, {task: task, response: response, err: err});
              callbackReport(task.requestId, '68', msg);
              return;
          }
  
          logger.verbose('Response parsed', {result: result, task: task});
  
          var rc = '68';
  
          var partnerResponseCode;
          try {
              partnerResponseCode = result.hpay.responseCode[0];
          } catch(e) {}
  
          var partnerMessage = '';
          try {
              partnerMessage = result.hpay.responseMessage[0];
          } catch(e) {}
  
          if (partnerResponseCode == '00') {
              rc = '00';
          }
          else if ((partnerResponseCode == '99') && (partnerMessage == 'Member Not Found')) {
              rc = '40';
          }
          else if (partnerResponseCode == '99') {
              rc = '68';
          }
          else {
              rc = '40';
          }
  
          var msg = '';
          if (partnerResponseCode) {
              msg = partnerResponseCode;
          }
  
          if (partnerMessage) {
              msg = msg + ' ' + partnerMessage;
          }
          msg = msg.trim();
  
          callbackReport(task.requestId, rc, msg);
      });
  }
  
  function requestToPartner(methodName, task) {
      var payload = createPayload(methodName, task, config.h2h_out.userid, config.h2h_out.noid, config.h2h_out.password);
      if (!payload) {
          callbackReport(task.requestId, '40', 'ERROR: Undefined payload');
          return;
      }
  
      var requestOpts = {
          url: config.h2h_out.partner,
          method: "POST",
          body: payload,

      }
  
      logger.verbose('Requesting to partner', {methodName: methodName, task: task, requestOpts: requestOpts});
      request(requestOpts, function (err, response, responseBody) {
          if (err) {
              var rc = '68';
              if (methodName === 'pay') {
                  rc = '40';
              }
  
              var msg = 'Error requesting pay method. ' + err;
              callbackReport(task.requestId, rc, msg);
              return;
          }
  
          logger.info('Got direct response from partner', {task: task, responseBody: responseBody});
          parseResponse(task, responseBody);
      });
  }
  
  
  function topupRequest(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');
          resendDelay.cancel(task);
          return;
      }
  
      antiSameDayDupe.check(task, _topupRequest, onSameDayDupe, _topupStatus);
  }
  
  function _topupRequest(task) {
      taskHistory.put(task, function() {
          requestToPartner('pay', task);;
      });
  }
  
  function _topupStatus(task) {
      requestToPartner('checking', task);
  }
  
  function onSameDayDupe(task) {
      callbackReport(task.requestId, '55', 'Transaksi duplikat dalam satu hari yang sama');
  }
  
  function extractProductDetail(remoteProduct) {
      var product;
  
      try {
          product = remoteProduct.split(',');
      }
      catch(e) {
          logger.warn('extractProductDetail: exception on split');
          return null;
      }
  
      if (product.length !== 3) {
          logger.warn('extractProductDetail: product.length <> 3');
          return null;
      }
  
      return {product: product[0], productType: product[1], nominal: product[2]};
  }
  
  function createPayload(transactionType, task, user, noid, pin) {
      var product = extractProductDetail(task.remoteProduct);
      if (!product) {
          logger.warn('createPayload: undefined product');
          return;
      }
  
      var payload = {
          transactionType: transactionType,
          product: product.product,
          productType: product.productType,
          idpel: task.destination,
          pin: pin,
          noid: noid,
          user: user,
          nominal: product.nominal
      };
  
      return xmlBuilder.buildObject(payload);
  }
  
  exports.start = start;
  exports.topupRequest = topupRequest;