const ArchiveUtil = require('./archive_util');
const { Errors } = require('./enig_error');
const Message = require('./message');
const { splitTextAtTerms } = require('./string_util');
const {
    getMessageConfTagByAreaTag,
    getMessageAreaByTag,
    getMessageConferenceByTag,
    getAllAvailableMessageAreaTags,
} = require('./message_area');
const StatLog = require('./stat_log');
const Config = require('./config').get;
const SysProps = require('./system_property');
const UserProps = require('./user_property');
const { numToMbf32 } = require('./mbf');
const { getEncodingFromCharacterSetIdentifier } = require('./ftn_util');

const { EventEmitter } = require('events');
const temptmp = require('temptmp');
const async = require('async');
const fs = require('graceful-fs');
const paths = require('path');
const { Parser } = require('binary-parser');
const iconv = require('iconv-lite');
const moment = require('moment');
const _ = require('lodash');
const IniConfigParser = require('ini-config-parser');

const enigmaVersion = require('../package.json').version;

//  Synchronet smblib TZ to a UTC offset
//  see https://github.com/kvadevack/synchronet/blob/master/src/smblib/smbdefs.h
const SMBTZToUTCOffset = {
    //  US Standard
    '40F0': '-04:00', //  Atlantic
    '412C': '-05:00', //  Eastern
    4168: '-06:00', //  Central
    '41A4': '-07:00', //  Mountain
    '41E0': '-08:00', //  Pacific
    '421C': '-09:00', //  Yukon
    4258: '-10:00', //  Hawaii/Alaska
    4294: '-11:00', //  Bering

    //  US Daylight
    C0F0: '-03:00', //  Atlantic
    C12C: '-04:00', //  Eastern
    C168: '-05:00', //  Central
    C1A4: '-06:00', //  Mountain
    C1E0: '-07:00', //  Pacific
    C21C: '-08:00', //  Yukon
    C258: '-09:00', //  Hawaii/Alaska
    C294: '-10:00', //  Bering

    //  "Non-Standard"
    2294: '-11:00', //  Midway
    '21E0': '-08:00', //  Vancouver
    '21A4': '-07:00', //  Edmonton
    2168: '-06:00', //  Winnipeg
    '212C': '-05:00', //  Bogota
    '20F0': '-04:00', //  Caracas
    '20B4': '-03:00', //  Rio de Janeiro
    2078: '-02:00', //  Fernando de Noronha
    '203C': '-01:00', //  Azores
    1000: '+00:00', //  London
    '103C': '+01:00', //  Berlin
    1078: '+02:00', //  Athens
    '10B4': '+03:00', //  Moscow
    '10F0': '+04:00', //  Dubai
    '110E': '+04:30', //  Kabul
    '112C': '+05:00', //  Karachi
    '114A': '+05:30', //  Bombay
    1159: '+05:45', //  Kathmandu
    1168: '+06:00', //  Dhaka
    '11A4': '+07:00', //  Bangkok
    '11E0': '+08:00', //  Hong Kong
    '121C': '+09:00', //  Tokyo
    1258: '+10:00', //  Sydney
    1294: '+11:00', //  Noumea
    '12D0': '+12:00', //  Wellington
};

const UTCOffsetToSMBTZ = _.invert(SMBTZToUTCOffset);

const QWKMessageBlockSize = 128;
const QWKHeaderTimestampFormat = 'MM-DD-YYHH:mm';
const QWKLF = 0xe3;

const QWKMessageStatusCodes = {
    UnreadPublic: ' ',
    ReadPublic: '-',
    UnreadPrivate: '+',
    ReadPrivate: '*',
    UnreadCommentToSysOp: '~',
    ReadCommentToSysOp: '`',
    UnreadSenderPWProtected: '%',
    ReadSenderPWProtected: '^',
    UnreadGroupPWProtected: '!',
    ReadGroupPWProtected: '#',
    PWProtectedToAll: '$',
    Vote: 'V',
};

const QWKMessageActiveStatus = {
    Active: 255,
    Deleted: 226,
};

const QWKNetworkTagIndicator = {
    Present: '*',
    NotPresent: ' ',
};

//  See the following:
//  -   http://fileformats.archiveteam.org/wiki/QWK
//  -   http://wiki.synchro.net/ref:qwk
//
const MessageHeaderParser = new Parser()
    .endianess('little')
    .string('status', {
        encoding: 'ascii',
        length: 1,
    })
    .string('num', {
        //  message num or conf num for REP's
        encoding: 'ascii',
        length: 7,
        formatter: n => {
            return parseInt(n);
        },
    })
    .string('timestamp', {
        encoding: 'ascii',
        length: 13,
    })
    //  these fields may be encoded in something other than ascii/CP437
    .array('toName', {
        type: 'uint8',
        length: 25,
    })
    .array('fromName', {
        type: 'uint8',
        length: 25,
    })
    .array('subject', {
        type: 'uint8',
        length: 25,
    })
    .string('password', {
        encoding: 'ascii',
        length: 12,
    })
    .string('replyToNum', {
        encoding: 'ascii',
        length: 8,
        formatter: n => {
            return parseInt(n);
        },
    })
    .string('numBlocks', {
        encoding: 'ascii',
        length: 6,
        formatter: n => {
            return parseInt(n);
        },
    })
    .uint8('status2')
    .uint16('confNum')
    .uint16('relNum')
    .uint8('netTag');

const replaceCharInBuffer = (buffer, search, replace) => {
    let i = 0;
    search = Buffer.from([search]);
    while (i < buffer.length) {
        i = buffer.indexOf(search, i);
        if (-1 === i) {
            break;
        }
        buffer[i] = replace;
        ++i;
    }
};

class QWKPacketReader extends EventEmitter {
    constructor(
        packetPath,
        { mode = QWKPacketReader.Modes.Guess, keepTearAndOrigin = true } = {
            mode: QWKPacketReader.Modes.Guess,
            keepTearAndOrigin: true,
        }
    ) {
        super();

        this.packetPath = packetPath;
        this.options = { mode, keepTearAndOrigin };
        this.temptmp = temptmp.createTrackedSession('qwkpacketreader');
    }

    static get Modes() {
        return {
            Guess: 'guess', //  try to guess
            QWK: 'qwk', //  standard incoming packet
            REP: 'rep', //  a reply packet
        };
    }

    read() {
        //
        //  A general overview:
        //
        //  - Find out what kind of archive we're dealing with
        //  - Extract to temporary location
        //  - Process various files
        //  - Emit messages we find, information about the packet, so on
        //
        async.waterfall(
            [
                //  determine packet archive type
                callback => {
                    const archiveUtil = ArchiveUtil.getInstance();
                    archiveUtil.detectType(this.packetPath, (err, archiveType) => {
                        if (err) {
                            return callback(err);
                        }
                        this.emit('archive type', archiveType);
                        return callback(null, archiveType);
                    });
                },
                //  create a temporary location to do processing
                (archiveType, callback) => {
                    this.temptmp.mkdir({ prefix: 'enigqwkreader-' }, (err, tempDir) => {
                        if (err) {
                            return callback(err);
                        }

                        return callback(null, archiveType, tempDir);
                    });
                },
                //  extract it
                (archiveType, tempDir, callback) => {
                    const archiveUtil = ArchiveUtil.getInstance();
                    archiveUtil.extractTo(this.packetPath, tempDir, archiveType, err => {
                        if (err) {
                            return callback(err);
                        }

                        return callback(null, tempDir);
                    });
                },
                //  gather extracted file list
                (tempDir, callback) => {
                    fs.readdir(tempDir, (err, files) => {
                        if (err) {
                            return callback(err);
                        }

                        //  Discover basic information about well known files
                        async.reduce(
                            files,
                            {},
                            (out, filename, next) => {
                                const key = filename.toUpperCase();

                                switch (key) {
                                    case 'MESSAGES.DAT': //  QWK
                                        if (
                                            this.options.mode ===
                                            QWKPacketReader.Modes.Guess
                                        ) {
                                            this.options.mode = QWKPacketReader.Modes.QWK;
                                        }
                                        if (
                                            this.options.mode ===
                                            QWKPacketReader.Modes.QWK
                                        ) {
                                            out.messages = { filename };
                                        }
                                        break;

                                    case 'ID.MSG':
                                        if (
                                            this.options.mode ===
                                            QWKPacketReader.Modes.Guess
                                        ) {
                                            this.options.mode = QWKPacketReader.Modes.REP;
                                        }

                                        if (
                                            this.options.mode ===
                                            QWKPacketReader.Modes.REP
                                        ) {
                                            out.messages = { filename };
                                        }
                                        break;

                                    case 'HEADERS.DAT': //  Synchronet
                                        out.headers = { filename };
                                        break;

                                    case 'VOTING.DAT': //  Synchronet
                                        out.voting = { filename };
                                        break;

                                    case 'CONTROL.DAT': //  QWK
                                        out.control = { filename };
                                        break;

                                    case 'DOOR.ID': //  QWK
                                        out.door = { filename };
                                        break;

                                    case 'NETFLAGS.DAT': //  QWK
                                        out.netflags = { filename };
                                        break;

                                    case 'NEWFILES.DAT': //  QWK
                                        out.newfiles = { filename };
                                        break;

                                    case 'PERSONAL.NDX': //    QWK
                                        out.personal = { filename };
                                        break;

                                    case '000.NDX': // QWK
                                        out.inbox = { filename };
                                        break;

                                    case 'TOREADER.EXT': //  QWKE
                                        out.toreader = { filename };
                                        break;

                                    case 'QLR.DAT':
                                        out.qlr = { filename };
                                        break;

                                    default:
                                        if (/[0-9]+\.NDX/.test(key)) {
                                            //  QWK
                                            out.pointers = out.pointers || {
                                                filenames: [],
                                            };
                                            out.pointers.filenames.push(filename);
                                        } else {
                                            out[key] = { filename };
                                        }
                                        break;
                                }

                                return next(null, out);
                            },
                            (err, packetFileInfo) => {
                                this.packetInfo = Object.assign({}, packetFileInfo, {
                                    tempDir,
                                });
                                return callback(null);
                            }
                        );
                    });
                },
                callback => {
                    return this.processPacketFiles(callback);
                },
            ],
            err => {
                this.temptmp.cleanup();

                if (err) {
                    return this.emit('error', err);
                }

                this.emit('done');
            }
        );
    }

    processPacketFiles(cb) {
        async.series(
            [
                callback => {
                    return this.readControl(callback);
                },
                callback => {
                    return this.readHeadersExtension(callback);
                },
                callback => {
                    return this.readMessages(callback);
                },
            ],
            err => {
                return cb(err);
            }
        );
    }

    readControl(cb) {
        //
        //  CONTROL.DAT is a CRLF text file containing information about
        //  the originating BBS, conf number <> name mapping, etc.
        //
        //  References:
        //  -   http://fileformats.archiveteam.org/wiki/QWK
        //
        if (!this.packetInfo.control) {
            return cb(Errors.DoesNotExist('No control file found within QWK packet'));
        }

        const path = paths.join(
            this.packetInfo.tempDir,
            this.packetInfo.control.filename
        );

        //  note that we read as UTF-8. Legacy says it should be CP437/ASCII
        //  but this seems safer for now so conference names and the like
        //  can be non-English for example.
        fs.readFile(path, { encoding: 'utf8' }, (err, controlLines) => {
            if (err) {
                return cb(err);
            }

            controlLines = splitTextAtTerms(controlLines);

            let state = 'header';
            const control = { confMap: {} };
            let currConfNumber;
            for (let lineNumber = 0; lineNumber < controlLines.length; ++lineNumber) {
                const line = controlLines[lineNumber].trim();
                switch (lineNumber) {
                    //  first set of lines is header info
                    case 0:
                        control.bbsName = line;
                        break;
                    case 1:
                        control.bbsLocation = line;
                        break;
                    case 2:
                        control.bbsPhone = line;
                        break;
                    case 3:
                        control.bbsSysOp = line;
                        break;
                    case 4:
                        control.doorRegAndBoardID = line;
                        break;
                    case 5:
                        control.packetCreationTime = line;
                        break;
                    case 6:
                        control.toUser = line;
                        break;
                    case 7:
                        break; //  Qmail menu
                    case 8:
                        break; //  unknown, always 0?
                    case 9:
                        break; //  total messages in packet (often set to 0)
                    case 10:
                        control.totalMessages = parseInt(line) + 1;
                        state = 'confNumber';
                        break;

                    default:
                        switch (state) {
                            case 'confNumber':
                                currConfNumber = parseInt(line);
                                if (isNaN(currConfNumber)) {
                                    state = 'news';

                                    control.welcomeFile = line;
                                } else {
                                    state = 'confName';
                                }
                                break;

                            case 'confName':
                                control.confMap[currConfNumber] = line;
                                state = 'confNumber';
                                break;

                            case 'news':
                                control.newsFile = line;
                                state = 'logoff';
                                break;

                            case 'logoff':
                                control.logoffFile = line;
                                state = 'footer';
                                break;

                            case 'footer':
                                //  some systems append additional info; we don't care.
                                break;
                        }
                }
            }

            return cb(null);
        });
    }

    readHeadersExtension(cb) {
        if (!this.packetInfo.headers) {
            return cb(null); //  nothing to do
        }

        const path = paths.join(
            this.packetInfo.tempDir,
            this.packetInfo.headers.filename
        );
        fs.readFile(path, { encoding: 'utf8' }, (err, iniData) => {
            if (err) {
                this.emit(
                    'warning',
                    Errors.Invalid(`Problem reading HEADERS.DAT: ${err.message}`)
                );
                return cb(null); //  non-fatal
            }

            try {
                const parserOptions = {
                    lineComment: false, //  no line comments; consume full lines
                    nativeType: false, //  just keep everything as strings
                    dotKey: false, //  'a.b.c = value' stays 'a.b.c = value'
                };
                this.packetInfo.headers.ini = IniConfigParser.parse(
                    iniData,
                    parserOptions
                );
            } catch (e) {
                this.emit(
                    'warning',
                    Errors.Invalid(`HEADERS.DAT file appears to be invalid: ${e.message}`)
                );
            }

            return cb(null);
        });
    }

    readMessages(cb) {
        if (!this.packetInfo.messages) {
            return cb(Errors.DoesNotExist('No messages file found within QWK packet'));
        }

        const encodingToSpec = 'cp437';
        let encoding;

        const path = paths.join(
            this.packetInfo.tempDir,
            this.packetInfo.messages.filename
        );
        fs.open(path, 'r', (err, fd) => {
            if (err) {
                return cb(err);
            }

            //  Some mappings/etc. used in loops below....
            //  Sync sets these in HEADERS.DAT: http://wiki.synchro.net/ref:qwk
            const FTNPropertyMapping = {
                'X-FTN-AREA': Message.FtnPropertyNames.FtnArea,
                'X-FTN-SEEN-BY': Message.FtnPropertyNames.FtnSeenBy,
            };

            const FTNKludgeMapping = {
                'X-FTN-PATH': 'PATH',
                'X-FTN-MSGID': 'MSGID',
                'X-FTN-REPLY': 'REPLY',
                'X-FTN-PID': 'PID',
                'X-FTN-FLAGS': 'FLAGS',
                'X-FTN-TID': 'TID',
                'X-FTN-CHRS': 'CHRS',
                //  :TODO: X-FTN-KLUDGE - not sure what this is?
            };

            //
            //  Various kludge tags defined by QWKE, etc.
            //  See the following:
            //  - ftp://vert.synchro.net/main/BBS/qwke.txt
            //  - http://wiki.synchro.net/ref:qwk
            //
            const Kludges = {
                //  QWKE
                To: 'To:',
                From: 'From:',
                Subject: 'Subject:',

                //  Synchronet
                Via: '@VIA:',
                MsgID: '@MSGID:',
                Reply: '@REPLY:',
                TZ: '@TZ:', //  https://github.com/kvadevack/synchronet/blob/master/src/smblib/smbdefs.h
                ReplyTo: '@REPLYTO:',

                //  :TODO: Look into other non-standards
                //  https://github.com/wmcbrine/MultiMail/blob/master/mmail/qwk.cc
                //  title, @subject, etc.
            };

            let blockCount = 0;
            let currMessage = {};
            let state;
            let messageBlocksRemain;
            const buffer = Buffer.alloc(QWKMessageBlockSize);

            const readNextBlock = () => {
                fs.read(fd, buffer, 0, QWKMessageBlockSize, null, (err, read) => {
                    if (err) {
                        return cb(err);
                    }

                    if (0 == read) {
                        //  we're done consuming all blocks
                        return fs.close(fd, err => {
                            return cb(err);
                        });
                    }

                    if (QWKMessageBlockSize !== read) {
                        return cb(
                            Errors.Invalid(
                                `Invalid QWK message block size. Expected ${QWKMessageBlockSize} got ${read}`
                            )
                        );
                    }

                    if (0 === blockCount) {
                        //  first 128 bytes is a space padded ID
                        const id = buffer.toString('ascii').trim();
                        this.emit('creator', id);
                        state = 'header';
                    } else {
                        switch (state) {
                            case 'header':
                                {
                                    const header = MessageHeaderParser.parse(buffer);
                                    encoding = encodingToSpec; //  reset per message

                                    //  massage into something a little more sane (things we can't quite do in the parser directly)
                                    ['toName', 'fromName', 'subject'].forEach(field => {
                                        //  note: always use to-spec encoding here
                                        header[field] = iconv
                                            .decode(header[field], encodingToSpec)
                                            .trim();
                                    });

                                    header.timestamp = moment(
                                        header.timestamp,
                                        QWKHeaderTimestampFormat
                                    );

                                    currMessage = {
                                        header,
                                        //  these may be overridden
                                        toName: header.toName,
                                        fromName: header.fromName,
                                        subject: header.subject,
                                    };

                                    if (_.has(this.packetInfo, 'headers.ini')) {
                                        //  Sections for a message in HEADERS.DAT are by current byte offset.
                                        //  128 = first message header = 0x80 = section [80]
                                        const headersSectionId = (
                                            blockCount * QWKMessageBlockSize
                                        ).toString(16);
                                        currMessage.headersExtension =
                                            this.packetInfo.headers.ini[headersSectionId];
                                    }

                                    //  if we have HEADERS.DAT with a 'Utf8' override for this message,
                                    //  the overridden to/from/subject/message fields are UTF-8
                                    if (
                                        currMessage.headersExtension &&
                                        'true' ===
                                            currMessage.headersExtension.Utf8.toLowerCase()
                                    ) {
                                        encoding = 'utf8';
                                    }

                                    //  remainder of blocks until the end of this message
                                    messageBlocksRemain = header.numBlocks - 1;
                                    state = 'message';
                                }
                                break;

                            case 'message':
                                if (!currMessage.body) {
                                    currMessage.body = Buffer.from(buffer);
                                } else {
                                    currMessage.body = Buffer.concat([
                                        currMessage.body,
                                        buffer,
                                    ]);
                                }
                                messageBlocksRemain -= 1;

                                if (0 === messageBlocksRemain) {
                                    //  1:n buffers to make up body. Decode:
                                    //  First, replace QWK style line feeds (0xe3) unless the message is UTF-8.
                                    //  If the message is UTF-8, we assume it's using standard line feeds.
                                    if (encoding !== 'utf8') {
                                        replaceCharInBuffer(
                                            currMessage.body,
                                            QWKLF,
                                            0x0a
                                        );
                                    }

                                    //
                                    //  Decode the message based on our final message encoding. Split the message
                                    //  into lines so we can extract various bits such as QWKE headers, origin, tear
                                    //  lines, etc.
                                    //
                                    const messageLines = splitTextAtTerms(
                                        iconv.decode(currMessage.body, encoding).trimEnd()
                                    );
                                    const bodyLines = [];

                                    let bodyState = 'kludge';

                                    const MessageTrailers = {
                                        //  While technically FTN oriented, these can come from any network
                                        //  (though we'll be processing a lot of messages that routed through FTN
                                        //  at some point)
                                        Origin: /^[ ]{1,2}\* Origin: /,
                                        Tear: /^--- /,
                                    };

                                    const qwkKludge = {};
                                    const ftnProperty = {};
                                    const ftnKludge = {};

                                    messageLines.forEach(line => {
                                        if (0 === line.length) {
                                            return bodyLines.push('');
                                        }

                                        switch (bodyState) {
                                            case 'kludge':
                                                //  :TODO: Update these to use the well known consts:
                                                if (line.startsWith(Kludges.To)) {
                                                    currMessage.toName = line
                                                        .substring(Kludges.To.length)
                                                        .trim();
                                                } else if (
                                                    line.startsWith(Kludges.From)
                                                ) {
                                                    currMessage.fromName = line
                                                        .substring(Kludges.From.length)
                                                        .trim();
                                                } else if (
                                                    line.startsWith(Kludges.Subject)
                                                ) {
                                                    currMessage.subject = line
                                                        .substring(Kludges.Subject.length)
                                                        .trim();
                                                } else if (line.startsWith(Kludges.Via)) {
                                                    qwkKludge['@VIA'] = line;
                                                } else if (
                                                    line.startsWith(Kludges.MsgID)
                                                ) {
                                                    qwkKludge['@MSGID'] = line
                                                        .substring(Kludges.MsgID.length)
                                                        .trim();
                                                } else if (
                                                    line.startsWith(Kludges.Reply)
                                                ) {
                                                    qwkKludge['@REPLY'] = line
                                                        .substring(Kludges.Reply.length)
                                                        .trim();
                                                } else if (line.startsWith(Kludges.TZ)) {
                                                    qwkKludge['@TZ'] = line
                                                        .substring(Kludges.TZ.length)
                                                        .trim();
                                                } else if (
                                                    line.startsWith(Kludges.ReplyTo)
                                                ) {
                                                    qwkKludge['@REPLYTO'] = line
                                                        .substring(Kludges.ReplyTo.length)
                                                        .trim();
                                                } else {
                                                    bodyState = 'body'; // past this point and up to any tear/origin/etc., is the real message body
                                                    bodyLines.push(line);
                                                }
                                                break;

                                            case 'body':
                                            case 'trailers':
                                                if (MessageTrailers.Origin.test(line)) {
                                                    ftnProperty.ftn_origin = line;
                                                    bodyState = 'trailers';
                                                } else if (
                                                    MessageTrailers.Tear.test(line)
                                                ) {
                                                    ftnProperty.ftn_tear_line = line;
                                                    bodyState = 'trailers';
                                                } else if ('body' === bodyState) {
                                                    bodyLines.push(line);
                                                }
                                        }
                                    });

                                    let messageTimestamp = currMessage.header.timestamp;

                                    //  HEADERS.DAT support.
                                    let useTZKludge = true;
                                    if (currMessage.headersExtension) {
                                        const ext = currMessage.headersExtension;

                                        //  to and subject can be overridden yet again if entries are present
                                        currMessage.toName = ext.To || currMessage.toName;
                                        currMessage.subject =
                                            ext.Subject || currMessage.subject;
                                        currMessage.from =
                                            ext.Sender || currMessage.fromName; //  why not From? Who the fuck knows.

                                        //  possibly override message ID kludge
                                        qwkKludge['@MSGID'] =
                                            ext['Message-ID'] || qwkKludge['@MSGID'];

                                        //  WhenWritten contains a ISO-8601-ish timestamp and a Synchronet/SMB style TZ offset:
                                        //  20180101174837-0600  4168
                                        //  We can use this to get a very slightly better precision on the timestamp (addition of seconds)
                                        //  over the headers value. Why not milliseconds? Who the fuck knows.
                                        if (ext.WhenWritten) {
                                            const whenWritten = moment(
                                                ext.WhenWritten,
                                                'YYYYMMDDHHmmssZ'
                                            );
                                            if (whenWritten.isValid()) {
                                                messageTimestamp = whenWritten;
                                                useTZKludge = false;
                                            }
                                        }

                                        if (ext.Tags) {
                                            currMessage.hashTags =
                                                ext.Tags.toString().split(' ');
                                        }

                                        //  FTN style properties/kludges represented as X-FTN-XXXX
                                        for (let [extName, propName] of Object.entries(
                                            FTNPropertyMapping
                                        )) {
                                            const v = ext[extName];
                                            if (v) {
                                                ftnProperty[propName] = v;
                                            }
                                        }

                                        for (let [extName, kludgeName] of Object.entries(
                                            FTNKludgeMapping
                                        )) {
                                            const v = ext[extName];
                                            if (v) {
                                                ftnKludge[kludgeName] = v;
                                            }
                                        }
                                    }

                                    const message = new Message({
                                        toUserName: currMessage.toName,
                                        fromUserName: currMessage.fromName,
                                        subject: currMessage.subject,
                                        modTimestamp: messageTimestamp,
                                        message: bodyLines.join('\n'),
                                        hashTags: currMessage.hashTags,
                                    });

                                    //  Indicate this message was imported from a QWK packet
                                    message.meta.System[
                                        Message.SystemMetaNames.ExternalFlavor
                                    ] = Message.AddressFlavor.QWK;

                                    if (!_.isEmpty(qwkKludge)) {
                                        message.meta.QwkKludge = qwkKludge;
                                    }

                                    if (!_.isEmpty(ftnProperty)) {
                                        message.meta.FtnProperty = ftnProperty;
                                    }

                                    if (!_.isEmpty(ftnKludge)) {
                                        message.meta.FtnKludge = ftnKludge;
                                    }

                                    //  Add in tear line and origin if requested
                                    if (this.options.keepTearAndOrigin) {
                                        if (ftnProperty.ftn_tear_line) {
                                            message.message += `\r\n${ftnProperty.ftn_tear_line}\r\n`;
                                        }

                                        if (ftnProperty.ftn_origin) {
                                            message.message += `${ftnProperty.ftn_origin}\r\n`;
                                        }
                                    }

                                    //  Update the timestamp if we have a valid TZ
                                    if (useTZKludge && qwkKludge['@TZ']) {
                                        const tzOffset =
                                            SMBTZToUTCOffset[qwkKludge['@TZ']];
                                        if (tzOffset) {
                                            message.modTimestamp.utcOffset(tzOffset);
                                        }
                                    }

                                    message.meta.QwkProperty = {
                                        qwk_msg_status: currMessage.header.status,
                                        qwk_in_reply_to_num:
                                            currMessage.header.replyToNum,
                                    };

                                    if (this.options.mode === QWKPacketReader.Modes.QWK) {
                                        message.meta.QwkProperty.qwk_msg_num =
                                            currMessage.header.num;
                                        message.meta.QwkProperty.qwk_conf_num =
                                            currMessage.header.confNum;
                                    } else {
                                        //  For REP's, prefer the larger field.
                                        message.meta.QwkProperty.qwk_conf_num =
                                            currMessage.header.num ||
                                            currMessage.header.confNum;
                                    }

                                    //  Another quick HEADERS.DAT fix-up
                                    if (currMessage.headersExtension) {
                                        message.meta.QwkProperty.qwk_conf_num =
                                            currMessage.headersExtension.Conference ||
                                            message.meta.QwkProperty.qwk_conf_num;
                                    }

                                    this.emit('message', message);
                                    state = 'header';
                                }
                                break;
                        }
                    }

                    ++blockCount;
                    readNextBlock();
                });
            };

            //  start reading blocks
            readNextBlock();
        });
    }
}

class QWKPacketWriter extends EventEmitter {
    constructor(
        {
            mode = QWKPacketWriter.Modes.User,
            enableQWKE = true,
            enableHeadersExtension = true,
            enableAtKludges = true,
            systemDomain = 'enigma-bbs',
            bbsID = 'ENIGMA',
            user = null,
            archiveFormat = 'application/zip',
            forceEncoding = null,
        } = QWKPacketWriter.DefaultOptions
    ) {
        super();

        this.options = {
            mode,
            enableQWKE,
            enableHeadersExtension,
            enableAtKludges,
            systemDomain,
            bbsID,
            user,
            archiveFormat,
            forceEncoding: forceEncoding ? forceEncoding.toLowerCase() : null,
        };

        this.temptmp = temptmp.createTrackedSession('qwkpacketwriter');

        this.areaTagConfMap = {};
    }

    static get DefaultOptions() {
        return {
            mode: QWKPacketWriter.Modes.User,
            enableQWKE: true,
            enableHeadersExtension: true,
            enableAtKludges: true,
            systemDomain: 'enigma-bbs',
            bbsID: 'ENIGMA',
            user: null,
            archiveFormat: 'application/zip',
            forceEncoding: null,
        };
    }

    static get Modes() {
        return {
            User: 'user', //  creation of a packet for a user (non-network); non-mapped confs allowed
            Network: 'network', //  creation of a packet for QWK network
        };
    }

    init() {
        async.series(
            [
                callback => {
                    return StatLog.init(callback);
                },
                callback => {
                    this.temptmp.mkdir({ prefix: 'enigqwkwriter-' }, (err, workDir) => {
                        this.workDir = workDir;
                        return callback(err);
                    });
                },
                callback => {
                    //
                    //  Prepare areaTag -> conference number mapping:
                    //  - In User mode, areaTags's that are not explicitly configured
                    //    will have their conference number auto-generated.
                    //  - In Network mode areaTags's missing a configuration will not
                    //    be mapped, and thus skipped.
                    //
                    const configuredAreas = _.get(Config(), 'messageNetworks.qwk.areas');
                    if (configuredAreas) {
                        Object.keys(configuredAreas).forEach(areaTag => {
                            const confNumber = configuredAreas[areaTag].conference;
                            if (confNumber) {
                                this.areaTagConfMap[areaTag] = confNumber;
                            }
                        });
                    }

                    if (this.options.mode === QWKPacketWriter.Modes.User) {
                        //  All the rest
                        //  Start at 1000 to work around what seems to be a bug with some readers
                        let confNumber = 1000;
                        const usedConfNumbers = new Set(
                            Object.values(this.areaTagConfMap)
                        );
                        getAllAvailableMessageAreaTags().forEach(areaTag => {
                            if (this.areaTagConfMap[areaTag]) {
                                return;
                            }

                            while (
                                confNumber < 10001 &&
                                usedConfNumbers.has(confNumber)
                            ) {
                                ++confNumber;
                            }

                            //  we can go up to 65535 for some things, but NDX files are limited to 9999
                            if (confNumber === 10000) {
                                //  sanity...
                                this.emit(
                                    'warning',
                                    Errors.General('To many conferences (over 9999)')
                                );
                            } else {
                                this.areaTagConfMap[areaTag] = confNumber;
                                ++confNumber;
                            }
                        });
                    }

                    return callback(null);
                },
                callback => {
                    this.messagesStream = fs.createWriteStream(
                        paths.join(this.workDir, 'messages.dat')
                    );

                    if (this.options.enableHeadersExtension) {
                        this.headersDatStream = fs.createWriteStream(
                            paths.join(this.workDir, 'headers.dat')
                        );
                    }

                    //  First block is a space padded ID
                    const id = `Created with ENiGMA 1/2 BBS v${enigmaVersion} Copyright (c) 2015-2023 Bryan Ashby`;
                    this.messagesStream.write(
                        id.padEnd(QWKMessageBlockSize, ' '),
                        'ascii'
                    );
                    this.currentMessageOffset = QWKMessageBlockSize;

                    this.totalMessages = 0;
                    this.areaTagsSeen = new Set();
                    this.personalIndex = []; //  messages addressed to 'user'
                    this.inboxIndex = []; //  private messages for 'user'
                    this.publicIndex = new Map();

                    return callback(null);
                },
            ],
            err => {
                if (err) {
                    return this.emit('error', err);
                }

                this.emit('ready');
            }
        );
    }

    makeMessageIdentifier(message) {
        return `<${message.messageId}.${message.messageUuid}@${this.options.systemDomain}>`;
    }

    _encodeWithFallback(s, encoding) {
        try {
            return iconv.encode(s, encoding);
        } catch (e) {
            this.emit(
                'warning',
                Errors.General(
                    `Failed to encode buffer using ${encoding}; Falling back to 'ascii'`
                )
            );
            return iconv.encode(s, 'ascii');
        }
    }

    appendMessage(message) {
        //
        //  Each message has to:
        //  - Append to MESSAGES.DAT
        //  - Append to HEADERS.DAT if enabled
        //
        //  If this is a personal (ie: non-network) packet:
        //  - Produce PERSONAL.NDX
        //  - Produce 000.NDX with pointers to the users personal "inbox" mail
        //  - Produce ####.NDX with pointers to the public/conference mail
        //  - Produce TOREADER.EXT if QWKE support is enabled
        //

        let fullMessageBody = '';

        //  Start of body is kludges if enabled
        if (this.options.enableQWKE) {
            if (message.toUserName.length > 25) {
                fullMessageBody += `To: ${message.toUserName}\n`;
            }
            if (message.fromUserName.length > 25) {
                fullMessageBody += `From: ${message.fromUserName}\n`;
            }
            if (message.subject.length > 25) {
                fullMessageBody += `Subject: ${message.subject}\n`;
            }
        }

        if (this.options.enableAtKludges) {
            //  Add in original kludges (perhaps in a different order) if
            //  they were originally imported
            if (
                Message.AddressFlavor.QWK ==
                message.meta.System[Message.SystemMetaNames.ExternalFlavor]
            ) {
                if (message.meta.QwkKludge) {
                    for (let [kludge, value] of Object.entries(message.meta.QwkKludge)) {
                        fullMessageBody += `${kludge}: ${value}\n`;
                    }
                }
            } else {
                fullMessageBody += `@MSGID: ${this.makeMessageIdentifier(message)}\n`;
                fullMessageBody += `@TZ: ${UTCOffsetToSMBTZ[moment().format('Z')]}\n`;
                //  :TODO: REPLY and REPLYTO
            }
        }

        //  Sanitize line feeds (e.g. CRLF -> LF, and possibly -> QWK style below)
        splitTextAtTerms(message.message).forEach(line => {
            fullMessageBody += `${line}\n`;
        });

        const encoding = this._getEncoding(message);

        const encodedMessage = this._encodeWithFallback(fullMessageBody, encoding);

        //
        //  QWK spec wants line feeds as 0xe3 for some reason, so we'll have
        //  to replace the \n's. If we're going against the spec and using UTF-8
        //  we can just leave them be.
        //
        if ('utf8' !== encoding) {
            replaceCharInBuffer(encodedMessage, 0x0a, QWKLF);
        }

        //  Messages must comprise of multiples of 128 bit blocks with the last
        //  block padded by spaces or nulls (we use nulls)
        const fullBlocks = Math.trunc(encodedMessage.length / QWKMessageBlockSize);
        const remainBytes =
            QWKMessageBlockSize - (encodedMessage.length % QWKMessageBlockSize);
        const totalBlocks = fullBlocks + 1 + (remainBytes ? 1 : 0);

        //  The first block is always a header
        if (!this._writeMessageHeader(message, totalBlocks)) {
            //  we can't write this message
            return;
        }

        this.messagesStream.write(encodedMessage);

        if (remainBytes) {
            this.messagesStream.write(Buffer.alloc(remainBytes, ' '));
        }

        this._updateIndexTracking(message);

        if (this.options.enableHeadersExtension) {
            this._appendHeadersExtensionData(message, encoding);
        }

        //  next message starts at this block
        this.currentMessageOffset += totalBlocks * QWKMessageBlockSize;

        this.totalMessages += 1;
        this.areaTagsSeen.add(message.areaTag);
    }

    _getEncoding(message) {
        if (this.options.forceEncoding) {
            return this.options.forceEncoding;
        }

        //  If the system has stored an explicit encoding, use that.
        let encoding = _.get(message.meta, 'System.explicit_encoding');
        if (encoding) {
            return encoding;
        }

        //  If the message is already tagged with a supported encoding
        //  indicator such as FTN-style CHRS, try to use that.
        encoding = _.get(message.meta, 'FtnKludge.CHRS');
        if (encoding) {
            //  Convert from CHRS to something standard
            encoding = getEncodingFromCharacterSetIdentifier(encoding);
            if (encoding) {
                return encoding;
            }
        }

        //  The to-spec default is CP437/ASCII. If it can be encoded as
        //  such then do so.
        if (message.isCP437Encodable()) {
            return 'cp437';
        }

        //  Something more modern...
        return 'utf8';
    }

    _messageAddressedToUser(message) {
        if (_.isUndefined(this.cachedCompareNames)) {
            if (this.options.user) {
                this.cachedCompareNames = [this.options.user.username.toLowerCase()];
                const realName = this.options.user.getProperty(UserProps.RealName);
                if (realName) {
                    this.cachedCompareNames.push(realName.toLowerCase());
                }
            } else {
                this.cachedCompareNames = [];
            }
        }

        return this.cachedCompareNames.includes(message.toUserName.toLowerCase());
    }

    _updateIndexTracking(message) {
        //  index points at start of *message* not the header for... reasons?
        const index = this.currentMessageOffset / QWKMessageBlockSize + 1;
        if (message.isPrivate()) {
            this.inboxIndex.push(index);
        } else {
            if (this._messageAddressedToUser(message)) {
                //  :TODO: add to both indexes???
                this.personalIndex.push(index);
            }

            const areaTag = message.areaTag;
            if (!this.publicIndex.has(areaTag)) {
                this.publicIndex.set(areaTag, [index]);
            } else {
                this.publicIndex.get(areaTag).push(index);
            }
        }
    }

    appendNewFile() {}

    finish(packetDirectory) {
        async.series(
            [
                callback => {
                    this.messagesStream.on('close', () => {
                        return callback(null);
                    });
                    this.messagesStream.end();
                },
                callback => {
                    if (!this.headersDatStream) {
                        return callback(null);
                    }
                    this.headersDatStream.on('close', () => {
                        return callback(null);
                    });
                    this.headersDatStream.end();
                },
                callback => {
                    return this._createControlData(callback);
                },
                callback => {
                    return this._createIndexes(callback);
                },
                callback => {
                    return this._producePacketArchive(packetDirectory, callback);
                },
            ],
            err => {
                this.temptmp.cleanup();

                if (err) {
                    return this.emit('error', err);
                }

                this.emit('finished');
            }
        );
    }

    _getNextAvailPacketFileName(packetDirectory, cb) {
        //
        //  According to http://wiki.synchro.net/ref:qwk filenames should
        //  start with .QWK -> .QW1 ... .QW9 -> .Q10 ... .Q99
        //
        let digits = 0;
        async.doWhilst(
            callback => {
                let ext;
                if (0 === digits) {
                    ext = 'QWK';
                } else if (digits < 10) {
                    ext = `QW${digits}`;
                } else if (digits < 100) {
                    ext = `Q${digits}`;
                } else {
                    return callback(
                        Errors.UnexpectedState(
                            'Unable to choose a valid QWK output filename'
                        )
                    );
                }

                ++digits;

                const filename = `${this.options.bbsID}.${ext}`;
                fs.stat(paths.join(packetDirectory, filename), err => {
                    if (err && 'ENOENT' === err.code) {
                        return callback(null, filename);
                    } else {
                        return callback(null, null);
                    }
                });
            },
            (filename, callback) => {
                return callback(null, filename ? false : true);
            },
            (err, filename) => {
                return cb(err, filename);
            }
        );
    }

    _producePacketArchive(packetDirectory, cb) {
        const archiveUtil = ArchiveUtil.getInstance();

        fs.readdir(this.workDir, (err, files) => {
            if (err) {
                return cb(err);
            }

            this._getNextAvailPacketFileName(packetDirectory, (err, filename) => {
                if (err) {
                    return cb(err);
                }

                const packetPath = paths.join(packetDirectory, filename);
                archiveUtil.compressTo(
                    this.options.archiveFormat,
                    packetPath,
                    files,
                    this.workDir,
                    () => {
                        fs.stat(packetPath, (err, stats) => {
                            if (stats) {
                                this.emit('packet', { stats, path: packetPath });
                            }
                            return cb(err);
                        });
                    }
                );
            });
        });
    }

    _qwkMessageStatus(message) {
        //  - Public vs Private
        //  - Look at message pointers for read status
        //  - If +op is exporting and this message is to +op
        //  -
        //  :TODO: this needs addressed - handle unread vs read, +op, etc.
        //  ....see getNewMessagesInAreaForUser(); Variant with just IDs, or just a way to get first new message ID per area?

        if (message.isPrivate()) {
            return QWKMessageStatusCodes.UnreadPrivate;
        }
        return QWKMessageStatusCodes.UnreadPublic;
    }

    _writeMessageHeader(message, totalBlocks) {
        const asciiNum = (n, l) => {
            if (isNaN(n)) {
                return '';
            }
            return n.toString().substr(0, l);
        };

        const asciiTotalBlocks = asciiNum(totalBlocks, 6);
        if (asciiTotalBlocks.length > 6) {
            this.emit('warning', Errors.General('Message too large for packet'), message);
            return false;
        }

        const conferenceNumber = this._getMessageConferenceNumberByAreaTag(
            message.areaTag
        );
        if (isNaN(conferenceNumber)) {
            this.emit(
                'warning',
                Errors.MissingConfig(
                    `No QWK conference mapping for areaTag ${message.areaTag}`
                )
            );
            return false;
        }

        const header = Buffer.alloc(QWKMessageBlockSize, ' ');
        header.write(this._qwkMessageStatus(message), 0, 1, 'ascii');
        header.write(asciiNum(message.messageId), 1, 'ascii');
        header.write(
            message.modTimestamp.format(QWKHeaderTimestampFormat),
            8,
            13,
            'ascii'
        );
        header.write(message.toUserName.substr(0, 25), 21, 'ascii');
        header.write(message.fromUserName.substr(0, 25), 46, 'ascii');
        header.write(message.subject.substr(0, 25), 71, 'ascii');
        header.write(' '.repeat(12), 96, 'ascii'); //  we don't use the password field
        header.write(asciiNum(message.replyToMsgId), 108, 'ascii');
        header.write(asciiTotalBlocks, 116, 'ascii');
        header.writeUInt8(QWKMessageActiveStatus.Active, 122);
        header.writeUInt16LE(conferenceNumber, 123);
        header.writeUInt16LE(this.totalMessages + 1, 125);
        header.write(QWKNetworkTagIndicator.NotPresent, 127, 1, 'ascii'); //  :TODO: Present if for network output?

        this.messagesStream.write(header);

        return true;
    }

    _getMessageConferenceNumberByAreaTag(areaTag) {
        if (Message.isPrivateAreaTag(areaTag)) {
            return 0;
        }

        return this.areaTagConfMap[areaTag];
    }

    _getExportForUsername() {
        return _.get(this.options, 'user.username', 'Any');
    }

    _getExportSysOpUsername() {
        return StatLog.getSystemStat(SysProps.SysOpUsername) || 'SysOp';
    }

    _createControlData(cb) {
        const areas = Array.from(this.areaTagsSeen).map(areaTag => {
            if (Message.isPrivateAreaTag(areaTag)) {
                return {
                    areaTag: Message.WellKnownAreaTags.Private,
                    name: 'Private',
                    desc: 'Private Messages',
                };
            }
            return getMessageAreaByTag(areaTag);
        });

        const controlStream = fs.createWriteStream(
            paths.join(this.workDir, 'control.dat')
        );
        controlStream.setDefaultEncoding('ascii');

        controlStream.on('close', () => {
            return cb(null);
        });

        controlStream.on('error', err => {
            return cb(err);
        });

        const initialControlData = [
            Config().general.boardName,
            'Earth',
            'XXX-XXX-XXX',
            `${this._getExportSysOpUsername()}, Sysop`,
            `0000,${this.options.bbsID}`,
            moment().format('MM-DD-YYYY,HH:mm:ss'),
            this._getExportForUsername(),
            '', // name of Qmail menu
            '0', // uh, OK
            this.totalMessages.toString(),
            //  this next line is total conferences - 1:
            //  We have areaTag <> conference mapping, so the number should work out
            (this.areaTagsSeen.size - 1).toString(),
        ];

        initialControlData.forEach(line => {
            controlStream.write(`${line}\r\n`);
        });

        //  map areas as conf #\r\nDescription\r\n pairs
        areas.forEach(area => {
            const conferenceNumber = this._getMessageConferenceNumberByAreaTag(
                area.areaTag
            );
            const conf = getMessageConferenceByTag(area.confTag);
            const desc = `${conf.name} - ${area.name}`;

            controlStream.write(`${conferenceNumber}\r\n`);
            controlStream.write(`${desc}\r\n`);
        });

        //  :TODO: do we ever care here?!
        ['HELLO', 'BBSNEWS', 'GOODBYE'].forEach(trailer => {
            controlStream.write(`${trailer}\r\n`);
        });

        controlStream.end();
    }

    _createIndexes(cb) {
        const appendIndexData = (stream, offset) => {
            const msb = numToMbf32(offset);
            stream.write(msb);

            //  technically, the conference #, but only as a byte, so pretty much useless
            //  AND the filename itself is the conference number... dafuq.
            stream.write(Buffer.from([0x00]));
        };

        async.series(
            [
                callback => {
                    //  Create PERSONAL.NDX
                    if (!this.personalIndex.length) {
                        return callback(null);
                    }

                    const indexStream = fs.createWriteStream(
                        paths.join(this.workDir, 'personal.ndx')
                    );
                    this.personalIndex.forEach(offset =>
                        appendIndexData(indexStream, offset)
                    );

                    indexStream.on('close', err => {
                        return callback(err);
                    });

                    indexStream.end();
                },
                callback => {
                    //  000.NDX of private mails
                    if (!this.inboxIndex.length) {
                        return callback(null);
                    }

                    const indexStream = fs.createWriteStream(
                        paths.join(this.workDir, '000.ndx')
                    );
                    this.inboxIndex.forEach(offset =>
                        appendIndexData(indexStream, offset)
                    );

                    indexStream.on('close', err => {
                        return callback(err);
                    });

                    indexStream.end();
                },
                callback => {
                    //  ####.NDX
                    async.eachSeries(
                        this.publicIndex.keys(),
                        (areaTag, nextArea) => {
                            const offsets = this.publicIndex.get(areaTag);
                            const conferenceNumber =
                                this._getMessageConferenceNumberByAreaTag(areaTag);
                            const indexStream = fs.createWriteStream(
                                paths.join(
                                    this.workDir,
                                    `${conferenceNumber.toString().padStart(4, '0')}.ndx`
                                )
                            );
                            offsets.forEach(offset =>
                                appendIndexData(indexStream, offset)
                            );

                            indexStream.on('close', err => {
                                return nextArea(err);
                            });

                            indexStream.end();
                        },
                        err => {
                            return callback(err);
                        }
                    );
                },
            ],
            err => {
                return cb(err);
            }
        );
    }

    _makeSynchronetTimestamp(ts) {
        const syncTimestamp = ts.format('YYYYMMDDHHmmssZZ');
        const syncTZ = UTCOffsetToSMBTZ[ts.format('Z')] || '0000'; //  :TODO: what if we don't have a map?
        return `${syncTimestamp} ${syncTZ}`;
    }

    _appendHeadersExtensionData(message, encoding) {
        const messageData = {
            //  Synchronet style
            Utf8: 'utf8' === encoding ? 'true' : 'false',
            'Message-ID': this.makeMessageIdentifier(message),

            WhenWritten: this._makeSynchronetTimestamp(message.modTimestamp),
            // WhenImported    : '',   //  :TODO: only if we have a imported time from another external system?
            ExportedFrom: `${this.options.systemID} ${message.areaTag} ${message.messageId}`,
            Sender: message.fromUserName,

            //  :TODO: if exporting for QWK-Net style/etc.
            //SenderNetAddr

            SenderIpAddr: '127.0.0.1', //  no sir, that's private.
            SenderHostName: this.options.systemDomain,
            //  :TODO: if exported:
            //SenderProtocol
            Organization: 'BBS',

            //'Reply-To'      : :TODO: "address to direct replies".... ?!
            Subject: message.subject,
            To: message.toUserName,
            //ToNetAddr     : :TODO: net addr to?!

            //  :TODO: Only set if not imported:
            Tags: message.hashTags.join(' '),

            //  :TODO: Needs tested with Sync/etc.; Sync wants Conference *numbers*
            Conference: message.isPrivate()
                ? '0'
                : getMessageConfTagByAreaTag(message.areaTag),

            //  ENiGMA Headers
            MessageUUID: message.messageUuid,
            ModTimestamp: message.modTimestamp.format('YYYY-MM-DDTHH:mm:ss.SSSZ'),
            AreaTag: message.areaTag,
        };

        const externalFlavor =
            message.meta.System[Message.SystemMetaNames.ExternalFlavor];
        if (externalFlavor === Message.AddressFlavor.FTN) {
            //  Add FTN properties if it came from such an origin
            if (message.meta.FtnProperty) {
                const ftnProp = message.meta.FtnProperty;
                messageData['X-FTN-AREA'] = ftnProp[Message.FtnPropertyNames.FtnArea];
                messageData['X-FTN-SEEN-BY'] =
                    ftnProp[Message.FtnPropertyNames.FtnSeenBy];
            }

            if (message.meta.FtnKludge) {
                const ftnKludge = message.meta.FtnKludge;
                messageData['X-FTN-PATH'] = ftnKludge.PATH;
                messageData['X-FTN-MSGID'] = ftnKludge.MSGID;
                messageData['X-FTN-REPLY'] = ftnKludge.REPLY;
                messageData['X-FTN-PID'] = ftnKludge.PID;
                messageData['X-FTN-FLAGS'] = ftnKludge.FLAGS;
                messageData['X-FTN-TID'] = ftnKludge.TID;
                messageData['X-FTN-CHRS'] = ftnKludge.CHRS;
            }
        } else {
            messageData.WhenExported = this._makeSynchronetTimestamp(moment());
            messageData.Editor = `ENiGMA 1/2 BBS FSE v${enigmaVersion}`;
        }

        this.headersDatStream.write(
            this._encodeWithFallback(
                `[${this.currentMessageOffset.toString(16)}]\r\n`,
                encoding
            )
        );

        for (let [name, value] of Object.entries(messageData)) {
            if (value) {
                this.headersDatStream.write(
                    this._encodeWithFallback(`${name}: ${value}\r\n`, encoding)
                );
            }
        }

        this.headersDatStream.write('\r\n');
    }
}

module.exports = {
    QWKPacketReader,
    QWKPacketWriter,
};