const MODULE_NAME = 'HIT.PREPAID-TOPUP';

const axios = require('axios').default;
const urljoin = require('url-join');

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');
    let lastResponse = null;

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

        const 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,
            'GET',
            endpointUrl,
            params,
            lastResponse && lastResponse.data,
            lastResponse && lastResponse.status,
            lastResponse,
            false,
        );
    }
};