"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Prompter = void 0;
const prompt = require("prompts");
const helpers = require("./helpers");
const readline = require("readline");
const yok_1 = require("./yok");
const MuteStream = require("mute-stream");
const _ = require("lodash");
class Prompter {
    constructor() {
        this.muteStreamInstance = null;
    }
    dispose() {
        if (this.ctrlcReader) {
            this.ctrlcReader.close();
        }
    }
    get(questions) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                this.muteStdout();
                if (!helpers.isInteractive()) {
                    if (_.some(questions, (s) => !s.default)) {
                        throw new Error("Console is not interactive and no default action specified.");
                    }
                    else {
                        const result = {};
                        _.each(questions, (s) => {
                            // Curly brackets needed because s.default() may return false and break the loop
                            result[s.name] = s.default();
                        });
                        return result;
                    }
                }
                else {
                    const result = yield prompt.prompt(questions);
                    return result;
                }
            }
            finally {
                this.unmuteStdout();
            }
        });
    }
    getPassword(message, options) {
        return __awaiter(this, void 0, void 0, function* () {
            const schema = {
                message,
                type: "password",
                name: "password",
                validate: (value) => {
                    const allowEmpty = options && options.allowEmpty;
                    return !allowEmpty && !value ? "Password must be non-empty" : true;
                },
            };
            const result = yield this.get([schema]);
            return result.password;
        });
    }
    getString(message, options) {
        return __awaiter(this, void 0, void 0, function* () {
            const schema = {
                message,
                type: "text",
                name: "inputString",
                validate: (value) => {
                    const doesNotAllowEmpty = options && _.has(options, "allowEmpty") && !options.allowEmpty;
                    return doesNotAllowEmpty && !value
                        ? `${message} must be non-empty`
                        : true;
                },
                default: options && options.defaultAction,
            };
            const result = yield this.get([schema]);
            return result.inputString;
        });
    }
    promptForChoice(promptMessage, choices, multiple = false, options = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const schema = Object.assign({ message: promptMessage, type: multiple ? "multiselect" : "select", name: "userAnswer", choices }, options);
            const result = yield this.get([schema]);
            const extractValue = (choice) => {
                if (typeof choice === "object") {
                    return choice.value || choice;
                }
                if (typeof choice === "string") {
                    return choice;
                }
                if (typeof choice === "number") {
                    return choices[choice];
                }
            };
            return multiple
                ? result.userAnswer.map(extractValue)
                : extractValue(result.userAnswer);
        });
    }
    promptForDetailedChoice(promptMessage, choices) {
        return __awaiter(this, void 0, void 0, function* () {
            const inquirerChoices = choices.map((choice) => {
                return {
                    title: choice.key,
                    value: choice.key,
                    description: choice.description,
                };
            });
            const schema = {
                message: promptMessage,
                type: "select",
                name: "userAnswer",
                choices: inquirerChoices,
            };
            const result = yield this.get([schema]);
            return result.userAnswer;
        });
    }
    confirm(message, defaultAction) {
        return __awaiter(this, void 0, void 0, function* () {
            const schema = {
                type: "confirm",
                name: "prompt",
                default: defaultAction,
                message,
            };
            const result = yield this.get([schema]);
            return result.prompt;
        });
    }
    muteStdout() {
        if (helpers.isInteractive()) {
            process.stdin.setRawMode(true); // After setting rawMode to true, Ctrl+C doesn't work for non node.js events loop i.e device log command
            // We need to create mute-stream and to pass it as output to ctrlcReader
            // This will prevent the prompter to show the user's text twice on the console
            this.muteStreamInstance = new MuteStream();
            this.muteStreamInstance.pipe(process.stdout);
            this.muteStreamInstance.mute();
            this.ctrlcReader = readline.createInterface({
                input: process.stdin,
                output: this.muteStreamInstance,
            });
            this.ctrlcReader.on("SIGINT", () => {
                // enable terminal cursor
                process.stdout.write("\x1B[?25h");
                process.exit();
            });
        }
    }
    unmuteStdout() {
        if (helpers.isInteractive()) {
            process.stdin.setRawMode(false);
            if (this.muteStreamInstance) {
                // We need to clean the event listeners from the process.stdout because the MuteStream.pipe function calls the pipe function of the Node js Stream which adds event listeners and this can cause memory leak if we display more than ~10 prompts.
                this.cleanEventListeners(process.stdout);
                this.muteStreamInstance.unmute();
                this.muteStreamInstance = null;
                this.dispose();
            }
        }
    }
    cleanEventListeners(stream) {
        // The events names and listeners names can be found here https://github.com/nodejs/node/blob/master/lib/stream.js
        // Which event cause memory leak can be tested with stream.listeners("event-name") and if the listeners count keeps increasing with each prompt we need to remove the listener.
        const memoryLeakEvents = [
            {
                eventName: "close",
                listenerName: "cleanup",
            },
            {
                eventName: "error",
                listenerName: "onerror",
            },
            {
                eventName: "drain",
                listenerName: "ondrain",
            },
        ];
        _.each(memoryLeakEvents, (memoryleakEvent) => this.cleanListener(stream, memoryleakEvent.eventName, memoryleakEvent.listenerName));
    }
    cleanListener(stream, eventName, listenerName) {
        const eventListeners = process.stdout.listeners(eventName);
        const listenerFunction = _.find(eventListeners, (func) => func.name === listenerName);
        if (listenerFunction) {
            stream.removeListener(eventName, listenerFunction);
        }
    }
}
exports.Prompter = Prompter;
yok_1.injector.register("prompter", Prompter);
//# sourceMappingURL=prompter.js.map