const MODULE_NAME = 'HIT.PREPAID-TOPUP';

  const axios = require('axios');

  const urljoin = require('url-join');

  const querystring = require('querystring');

  
  const config = require('komodo-sdk/config');

  const logger = require('tektrans-logger');

  
  const report = require('../report/prepaid');
  const translateRc = require('../translate-rc');
  const composeCallbackUrl = require('./compose-callback-url');

  const dumpReqRes = require('./dump-req-res');

  const axiosErrorIsSafe = require('./axios-error-is-safe');

  module.exports = async (xid, task) => {

      logger.verbose(`${MODULE_NAME} 2272F01F: Processing task`, {
          xid,

          task,
      });

      const params = {
          request_id: task.trx_id,
          terminal_name: config.partner.terminal_name,
          password: config.partner.password,
          destination: task.destination,
          product_name: task.remote_product,

          reverse_url: composeCallbackUrl(xid, task, false),

      };

      const endpointUrl = urljoin(config.partner.url, '/topup');

      const fullEndpointUrl = urljoin(
          endpointUrl,
          [
              '?',
              querystring.stringify(params),

          ].join(''),

      );

      let lastResponse = null;

      try {
          logger.verbose(`${MODULE_NAME} 4AAD4F99: Going to HIT prepaid endpoint`, {
              xid,

              endpointUrl,
              params,

              fullEndpointUrl: (!config.partner.method || config.partner.method === 'GET')
                  ? fullEndpointUrl
                  : endpointUrl,

          });

          report(xid, {
              trx_id: task.trx_id,
              rc: '68',
              message: {
                  xid,
                  msg: 'Sending request to partner',

                  method: config.partner.method || 'GET',

                  endpointUrl,
              },
          });

          let response;
          if (config.partner.method === 'POST') {
              response = await axios.post(endpointUrl, new URLSearchParams(params), {

                  headers: {
                      'User-Agent': 'KOMODO-GW-HTTPGETX',
                  },
                  timeout: config.partner.hit_timeout_ms || 60 * 1000,

              });
          } else if (config.partner.method === 'POST-JSON') {
              response = await axios.post(endpointUrl, params, {
                  headers: {
                      'User-Agent': 'KOMODO-GW-HTTPGETX',
                  },
                  timeout: config.partner.hit_timeout_ms || 60 * 1000,
              });
          } else {
              response = await axios.get(endpointUrl, {

                  headers: {
                      'User-Agent': 'KOMODO-GW-HTTPGETX',
                  },
                  timeout: config.partner.hit_timeout_ms || 60 * 1000,
                  params,
              });

          }

  
          if (!response) {
              const e = new Error(`${MODULE_NAME} 8CF4E04D: Empty response`);
              e.rc = '68';
              e.response = response;
              throw e;
          }
  
          if (!response.data) {
              const e = new Error(`${MODULE_NAME} E72B5A53: Empty response data`);
              e.rc = '68';
              e.response = response;
              throw e;
          }
  
          if (typeof response.data !== 'object') {
              const e = new Error(`${MODULE_NAME} 507680AB: Response data is not a JSON`);
              e.rc = '68';
              e.response = response;
              throw e;
          }

          lastResponse = response;

          logger.verbose(`${MODULE_NAME} E51AFBBA: Got a direct response`, {
              xid,
              responseBody: response.data,
          });
  
          report(xid, {
              trx_id: task.trx_id,
              rc: response.data.rc ? translateRc[response.data.rc] || response.data.rc
                  : '68',
              sn: response.data.sn || null,

              amount: Number(response.data.amount) || undefined,
              balance: Number(response.data.ending_balance) || undefined,

              message: {
                  xid,
                  'DIRECT-RESPONSE': response.data,

              },
          });
      } catch (e) {

          const rc = e.rc
              || (axiosErrorIsSafe(e) && '91')
              || '68';

          logger.warn(`${MODULE_NAME} 8E8E49F5: Exception`, {
              xid,
              eCode: e.code,
              eMessage: e.message,
              eRc: e.rc,
              rc,

              responseHttpStatus: e.response && e.response.status,
              responseBody: e.response && e.response.data,
          });

          lastResponse = e.response;

          report(xid, {
              trx_id: task.trx_id,
              rc,
              message: {
                  xid,
                  'KOMODO-GW-ERROR': {
                      eCode: e.code,
                      eMessage: e.message,
                      responseHttpStatus: e.response && e.response.status,
                      responseBody: e.response && e.response.data,
                  },

              },
          });

      } finally {
          dumpReqRes(
              xid,
              task,

              config.partner.method || 'GET',

              endpointUrl,
              params,
              lastResponse && lastResponse.data,
              lastResponse && lastResponse.status,
              lastResponse,

              false,

          );

      }
  };