/* jslint node: true */
'use strict';

//  ENiGMA½
const Log = require('../../logger.js').log;
const { ServerModule } = require('../../server_module.js');
const Config = require('../../config.js').get;
const { getTransactionDatabase, getModDatabasePath } = require('../../database.js');
const {
    getMessageAreaByTag,
    getMessageConferenceByTag,
} = require('../../message_area.js');
const User = require('../../user.js');
const Errors = require('../../enig_error.js').Errors;
const Message = require('../../message.js');
const FTNAddress = require('../../ftn_address.js');
const {
    isAnsi,
    stripAnsiControlCodes,
    splitTextAtTerms,
} = require('../../string_util.js');
const AnsiPrep = require('../../ansi_prep.js');
const { stripMciColorCodes } = require('../../color_codes.js');

//  deps
const NNTPServerBase = require('nntp-server');
const _ = require('lodash');
const fs = require('fs-extra');
const forEachSeries = require('async/forEachSeries');
const asyncReduce = require('async/reduce');
const asyncMap = require('async/map');
const asyncSeries = require('async/series');
const asyncWaterfall = require('async/waterfall');
const LRU = require('lru-cache');
const sqlite3 = require('sqlite3');
const paths = require('path');

//
//  Network News Transfer Protocol (NNTP)
//
//  RFCS
//  - https://www.w3.org/Protocols/rfc977/rfc977
//  - https://tools.ietf.org/html/rfc3977
//  - https://tools.ietf.org/html/rfc2980
//  - https://tools.ietf.org/html/rfc5536

//
exports.moduleInfo = {
    name: 'NNTP',
    desc: 'Network News Transfer Protocol (NNTP) Server',
    author: 'NuSkooler',
    packageName: 'codes.l33t.enigma.nntp.server',
};

exports.performMaintenanceTask = performMaintenanceTask;

/*
    General TODO
    - ACS checks need worked out. Currently ACS relies on |client|. We need a client
      spec that can be created even without a login server. Some checks and simply
      return false/fail.
*/

//  simple DB maps NNTP Message-ID's which are
//  sequential per group -> ENiG messages
//  A single instance is shared across NNTP and/or NNTPS
class NNTPDatabase {
    constructor() {}

    init(cb) {
        asyncSeries(
            [
                callback => {
                    this.db = getTransactionDatabase(
                        new sqlite3.Database(
                            getModDatabasePath(exports.moduleInfo),
                            err => {
                                return callback(err);
                            }
                        )
                    );
                },
                callback => {
                    this.db.serialize(() => {
                        this.db.run(
                            `CREATE TABLE IF NOT EXISTS nntp_area_message (
                                nntp_message_id     INTEGER NOT NULL,
                                message_id          INTEGER NOT NULL,
                                message_area_tag    VARCHAR NOT NULL,
                                message_uuid        VARCHAR NOT NULL,

                                UNIQUE(nntp_message_id, message_area_tag)
                            );`
                        );

                        this.db.run(
                            `CREATE INDEX IF NOT EXISTS nntp_area_message_by_uuid_index
                            ON nntp_area_message (message_uuid);`
                        );

                        return callback(null);
                    });
                },
            ],
            err => {
                return cb(err);
            }
        );
    }
}

let nntpDatabase;

class NNTPServer extends NNTPServerBase {
    constructor(options, serverName) {
        super(options);

        this.log = Log.child({ server: serverName });

        const config = Config();
        this.groupCache = new LRU({
            max: _.get(config, 'contentServers.nntp.cache.maxItems', 200),
            ttl: _.get(config, 'contentServers.nntp.cache.maxAge', 1000 * 30), //  default=30s
        });
    }

    _needAuth(session, command) {
        return super._needAuth(session, command);
    }

    _authenticate(session) {
        const username = session.authinfo_user;
        const password = session.authinfo_pass;

        this.log.trace({ username }, 'Authentication request');

        return new Promise(resolve => {
            const user = new User();
            user.authenticateFactor1(
                { type: User.AuthFactor1Types.Password, username, password },
                err => {
                    if (err) {
                        //  :TODO: Log IP address
                        this.log.debug(
                            { username, reason: err.message },
                            'Authentication failure'
                        );
                        return resolve(false);
                    }

                    session.authUser = user;

                    this.log.debug({ username }, 'User authenticated successfully');
                    return resolve(true);
                }
            );
        });
    }

    isGroupSelected(session) {
        return Array.isArray(_.get(session, 'groupInfo.messageList'));
    }

    getJAMStyleFrom(message, fromName) {
        //
        //  Try to to create a (JamNTTPd) JAM style "From" field:
        //
        //  -   If we're dealing with a FTN address, create an email-like format
        //      but do not include ':' or '/' characters as it may cause clients
        //      to puke. FTN addresses are formatted how JamNTTPd does it for
        //      some sort of compliance. We also extend up to 5D addressing.
        //  -   If we have an email address, then it's ready to go.
        //
        const remoteFrom = _.get(message.meta, [
            'System',
            Message.SystemMetaNames.RemoteFromUser,
        ]);
        let jamStyleFrom;
        if (remoteFrom) {
            const flavor = _.get(message.meta, [
                'System',
                Message.SystemMetaNames.ExternalFlavor,
            ]);
            switch (flavor) {
                case [Message.AddressFlavor.FTN]:
                    {
                        let ftnAddr = FTNAddress.fromString(remoteFrom);
                        if (ftnAddr && ftnAddr.isValid()) {
                            //  In general, addresses are in point, node, net, zone, domain order
                            if (ftnAddr.domain) {
                                //  5D
                                // point.node.net.zone@domain or node.net.zone@domain
                                jamStyleFrom = `${ftnAddr.node}.${ftnAddr.net}.${ftnAddr.zone}@${ftnAddr.domain}`;
                                if (ftnAddr.point) {
                                    jamStyleFrom = `${ftnAddr.point}.` + jamStyleFrom;
                                }
                            } else {
                                if (ftnAddr.point) {
                                    jamStyleFrom = `${ftnAddr.point}@${ftnAddr.node}.${ftnAddr.net}.${ftnAddr.zone}`;
                                } else {
                                    jamStyleFrom = `0@${ftnAddr.node}.${ftnAddr.net}.${ftnAddr.zone}`;
                                }
                            }
                        }
                    }
                    break;

                case [Message.AddressFlavor.Email]:
                    jamStyleFrom = `${fromName} <${remoteFrom}>`;
                    break;
            }
        }

        if (!jamStyleFrom) {
            jamStyleFrom = fromName;
        }

        return jamStyleFrom;
    }

    populateNNTPHeaders(session, message, cb) {
        //
        //  Build compliant headers
        //
        //  Resources:
        //  - https://tools.ietf.org/html/rfc5536#section-3.1
        //  - https://github.com/ftnapps/jamnntpd/blob/master/src/nntpserv.c#L962
        //
        const toName = this.getMessageTo(message);
        const fromName = this.getMessageFrom(message);

        message.nntpHeaders = {
            From: this.getJAMStyleFrom(message, fromName),
            'X-Comment-To': toName,
            Newsgroups: session.group.name,
            Subject: message.subject,
            Date: this.getMessageDate(message),
            'Message-ID': this.getMessageIdentifier(message),
            Path: 'ENiGMA1/2!not-for-mail',
            'Content-Type': 'text/plain; charset=utf-8',
        };

        const externalFlavor = _.get(message.meta.System, [
            Message.SystemMetaNames.ExternalFlavor,
        ]);
        if (externalFlavor) {
            message.nntpHeaders['X-ENiG-MessageFlavor'] = externalFlavor;
        }

        //  Any FTN properties -> X-FTN-*
        _.each(message.meta.FtnProperty, (v, k) => {
            const suffix = {
                [Message.FtnPropertyNames.FtnTearLine]: 'Tearline',
                [Message.FtnPropertyNames.FtnOrigin]: 'Origin',
                [Message.FtnPropertyNames.FtnArea]: 'AREA',
                [Message.FtnPropertyNames.FtnSeenBy]: 'SEEN-BY',
            }[k];

            if (suffix) {
                //  some special treatment.
                if ('Tearline' === suffix) {
                    v = v.replace(/^--- /, '');
                } else if ('Origin' === suffix) {
                    v = v.replace(/^[ ]{1,2}\* Origin: /, '');
                }
                if (Array.isArray(v)) {
                    //  ie: SEEN-BY[] -> one big list
                    v = v.join(' ');
                }
                message.nntpHeaders[`X-FTN-${suffix}`] = v.trim();
            }
        });

        //  Other FTN kludges
        _.each(message.meta.FtnKludge, (v, k) => {
            if (Array.isArray(v)) {
                v = v.join(' '); //  same as above
            }
            message.nntpHeaders[`X-FTN-${k.toUpperCase()}`] = v.toString().trim();
        });

        //
        //  Set X-FTN-To and X-FTN-From:
        //  - If remote to/from : joeuser <remoteAddr>
        //  - Without remote    : joeuser
        //
        const remoteFrom = _.get(message.meta, [
            'System',
            Message.SystemMetaNames.RemoteFromUser,
        ]);
        message.nntpHeaders['X-FTN-From'] = remoteFrom
            ? `${fromName} <${remoteFrom}>`
            : fromName;
        const remoteTo = _.get(message.meta, [
            'System',
            Message.SystemMetaNames.RemoteToUser,
        ]);
        message.nntpHeaders['X-FTN-To'] = remoteTo ? `${toName} <${remoteTo}>` : toName;

        if (!message.replyToMsgId) {
            return cb(null);
        }

        //  replyToMessageId -> Message-ID formatted ID
        const filter = {
            resultType: 'uuid',
            ids: [parseInt(message.replyToMsgId)],
            limit: 1,
        };
        Message.findMessages(filter, (err, uuids) => {
            if (!err && Array.isArray(uuids)) {
                message.nntpHeaders.References = this.makeMessageIdentifier(
                    message.replyToMsgId,
                    uuids[0]
                );
            }
            return cb(null);
        });
    }

    getMessageUUIDFromMessageID(session, messageId) {
        let messageUuid;

        //  Direct ID request
        if (
            (_.isString(messageId) && '<' !== messageId.charAt(0)) ||
            _.isNumber(messageId)
        ) {
            //  group must be in session
            if (!this.isGroupSelected(session)) {
                return null;
            }

            messageId = parseInt(messageId);
            if (isNaN(messageId)) {
                return null;
            }

            const msg = session.groupInfo.messageList.find(m => {
                return m.index === messageId;
            });

            messageUuid = msg && msg.messageUuid;
        } else {
            //  <Message-ID> request
            [, messageUuid] = this.getMessageIdentifierParts(messageId);
        }

        if (!_.isString(messageUuid)) {
            return null;
        }

        return messageUuid;
    }

    _getArticle(session, messageId) {
        return new Promise(resolve => {
            this.log.trace({ messageId }, 'Get article');

            const messageUuid = this.getMessageUUIDFromMessageID(session, messageId);
            if (!messageUuid) {
                this.log.debug(
                    { messageId },
                    'Unable to retrieve message UUID for article request'
                );
                return resolve(null);
            }

            const message = new Message();
            asyncSeries(
                [
                    callback => {
                        return message.load({ uuid: messageUuid }, callback);
                    },
                    callback => {
                        if (!_.has(session, 'groupInfo.areaTag')) {
                            //  :TODO: if this is needed, how to validate properly?
                            this.log.warn(
                                { messageUuid, messageId },
                                'Get article request without group selection'
                            );
                            return resolve(null);
                        }

                        if (session.groupInfo.areaTag !== message.areaTag) {
                            return resolve(null);
                        }

                        if (
                            !this.hasConfAndAreaReadAccess(
                                session,
                                session.groupInfo.confTag,
                                session.groupInfo.areaTag
                            )
                        ) {
                            this.log.info(
                                { messageUuid, messageId },
                                'Access denied for message'
                            );
                            return resolve(null);
                        }

                        return callback(null);
                    },
                    callback => {
                        return this.populateNNTPHeaders(session, message, callback);
                    },
                    callback => {
                        return this.prepareMessageBody(message, callback);
                    },
                ],
                err => {
                    if (err) {
                        this.log.error(
                            { error: err.message, messageUuid },
                            'Failed to load article'
                        );
                        return resolve(null);
                    }

                    this.log.info(
                        { messageUuid, messageId, areaTag: message.areaTag },
                        'Serving article'
                    );
                    return resolve(message);
                }
            );
        });
    }

    _getRange(session, first, last /*options*/) {
        return new Promise(resolve => {
            //
            //  Build an array of message objects that can later
            //  be used with the various _build* methods.
            //
            //  :TODO: Handle |options|
            if (!this.isGroupSelected(session)) {
                return resolve(null);
            }

            const uuids = session.groupInfo.messageList
                .filter(m => {
                    if (m.areaTag !== session.groupInfo.areaTag) {
                        return false;
                    }
                    if (m.index < first || m.index > last) {
                        return false;
                    }
                    return true;
                })
                .map(m => {
                    return { uuid: m.messageUuid, index: m.index };
                });

            asyncMap(
                uuids,
                (msgInfo, nextMessageUuid) => {
                    const message = new Message();
                    message.load({ uuid: msgInfo.uuid }, err => {
                        if (err) {
                            return nextMessageUuid(err);
                        }

                        message.index = msgInfo.index;

                        this.populateNNTPHeaders(session, message, () => {
                            this.prepareMessageBody(message, () => {
                                return nextMessageUuid(null, message);
                            });
                        });
                    });
                },
                (err, messages) => {
                    return resolve(err ? null : messages);
                }
            );
        });
    }

    _selectGroup(session, groupName) {
        this.log.trace({ groupName }, 'Select group request');

        return new Promise(resolve => {
            this.getGroup(session, groupName, (err, group) => {
                if (err) {
                    return resolve(false);
                }

                session.group = Object.assign(
                    {}, //  start clean
                    {
                        description: group.friendlyDesc || group.friendlyName,
                        current_article: group.nntp.total ? group.nntp.min_index : 0,
                    },
                    group.nntp
                );

                session.groupInfo = group; //  full set of info

                return resolve(true);
            });
        });
    }

    _getGroups(session, time, wildmat) {
        this.log.trace({ time, wildmat }, 'Get groups request');

        //  :TODO: handle time - probably use as caching mechanism - must consider user/auth/rights
        //  :TODO: handle |time| if possible.
        return new Promise((resolve, reject) => {
            const config = Config();

            //  :TODO: merge confs avail to authenticated user
            const publicConfs = _.get(
                config,
                'contentServers.nntp.publicMessageConferences',
                {}
            );

            asyncReduce(
                Object.keys(publicConfs),
                [],
                (groups, confTag, nextConfTag) => {
                    const areaTags = publicConfs[confTag];
                    //  :TODO: merge area tags available to authenticated user
                    asyncMap(
                        areaTags,
                        (areaTag, nextAreaTag) => {
                            const groupName = this.getGroupName(confTag, areaTag);

                            //  filter on |wildmat| if supplied. We will remove
                            //  empty areas below in the final results.
                            if (wildmat && !wildmat.test(groupName)) {
                                return nextAreaTag(null, null);
                            }

                            this.getGroup(session, groupName, (err, group) => {
                                if (err) {
                                    return nextAreaTag(null, null); //  try others
                                }
                                return nextAreaTag(null, group.nntp);
                            });
                        },
                        (err, areas) => {
                            if (err) {
                                return nextConfTag(err);
                            }

                            areas = areas.filter(a => a && Object.keys(a).length > 0); //  remove empty
                            groups.push(...areas);

                            return nextConfTag(null, groups);
                        }
                    );
                },
                (err, groups) => {
                    if (err) {
                        return reject(err);
                    }
                    return resolve(groups);
                }
            );
        });
    }

    isConfAndAreaPubliclyExposed(confTag, areaTag) {
        const publicAreaTags = _.get(Config(), [
            'contentServers',
            'nntp',
            'publicMessageConferences',
            confTag,
        ]);
        return Array.isArray(publicAreaTags) && publicAreaTags.includes(areaTag);
    }

    hasConfAndAreaReadAccess(session, confTag, areaTag) {
        if (Message.isPrivateAreaTag(areaTag)) {
            return false;
        }

        if (this.isConfAndAreaPubliclyExposed(confTag, areaTag)) {
            return true;
        }

        //  further checks require an authenticated user & ACS
        if (!session || !session.authUser) {
            return false;
        }

        const conf = getMessageConferenceByTag(confTag);
        if (!conf) {
            return false;
        }
        //  :TODO: validate ACS

        const area = getMessageAreaByTag(areaTag, confTag);
        if (!area) {
            return false;
        }
        //  :TODO: validate ACS

        return false;
    }

    getGroup(session, groupName, cb) {
        let group = this.groupCache.get(groupName);
        if (group) {
            return cb(null, group);
        }

        const [confTag, areaTag] = groupName.split('.');
        if (!confTag || !areaTag) {
            return cb(Errors.UnexpectedState(`Invalid NNTP group name: ${groupName}`));
        }

        if (!this.hasConfAndAreaReadAccess(session, confTag, areaTag)) {
            return cb(
                Errors.AccessDenied(
                    `No access to conference ${confTag} and/or area ${areaTag}`
                )
            );
        }

        const area = getMessageAreaByTag(areaTag, confTag);
        if (!area) {
            return cb(
                Errors.DoesNotExist(
                    `No area for areaTag "${areaTag}" / confTag "${confTag}"`
                )
            );
        }

        this.getMappedMessageListForArea(areaTag, (err, messageList) => {
            if (err) {
                return cb(err);
            }

            if (0 === messageList.length) {
                //
                //  Handle empty group
                //  See https://tools.ietf.org/html/rfc3977#section-6.1.1.2
                //
                return cb(null, {
                    messageList: [],
                    confTag,
                    areaTag,
                    friendlyName: area.name,
                    friendlyDesc: area.desc,
                    nntp: {
                        name: groupName,
                        description: area.desc,
                        min_index: 0,
                        max_index: 0,
                        total: 0,
                    },
                });
            }

            group = {
                messageList,
                confTag,
                areaTag,
                friendlyName: area.name,
                friendlyDesc: area.desc,
                nntp: {
                    name: groupName,
                    min_index: messageList[0].index,
                    max_index: messageList[messageList.length - 1].index,
                    total: messageList.length,
                },
            };

            this.groupCache.set(groupName, group);

            return cb(null, group);
        });
    }

    getMappedMessageListForArea(areaTag, cb) {
        //
        //  Get all messages in mapped database. Then, find any messages that are not
        //  yet mapped with ID's > the highest ID we have. Any new messages will have
        //  new mappings created.
        //
        //  :TODO: introduce caching
        asyncWaterfall(
            [
                callback => {
                    nntpDatabase.db.all(
                        `SELECT nntp_message_id, message_id, message_uuid
                        FROM nntp_area_message
                        WHERE message_area_tag = ?
                        ORDER BY nntp_message_id;`,
                        [areaTag],
                        (err, rows) => {
                            if (err) {
                                return callback(err);
                            }

                            let messageList;
                            const lastMessageId =
                                rows.length > 0 ? rows[rows.length - 1].message_id : 0;
                            if (!lastMessageId) {
                                messageList = [];
                            } else {
                                messageList = rows.map(r => {
                                    return {
                                        areaTag,
                                        index: r.nntp_message_id, //  node-nntp wants this name
                                        messageUuid: r.message_uuid,
                                    };
                                });
                            }

                            return callback(null, messageList, lastMessageId);
                        }
                    );
                },
                (messageList, lastMessageId, callback) => {
                    //  Find any new entries
                    const filter = {
                        areaTag,
                        newerThanMessageId: lastMessageId,
                        sort: 'messageId',
                        order: 'ascending',
                        resultType: 'messageList',
                    };
                    Message.findMessages(filter, (err, newMessageList) => {
                        if (err) {
                            return callback(err);
                        }

                        let index =
                            messageList.length > 0
                                ? messageList[messageList.length - 1].index + 1
                                : 1;
                        newMessageList = newMessageList.map(m => {
                            return Object.assign(m, { index: index++ });
                        });

                        if (0 === newMessageList.length) {
                            return callback(null, messageList);
                        }

                        //  populate mapping DB with any new entries
                        nntpDatabase.db.beginTransaction((err, trans) => {
                            if (err) {
                                return callback(err);
                            }

                            forEachSeries(
                                newMessageList,
                                (newMessage, nextNewMessage) => {
                                    trans.run(
                                        `INSERT INTO nntp_area_message (nntp_message_id, message_id, message_area_tag, message_uuid)
                                    VALUES (?, ?, ?, ?);`,
                                        [
                                            newMessage.index,
                                            newMessage.messageId,
                                            areaTag,
                                            newMessage.messageUuid,
                                        ],
                                        err => {
                                            return nextNewMessage(err);
                                        }
                                    );
                                },
                                err => {
                                    if (err) {
                                        return trans.rollback(() => {
                                            return callback(err);
                                        });
                                    }

                                    trans.commit(() => {
                                        messageList.push(
                                            ...newMessageList.map(m => {
                                                return {
                                                    areaTag,
                                                    index: m.nntpMessageId,
                                                    messageUuid: m.messageUuid,
                                                };
                                            })
                                        );

                                        return callback(null, messageList);
                                    });
                                }
                            );
                        });
                    });
                },
            ],
            (err, messageList) => {
                return cb(err, messageList);
            }
        );
    }

    _buildHead(session, message) {
        return _.map(message.nntpHeaders, (v, k) => `${k}: ${v}`).join('\r\n');
    }

    _buildBody(session, message) {
        return message.preparedBody;
    }

    _buildHeaderField(session, message, field) {
        const body = message.preparedBody || message.message;
        const value =
            {
                ':bytes': Buffer.byteLength(body).toString(),
                ':lines': splitTextAtTerms(body).length.toString(),
            }[field] ||
            _.find(message.nntpHeaders, (v, k) => {
                return k.toLowerCase() === field;
            });

        if (!value) {
            //
            //  Clients will check some headers just to see if they exist.
            //  Don't spam logs with these. For others, it's good to know.
            //
            if (!['references', 'xref'].includes(field)) {
                this.log.trace(`No value for requested header field "${field}"`);
            }
        }

        return value;
    }

    _getOverviewFmt(session) {
        return super._getOverviewFmt(session);
    }

    _getNewNews(session, time, wildmat) {
        //  Currently seems pointless to implement. No semi-modern clients seem to use it anyway.
        this.log.debug(
            { time, wildmat },
            'Request made using unsupported NEWNEWS command'
        );
        throw new Errors.Invalid('NEWNEWS is not enabled on this server');
    }

    getMessageDate(message) {
        //  https://tools.ietf.org/html/rfc5536#section-3.1.1 -> https://tools.ietf.org/html/rfc5322#section-3.3
        return message.modTimestamp.format('ddd, D MMM YYYY HH:mm:ss ZZ');
    }

    makeMessageIdentifier(messageId, messageUuid) {
        //
        //  Spec        : RFC-5536 Section 3.1.3 @ https://tools.ietf.org/html/rfc5536#section-3.1.3
        //  Example     : <2456.0f6587f7-5512-4d03-8740-4d592190145a@enigma-bbs>
        //
        return `<${messageId}.${messageUuid}@enigma-bbs>`;
    }

    getMessageIdentifier(message) {
        //  note that we use the *real* message ID here, not the NNTP-specific index.
        return this.makeMessageIdentifier(message.messageId, message.messageUuid);
    }

    getMessageIdentifierParts(messageId) {
        const m = messageId.match(
            /<([0-9]+)\.([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})@enigma-bbs>/
        );
        if (m) {
            return [m[1], m[2]];
        }
        return [];
    }

    getMessageTo(message) {
        //  :TODO: same as From -- check config
        return message.toUserName;
    }

    getMessageFrom(message) {
        //  :TODO: NNTP config > conf > area config for real names
        return message.fromUserName;
    }

    prepareMessageBody(message, cb) {
        if (isAnsi(message.message)) {
            AnsiPrep(
                message.message,
                {
                    rows: 'auto',
                    cols: 79,
                    forceLineTerm: true,
                    asciiMode: true,
                    fillLines: false,
                },
                (err, prepped) => {
                    message.preparedBody = prepped || message.message;
                    return cb(null);
                }
            );
        } else {
            message.preparedBody = stripMciColorCodes(
                stripAnsiControlCodes(message.message, { all: true })
            );
            return cb(null);
        }
    }

    getGroupName(confTag, areaTag) {
        //
        //  Example:
        //  input : fsxNet (confTag) fsx_bbs (areaTag)
        //  output: fsx_net.fsx_bbs
        //
        //  Note also that periods are replaced in conf and area
        //  tags such that we *only* have a period separator
        //  between the two for a group name!
        //
        return `${_.snakeCase(confTag).replace(/\./g, '_')}.${_.snakeCase(
            areaTag
        ).replace(/\./g, '_')}`;
    }
}

exports.getModule = class NNTPServerModule extends ServerModule {
    constructor() {
        super();
    }

    isEnabled() {
        return this.enableNntp || this.enableNttps;
    }

    get enableNntp() {
        return _.get(Config(), 'contentServers.nntp.nntp.enabled', false);
    }

    get enableNttps() {
        return _.get(Config(), 'contentServers.nntp.nntps.enabled', false);
    }

    isConfigured() {
        const config = Config();

        //
        //  Any conf/areas exposed?
        //
        const publicConfs = _.get(
            config,
            'contentServers.nntp.publicMessageConferences',
            {}
        );
        const areasExposed = _.some(publicConfs, areas => {
            return Array.isArray(areas) && areas.length > 0;
        });

        if (!areasExposed) {
            return false;
        }

        const nntp = _.get(config, 'contentServers.nntp.nntp');
        if (nntp && this.enableNntp) {
            if (isNaN(nntp.port)) {
                return false;
            }
        }

        const nntps = _.get(config, 'contentServers.nntp.nntps');
        if (nntps && this.enableNttps) {
            if (isNaN(nntps.port)) {
                return false;
            }

            if (!_.isString(nntps.certPem) || !_.isString(nntps.keyPem)) {
                return false;
            }
        }

        return true;
    }

    createServer(cb) {
        if (!this.isEnabled() || !this.isConfigured()) {
            return cb(null);
        }

        const config = Config();

        const commonOptions = {
            //requireAuth : true,   //  :TODO: re-enable!
            //  :TODO: override |session| - use our own debug to Bunyan, etc.
        };

        if (this.enableNntp) {
            this.nntpServer = new NNTPServer(
                //  :TODO: according to docs: if connection is non-tls, but behind proxy (assuming TLS termination?!!) then set this to true
                Object.assign({ secure: false }, commonOptions),
                'NNTP'
            );
        }

        if (this.enableNttps) {
            this.nntpsServer = new NNTPServer(
                Object.assign(
                    {
                        secure: true,
                        tls: {
                            cert: fs.readFileSync(
                                config.contentServers.nntp.nntps.certPem
                            ),
                            key: fs.readFileSync(config.contentServers.nntp.nntps.keyPem),
                        },
                    },
                    commonOptions
                ),
                'NTTPS'
            );
        }

        nntpDatabase = new NNTPDatabase();
        nntpDatabase.init(err => {
            return cb(err);
        });
    }

    listen(cb) {
        const config = Config();
        forEachSeries(
            ['nntp', 'nntps'],
            (service, nextService) => {
                const server = this[`${service}Server`];
                if (server) {
                    const port = config.contentServers.nntp[service].port;
                    server
                        .listen(this.listenURI(port, service))
                        .catch(e => {
                            Log.warn(
                                { error: e.message, port },
                                `${service.toUpperCase()} failed to listen`
                            );
                            return nextService(null); //  try next anyway
                        })
                        .then(() => {
                            return nextService(null);
                        });
                } else {
                    return nextService(null);
                }
            },
            err => {
                return cb(err);
            }
        );
    }

    listenURI(port, service = 'nntp') {
        return `${service}://0.0.0.0:${port}`;
    }
};

function performMaintenanceTask(args, cb) {
    //
    //  Delete any message mapping that no longer have
    //  an actual message associated with them.
    //
    if (!nntpDatabase) {
        Log.trace('Cannot perform NNTP maintenance without NNTP database initialized');
        return cb(null);
    }

    let attached = false;
    asyncSeries(
        [
            callback => {
                const messageDbPath = paths.join(Config().paths.db, 'message.sqlite3');
                nntpDatabase.db.run(
                    `ATTACH DATABASE "${messageDbPath}" AS msgdb;`,
                    err => {
                        attached = !err;
                        return callback(err);
                    }
                );
            },
            callback => {
                nntpDatabase.db.run(
                    `DELETE FROM nntp_area_message
                    WHERE message_uuid NOT IN (
                        SELECT message_uuid
                        FROM msgdb.message
                    );`,
                    function result(err) {
                        //  no arrow func; need |this.changes|
                        if (err) {
                            Log.warn(
                                { error: err.message },
                                'Failed to delete from NNTP database'
                            );
                        } else {
                            Log.debug(
                                { count: this.changes },
                                'Deleted mapped message IDs from NNTP database'
                            );
                        }
                        return callback(err);
                    }
                );
            },
        ],
        err => {
            if (attached) {
                nntpDatabase.db.run('DETACH DATABASE msgdb;');
            }
            return cb(err);
        }
    );
}