const childProcess = require('child_process');

const express = require('express');
const bodyParser = require('body-parser');

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

const smstoolsConfig = require('../../smstools-config');
const smstoolsConfigData = require('../../smstools-config/config-file');
const smstoolsConfigCreator = require('../../smstools-config/creator');
const smstoolsConfigSetter = require('../../smstools-config/setter');
const queuesAndProviders = require('../../smstools-config/queues-and-providers');


const router = express.Router();
module.exports = router;

async function pageIndex(req, res) {
    const configString = await smstoolsConfigCreator();
    res.json({
        dirty: smstoolsConfig.config.dirty,
        config: smstoolsConfig.config,
        configStringLength: configString.length,
        configStringNrLines: (configString.match(/\n/g) || []).length,
        configString,
    });
}

async function pageGenerate(req, res) {
    res.end(await smstoolsConfigCreator());
}

async function pageModemList(req, res) {
    const modems = [];
    // eslint-disable-next-line no-restricted-syntax
    for (const [key, value] of Object.entries(smstoolsConfigData.modems || {})) {
        modems.push({
            label: `${key}: ${value.device}, INCOMING${value.outgoing ? ' and OUTGOING' : ''}`,
            value: key,
            data: value,
        });
    }

    res.json(modems);
}

async function pageSet(req, res) {
    const keyword = (req.params.keyword || req.query.keyword || '').trim();
    const value = (req.query.value || '').trim();

    if (!keyword) {
        res.end('Invalid keyword');
        return;
    }

    const result = await smstoolsConfigSetter.set(keyword, value);
    res.json({
        dirty: !!smstoolsConfigData.dirty,
        result,
    });
}

async function pageModemSet(req, res) {
    if (!req.body) {
        res.json({
            status: 'NOT OK',
            message: 'Empty body',
        });
        return;
    }

    const modemName = (req.params.modemName || '').trim();
    if (!modemName) {
        res.json({
            status: 'NOT OK',
            message: 'Invalid modem name',
        });
        return;
    }

    const result = await smstoolsConfigSetter.setModem(modemName, req.body);
    res.json({
        dirty: !!smstoolsConfigData.dirty,
        result,
    });
}

async function pageModemSetSingleValue(req, res) {
    if (!req.body) {
        res.json({
            status: 'NOT OK',
            message: 'Empty body',
        });
        return;
    }

    const modemName = (req.params.modemName || '').trim();
    if (!modemName) {
        res.json({
            status: 'NOT OK',
            message: 'Invalid modem name',
        });
        return;
    }

    const keyword = (req.body.keyword || '').trim();
    if (!keyword) {
        res.json({
            status: 'NOT OK',
            message: 'Invalid keyword',
        });
        return;
    }

    const { value } = req.body;

    const result = await smstoolsConfigSetter.setModemSingleValue(modemName, keyword, value);
    res.json({
        dirty: !!smstoolsConfigData.dirty,
        result,
    });
}

async function pageModemDelete(req, res) {
    const modemName = (req.params.modemName || '').trim();
    if (!modemName) {
        res.json({
            status: 'NOT OK',
            message: 'Invalid modem name',
        });
        return;
    }

    const result = await smstoolsConfigSetter.delModem(modemName);
    res.json({
        dirty: !!smstoolsConfigData.dirty,
        result,
    });
}

async function pageInstallConfig(req, res) {
    logger.info('ROUTER-SMSTOOLS-CONFIG: Going to write configuration and restart smsd service');
    await smstoolsConfigSetter.writeConfig();

    const fileToExec = `${process.cwd()}/bin/smstools-config-install`;
    childProcess.execFile(fileToExec, [config.smstools_config_file || '/etc/smsd.conf'], (err, stdout, stderr) => {
        res.json({
            err,
            stdout,
            stderr,
        });
    });
}

async function pageQueuesAndProviders(req, res) {
    res.json(smstoolsConfigData.queues);
}

function pageModemQueueName(req, res) {
    const modemName = req.params.modemName || req.query.modemName || req.query.modem_name;
    res.json({
        modemName,
        queueName: queuesAndProviders.getModemQueueName(modemName),
    });
}

router.get('/', pageIndex);
router.get('/generate', pageGenerate);
router.get('/modems', pageModemList);

router.get('/set/:keyword', pageSet);
router.post('/modem/set/:modemName', bodyParser.json({ type: '*/json' }), pageModemSet);
router.post('/modem/set-single-value/:modemName', bodyParser.json({ type: '*/json' }), pageModemSetSingleValue);
router.get('/modem/delete/:modemName', pageModemDelete);
router.get('/install-config', pageInstallConfig);
router.get('/queues-and-providers', pageQueuesAndProviders);
router.get('/modem-queue-name', pageModemQueueName);
router.get('/modem-queue-name/:modemName', pageModemQueueName);