/* jslint node: true */
/* eslint-disable no-console */
'use strict';

const {
    printUsageAndSetExitCode,
    getConfigPath,
    ExitCodes,
    argv,
    initConfigAndDatabases,
    getAnswers,
    writeConfig,
} = require('./oputil_common.js');

const getHelpFor = require('./oputil_help.js').getHelpFor;
const Address = require('../ftn_address.js');
const Errors = require('../enig_error.js').Errors;

//	deps
const async = require('async');
const paths = require('path');
const fs = require('fs');
const hjson = require('hjson');
const _ = require('lodash');
const moment = require('moment');

exports.handleMessageBaseCommand = handleMessageBaseCommand;

function areaFix() {
    //
    //	oputil mb areafix CMD1 CMD2 ... ADDR [--password PASS]
    //
    if (argv._.length < 3) {
        return printUsageAndSetExitCode(getHelpFor('MessageBase'), ExitCodes.ERROR);
    }

    async.waterfall(
        [
            function init(callback) {
                return initConfigAndDatabases(callback);
            },
            function validateAddress(callback) {
                const addrArg = argv._.slice(-1)[0];
                const ftnAddr = Address.fromString(addrArg);

                if (!ftnAddr) {
                    return callback(
                        Errors.Invalid(`"${addrArg}" is not a valid FTN address`)
                    );
                }

                //
                //	We need to validate the address targets a system we know unless
                //	the --force option is used
                //
                //	:TODO:
                return callback(null, ftnAddr);
            },
            function fetchFromUser(ftnAddr, callback) {
                //
                //	--from USER || +op from system
                //
                //	If possible, we want the user ID of the supplied user as well
                //
                const User = require('../user.js');

                if (argv.from) {
                    User.getUserIdAndNameByLookup(argv.from, (err, userId, fromName) => {
                        if (err) {
                            return callback(null, ftnAddr, argv.from, 0);
                        }

                        //	fromName is the same as argv.from, but case may be differnet (yet correct)
                        return callback(null, ftnAddr, fromName, userId);
                    });
                } else {
                    User.getUserName(User.RootUserID, (err, fromName) => {
                        return callback(
                            null,
                            ftnAddr,
                            fromName || 'SysOp',
                            err ? 0 : User.RootUserID
                        );
                    });
                }
            },
            function createMessage(ftnAddr, fromName, fromUserId, callback) {
                //
                //	Build message as commands separated by line feed
                //
                //	We need to remove quotes from arguments. These are required
                //	in the case of e.g. removing an area: "-SOME_AREA" would end
                //	up confusing minimist, therefor they must be quoted: "'-SOME_AREA'"
                //
                const messageBody =
                    argv._.slice(2, -1)
                        .map(arg => {
                            return arg.replace(/["']/g, '');
                        })
                        .join('\r\n') + '\n';

                const Message = require('../message.js');

                const message = new Message({
                    toUserName: argv.to || 'AreaFix',
                    fromUserName: fromName,
                    subject: argv.password || '',
                    message: messageBody,
                    areaTag: Message.WellKnownAreaTags.Private, //	mark private
                    meta: {
                        System: {
                            [Message.SystemMetaNames.RemoteToUser]: ftnAddr.toString(), //	where to send it
                            [Message.SystemMetaNames.ExternalFlavor]:
                                Message.AddressFlavor.FTN, //	on FTN-style network
                        },
                    },
                });

                if (0 !== fromUserId) {
                    message.setLocalFromUserId(fromUserId);
                }

                return callback(null, message);
            },
            function persistMessage(message, callback) {
                message.persist(err => {
                    if (!err) {
                        console.log(
                            'AreaFix message persisted and will be exported at next scheduled scan'
                        );
                    }
                    return callback(err);
                });
            },
        ],
        err => {
            if (err) {
                process.exitCode = ExitCodes.ERROR;
                console.error(`${err.message}${err.reason ? ': ' + err.reason : ''}`);
            }
        }
    );
}

function validateUplinks(uplinks) {
    const ftnAddress = require('../../core/ftn_address.js');
    const valid = uplinks.every(ul => {
        const addr = ftnAddress.fromString(ul);
        return addr;
    });
    return valid;
}

function getMsgAreaImportType(path) {
    if (argv.type) {
        return argv.type.toLowerCase();
    }

    return paths.extname(path).substr(1).toLowerCase(); //  bbs|na|...
}

function importAreas() {
    const importPath = argv._[argv._.length - 1];
    if (argv._.length < 3 || !importPath || 0 === importPath.length) {
        return printUsageAndSetExitCode(getHelpFor('Config'), ExitCodes.ERROR);
    }

    const importType = getMsgAreaImportType(importPath);
    if ('na' !== importType && 'bbs' !== importType) {
        return console.error(`"${importType}" is not a recognized import file type`);
    }

    //	optional data - we'll prompt if for anything not found
    let confTag = argv.conf;
    let networkName = argv.network;
    let uplinks = argv.uplinks;
    if (uplinks) {
        uplinks = uplinks.split(/[\s,]+/);
    }

    let importEntries;

    async.waterfall(
        [
            function readImportFile(callback) {
                fs.readFile(importPath, 'utf8', (err, importData) => {
                    if (err) {
                        return callback(err);
                    }

                    importEntries = getImportEntries(importType, importData);
                    if (0 === importEntries.length) {
                        return callback(Errors.Invalid('Invalid or empty import file'));
                    }

                    //	We should have enough to validate uplinks
                    if ('bbs' === importType) {
                        for (let i = 0; i < importEntries.length; ++i) {
                            if (!validateUplinks(importEntries[i].uplinks)) {
                                return callback(Errors.Invalid('Invalid uplink(s)'));
                            }
                        }
                    } else {
                        if (!validateUplinks(uplinks || [])) {
                            return callback(Errors.Invalid('Invalid uplink(s)'));
                        }
                    }

                    return callback(null);
                });
            },
            function init(callback) {
                return initConfigAndDatabases(callback);
            },
            function validateAndCollectInput(callback) {
                const msgArea = require('../../core/message_area.js');
                const sysConfig = require('../../core/config.js').get();

                let msgConfs = msgArea.getSortedAvailMessageConferences(null, {
                    noClient: true,
                });
                if (!msgConfs) {
                    return callback(
                        Errors.DoesNotExist('No conferences exist in your configuration')
                    );
                }

                msgConfs = msgConfs.map(mc => {
                    return {
                        name: mc.conf.name,
                        value: mc.confTag,
                    };
                });

                if (
                    confTag &&
                    !msgConfs.find(mc => {
                        return confTag === mc.value;
                    })
                ) {
                    return callback(
                        Errors.DoesNotExist(`Conference "${confTag}" does not exist`)
                    );
                }

                const existingNetworkNames = Object.keys(
                    _.get(sysConfig, 'messageNetworks.ftn.networks', {})
                );

                if (
                    networkName &&
                    !existingNetworkNames.find(net => networkName === net)
                ) {
                    return callback(
                        Errors.DoesNotExist(
                            `FTN style Network "${networkName}" does not exist`
                        )
                    );
                }

                //  can't use --uplinks without a network
                if (!networkName && 0 === existingNetworkNames.length && uplinks) {
                    return callback(
                        Errors.Invalid(
                            'Cannot use --uplinks without an FTN network to import to'
                        )
                    );
                }

                getAnswers(
                    [
                        {
                            name: 'confTag',
                            message: 'Message conference:',
                            type: 'list',
                            choices: msgConfs,
                            pageSize: 10,
                            when: !confTag,
                        },
                        {
                            name: 'networkName',
                            message: 'FTN network name:',
                            type: 'list',
                            choices: ['-None-'].concat(existingNetworkNames),
                            pageSize: 10,
                            when: !networkName && existingNetworkNames.length > 0,
                            filter: choice => {
                                return '-None-' === choice ? undefined : choice;
                            },
                        },
                    ],
                    answers => {
                        confTag = confTag || answers.confTag;
                        networkName = networkName || answers.networkName;
                        uplinks = uplinks || answers.uplinks;

                        importEntries.forEach(ie => {
                            ie.areaTag = ie.ftnTag.toLowerCase();
                        });

                        return callback(null);
                    }
                );
            },
            function collectUplinks(callback) {
                if (!networkName || uplinks || 'bbs' === importType) {
                    return callback(null);
                }

                getAnswers(
                    [
                        {
                            name: 'uplinks',
                            message: 'Uplink(s) (comma separated):',
                            type: 'input',
                            validate: input => {
                                const inputUplinks = input.split(/[\s,]+/);
                                return validateUplinks(inputUplinks)
                                    ? true
                                    : 'Invalid uplink(s)';
                            },
                        },
                    ],
                    answers => {
                        uplinks = answers.uplinks;
                        return callback(null);
                    }
                );
            },
            function confirmWithUser(callback) {
                const sysConfig = require('../../core/config.js').get();

                console.info(`Importing the following for "${confTag}"`);
                console.info(
                    `(${sysConfig.messageConferences[confTag].name} - ${sysConfig.messageConferences[confTag].desc})`
                );
                console.info('');
                importEntries.forEach(ie => {
                    console.info(`  ${ie.ftnTag} - ${ie.name}`);
                });

                if (networkName) {
                    console.info('');
                    console.info(`For FTN network: ${networkName}`);
                    console.info(`Uplinks: ${uplinks}`);
                    console.info('');
                    console.info(
                        'Importing will NOT create required FTN network configurations.'
                    );
                    console.info(
                        'If you have not yet done this, you will need to complete additional steps after importing.'
                    );
                    console.info('See Message Networks docs for details.');
                    console.info('');
                }

                getAnswers(
                    [
                        {
                            name: 'proceed',
                            message: 'Proceed?',
                            type: 'confirm',
                        },
                    ],
                    answers => {
                        return callback(
                            answers.proceed ? null : Errors.General('User canceled')
                        );
                    }
                );
            },
            function loadConfigHjson(callback) {
                const configPath = getConfigPath();
                fs.readFile(configPath, 'utf8', (err, confData) => {
                    if (err) {
                        return callback(err);
                    }

                    let config;
                    try {
                        config = hjson.parse(confData, { keepWsc: true });
                    } catch (e) {
                        return callback(e);
                    }
                    return callback(null, config);
                });
            },
            function performImport(config, callback) {
                const confAreas = { messageConferences: {} };
                confAreas.messageConferences[confTag] = { areas: {} };

                const msgNetworks = { messageNetworks: { ftn: { areas: {} } } };

                importEntries.forEach(ie => {
                    const specificUplinks = ie.uplinks || uplinks; //	AREAS.BBS has specific uplinks per area

                    confAreas.messageConferences[confTag].areas[ie.areaTag] = {
                        name: ie.name,
                        desc: ie.name,
                    };

                    if (networkName) {
                        msgNetworks.messageNetworks.ftn.areas[ie.areaTag] = {
                            network: networkName,
                            tag: ie.ftnTag,
                            uplinks: specificUplinks,
                        };
                    }
                });

                const newConfig = _.defaultsDeep(config, confAreas, msgNetworks);
                const configPath = getConfigPath();

                if (!writeConfig(newConfig, configPath)) {
                    return callback(
                        Errors.UnexpectedState('Failed writing configuration')
                    );
                }

                return callback(null);
            },
        ],
        err => {
            if (err) {
                console.error(err.reason ? err.reason : err.message);
            } else {
                const addFieldUpd = 'bbs' === importType ? '"name" and "desc"' : '"desc"';
                console.info('Import complete.');
                console.info(
                    `You may wish to validate changes made to ${getConfigPath()}`
                );
                console.info(`as well as update ${addFieldUpd} fields, sorting, etc.`);
                console.info('');
            }
        }
    );
}

function getImportEntries(importType, importData) {
    let importEntries = [];

    if ('na' === importType) {
        //
        //	parse out
        //	TAG		DESC
        //
        const re = /^([^\s]+)\s+([^\r\n]+)/gm;
        let m;

        while ((m = re.exec(importData))) {
            importEntries.push({
                ftnTag: m[1].trim(),
                name: m[2].trim(),
            });
        }
    } else if ('bbs' === importType) {
        //
        //	Various formats for AREAS.BBS seem to exist. We want to support as much as possible.
        //
        //	SBBS http://www.synchro.net/docs/sbbsecho.html#AREAS.BBS
        //	CODE	TAG		UPLINKS
        //
        //	VADV https://www.vadvbbs.com/products/vadv/support/docs/docs_vfido.php#AREAS.BBS
        //	TAG		UPLINKS
        //
        //	Misc
        //	PATH|OTHER	TAG		UPLINKS
        //
        //	Assume the second item is TAG and 1:n UPLINKS (space and/or comma sep) after (at the end)
        //
        const re = /^[^\s]+\s+([^\s]+)\s+([^\n]+)$/gm;
        let m;
        while ((m = re.exec(importData))) {
            const tag = m[1].trim();

            importEntries.push({
                ftnTag: tag,
                name: `Area: ${tag}`,
                uplinks: m[2].trim().split(/[\s,]+/),
            });
        }
    }

    return importEntries;
}

function dumpQWKPacket() {
    const packetPath = argv._[argv._.length - 1];
    if (argv._.length < 3 || !packetPath || 0 === packetPath.length) {
        return printUsageAndSetExitCode(getHelpFor('MessageBase'), ExitCodes.ERROR);
    }

    async.waterfall(
        [
            callback => {
                return initConfigAndDatabases(callback);
            },
            callback => {
                const { QWKPacketReader } = require('../qwk_mail_packet');
                const reader = new QWKPacketReader(packetPath);

                reader.on('error', err => {
                    console.error(`ERROR: ${err.message}`);
                    return callback(err);
                });

                reader.on('done', () => {
                    return callback(null);
                });

                reader.on('archive type', archiveType => {
                    console.info(`-> Archive type: ${archiveType}`);
                });

                reader.on('creator', creator => {
                    console.info(`-> Creator: ${creator}`);
                });

                reader.on('message', message => {
                    console.info('--- message ---');
                    console.info(`To:      ${message.toUserName}`);
                    console.info(`From:    ${message.fromUserName}`);
                    console.info(`Subject: ${message.subject}`);
                    console.info(`Message:\r\n${message.message}`);
                });

                reader.read();
            },
        ],
        err => {
            if (err) {
                console.error(`QWK dump failed: ${err.message}`);
            }
        }
    );
}

function exportQWKPacket() {
    let packetPath = argv._[argv._.length - 1];
    if (argv._.length < 3 || !packetPath || 0 === packetPath.length) {
        return printUsageAndSetExitCode(getHelpFor('MessageBase'), ExitCodes.ERROR);
    }

    //  oputil mb qwk-export TAGS PATH [--user USER] [--after TIMESTAMP]
    //  [areaTag1,areaTag2,...] PATH --user USER --after TIMESTAMP
    let bbsID = 'ENIGMA';
    const filename = paths.basename(packetPath);
    if (filename) {
        const ext = paths.extname(filename);
        bbsID = paths.basename(filename, ext);
    }

    packetPath = paths.dirname(packetPath);

    const posArgLen = argv._.length;

    let areaTags;
    if (4 === posArgLen) {
        areaTags = argv._[posArgLen - 2].split(',');
    } else {
        areaTags = [];
    }

    let newerThanTimestamp = null;
    if (argv.after) {
        const ts = moment(argv.after);
        if (ts.isValid()) {
            newerThanTimestamp = ts.format();
        }
    }

    const userName = argv.user || '-';

    const writerOptions = {
        enableQWKE: !(false === argv.qwke),
        enableHeadersExtension: !(false === argv.synchronet),
        enableAtKludges: !(false === argv.synchronet),
        archiveFormat: argv.format || 'application/zip',
    };

    let totalExported = 0;
    async.waterfall(
        [
            callback => {
                return initConfigAndDatabases(callback);
            },
            callback => {
                const User = require('../../core/user.js');

                User.getUserIdAndName(userName, (err, userId) => {
                    if (err) {
                        if ('-' === userName) {
                            userId = 1;
                        } else {
                            return callback(err);
                        }
                    }
                    return User.getUser(userId, callback);
                });
            },
            (user, callback) => {
                //  populate area tags with all available to user
                //  if they were not explicitly supplied
                if (!areaTags.length) {
                    const {
                        getAllAvailableMessageAreaTags,
                    } = require('../../core/message_area');

                    areaTags = getAllAvailableMessageAreaTags();
                }
                return callback(null, user);
            },
            (user, callback) => {
                const Message = require('../message');

                const filter = {
                    resultType: 'id',
                    areaTag: areaTags,
                    newerThanTimestamp,
                };

                //  public
                Message.findMessages(filter, (err, publicMessageIds) => {
                    if (err) {
                        return callback(err);
                    }

                    delete filter.areaTag;
                    filter.privateTagUserId = user.userId;

                    Message.findMessages(filter, (err, privateMessageIds) => {
                        return callback(
                            err,
                            user,
                            Message,
                            privateMessageIds.concat(publicMessageIds)
                        );
                    });
                });
            },
            (user, Message, messageIds, callback) => {
                const { QWKPacketWriter } = require('../qwk_mail_packet');
                const writer = new QWKPacketWriter(
                    Object.assign(writerOptions, {
                        bbsID,
                        user,
                    })
                );

                writer.on('ready', () => {
                    async.eachSeries(
                        messageIds,
                        (messageId, nextMessageId) => {
                            const message = new Message();
                            message.load({ messageId }, err => {
                                if (!err) {
                                    writer.appendMessage(message);
                                    ++totalExported;
                                }
                                return nextMessageId(err);
                            });
                        },
                        err => {
                            writer.finish(packetPath);
                            if (err) {
                                console.error(
                                    `Failed to write one or more messages: ${err.message}`
                                );
                            }
                        }
                    );
                });

                writer.on('warning', err => {
                    console.warn(`!!! ${err.reason ? err.reason : err.message}`);
                });

                writer.on('finished', () => {
                    return callback(null);
                });

                writer.init();
            },
        ],
        err => {
            if (err) {
                return console.error(err.reason ? err.reason : err.message);
            }

            console.info(`-> Exported ${totalExported} messages`);
        }
    );
}

const listConferences = () => {
    initConfigAndDatabases(err => {
        if (err) {
            return console.error(err.reason ? err.reason : err.message);
        }

        const { getSortedAvailMessageConferences } = require('../../core/message_area');

        const conferences = getSortedAvailMessageConferences(null, { noClient: true });

        for (let conf of conferences) {
            console.info(`${conf.confTag} - ${conf.conf.name}`);

            if (!argv.areas) {
                continue;
            }

            for (let areaTag of Object.keys(conf.conf.areas)) {
                console.info(`  ${areaTag} - ${conf.conf.areas[areaTag].name}`);
            }
        }
    });
};

function handleMessageBaseCommand() {
    function errUsage() {
        return printUsageAndSetExitCode(getHelpFor('MessageBase'), ExitCodes.ERROR);
    }

    if (true === argv.help) {
        return errUsage();
    }

    const action = argv._[1];

    return (
        {
            areafix: areaFix,
            'import-areas': importAreas,
            'qwk-dump': dumpQWKPacket,
            'qwk-export': exportQWKPacket,
            'list-confs': listConferences,
        }[action] || errUsage
    )();
}