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

//  ENiGMA½
const MenuModule                = require('./menu_module.js').MenuModule;
const resetScreen               = require('./ansi_term.js').resetScreen;
const setSyncTermFontWithAlias  = require('./ansi_term.js').setSyncTermFontWithAlias;

//  deps
const async         = require('async');
const _             = require('lodash');
const net           = require('net');
const EventEmitter  = require('events');

const {
    TelnetSocket,
    TelnetSpec :
    {
        Commands,
        Options,
        SubNegotiationCommands,
    },
} = require('telnet-socket');

/*
    Expected configuration block:

    {
        module: telnet_bridge
        ...
        config: {
            host: somehost.net
            port: 23
        }
    }
*/

//  :TODO: ENH: Support nodeMax and tooManyArt
exports.moduleInfo = {
    name    : 'Telnet Bridge',
    desc    : 'Connect to other Telnet Systems',
    author  : 'Andrew Pamment',
};

const IAC_DO_TERM_TYPE = TelnetSocket.commandBuffer(
    Commands.DO,
    Options.TTYPE,
);

class TelnetClientConnection extends EventEmitter {
    constructor(client) {
        super();

        this.client     = client;
    }


    restorePipe() {
        if(!this.pipeRestored) {
            this.pipeRestored = true;
            this.client.dataPassthrough = false;

            //  client may have bailed
            if(null !== _.get(this, 'client.term.output', null)) {
                if(this.bridgeConnection) {
                    this.client.term.output.unpipe(this.bridgeConnection);
                }
                this.client.term.output.resume();
            }
        }
    }

    connect(connectOpts) {
        this.bridgeConnection = net.createConnection(connectOpts, () => {
            this.emit('connected');

            this.pipeRestored = false;
            this.client.dataPassthrough = true;
            this.client.term.output.pipe(this.bridgeConnection);
        });

        this.bridgeConnection.on('data', data => {
            this.client.term.rawWrite(data);

            //
            //  Wait for a terminal type request, and send it exactly once.
            //  This is enough (in additional to other negotiations handled in telnet.js)
            //  to get us in on most systems
            //
            if(!this.termSent && data.indexOf(IAC_DO_TERM_TYPE) > -1) {
                this.termSent = true;
                this.bridgeConnection.write(this.getTermTypeNegotiationBuffer());
            }
        });

        this.bridgeConnection.once('end', () => {
            this.restorePipe();
            this.emit('end');
        });

        this.bridgeConnection.once('error', err => {
            this.restorePipe();
            this.emit('end', err);
        });
    }

    disconnect() {
        if(this.bridgeConnection) {
            this.bridgeConnection.end();
        }
    }

    destroy() {
        if(this.bridgeConnection) {
            this.bridgeConnection.destroy();
            this.bridgeConnection.removeAllListeners();
            this.restorePipe();
            this.emit('end');
        }
    }

    getTermTypeNegotiationBuffer() {
        //
        //  Create a TERMINAL-TYPE sub negotiation buffer using the
        //  actual/current terminal type.
        //
        const sendTermType = TelnetSocket.commandBuffer(
            Commands.SB,
            Options.TTYPE,
            [
                SubNegotiationCommands.IS,
                ...Buffer.from(this.client.term.termType),  //  e.g. "ansi"
                Commands.IAC,
                Commands.SE,
            ]
        );
        return sendTermType;
    }
}

exports.getModule = class TelnetBridgeModule extends MenuModule {
    constructor(options) {
        super(options);

        this.config         = Object.assign({}, _.get(options, 'menuConfig.config'), options.extraArgs);
        this.config.port    = this.config.port || 23;
    }

    initSequence() {
        let clientTerminated;
        const self = this;

        async.series(
            [
                function validateConfig(callback) {
                    if(_.isString(self.config.host) &&
                        _.isNumber(self.config.port))
                    {
                        callback(null);
                    } else {
                        callback(new Error('Configuration is missing required option(s)'));
                    }
                },
                function createTelnetBridge(callback) {
                    const connectOpts = {
                        port    : self.config.port,
                        host    : self.config.host,
                    };

                    self.client.term.write(resetScreen());
                    self.client.term.write(
                        `  Connecting to ${connectOpts.host}, please wait...\n  (Press ESC to cancel)\n`
                    );

                    const telnetConnection = new TelnetClientConnection(self.client);

                    const connectionKeyPressHandler = (ch, key) => {
                        if('escape' === key.name) {
                            self.client.removeListener('key press', connectionKeyPressHandler);
                            telnetConnection.destroy();
                        }
                    };

                    self.client.on('key press', connectionKeyPressHandler);

                    telnetConnection.on('connected', () => {
                        self.client.removeListener('key press', connectionKeyPressHandler);
                        self.client.log.info(connectOpts, 'Telnet bridge connection established');

                        if(self.config.font) {
                            self.client.term.rawWrite(setSyncTermFontWithAlias(self.config.font));
                        }

                        self.client.once('end', () => {
                            self.client.log.info('Connection ended. Terminating connection');
                            clientTerminated = true;
                            telnetConnection.disconnect();
                        });
                    });

                    telnetConnection.on('end', err => {
                        self.client.removeListener('key press', connectionKeyPressHandler);

                        if(err) {
                            self.client.log.info(`Telnet bridge connection error: ${err.message}`);
                        }

                        callback(clientTerminated ? new Error('Client connection terminated') : null);
                    });

                    telnetConnection.connect(connectOpts);
                }
            ],
            err => {
                if(err) {
                    self.client.log.warn( { error : err.message }, 'Telnet connection error');
                }

                if(!clientTerminated) {
                    self.prevMenu();
                }
            }
        );
    }
};