const ora = require('ora');
const inquirer = require('inquirer');
const chalk = require('chalk');
const { getAllDoodlePlans, getDoodlePlanById, createSubscriptionForUser } = require('@doodle/billing-client');
const { NAMESPACES, CONFIG_PASSWORD_KEY, CONFIG_EMAIL_KEY, verboseLogging } = require('../constants');
const setupEnvVarsForEnviornment = require('../utils/setup-enviornment');
const { getTokenForUser } = require('../apis/keycloak');
const { obfuscateString } = require('../utils/strings');

/**
 * Start a trial for the supplied user.
 *
 * @param {Object} options
 * @param {string} options.email
 * @param {string} options.target
 * @param {string} options.password
 * @param {string} options.subscriptionName
 * @param {Object} config
 */
async function startTrialPrompt(options = {}, config) {
  const obfuscatedPassword = obfuscateString(config[CONFIG_PASSWORD_KEY]);

  await inquirer
    .prompt([
      {
        type: 'list',
        name: 'target',
        message: 'What environment should we create the subscription?',
        choices: NAMESPACES,
        default: 'staging',
        when: !options.target,
      },
      {
        type: 'input',
        name: 'email',
        message: "What is the user's email address?",
        default: config[CONFIG_EMAIL_KEY],
        when: !options.email,
        validate: input => {
          if (input.trim().search('@') === -1 || input.trim().length < 6) {
            return 'Enter a valid email address';
          }
          return true;
        },
      },
      {
        type: 'password',
        name: 'password',
        message: `What is the user's account password? (leave blank for default: ${obfuscatedPassword})`,
        default: config[CONFIG_PASSWORD_KEY],
        when: !options.password,
      },
      {
        type: 'list',
        name: 'subscriptionName',
        message: 'What subscription should we create?',
        choices: Object.values(getAllDoodlePlans()).map(plan => `${plan.planId}: ${plan.internalName}`),
        default: `25: ${getDoodlePlanById(25).internalName}`,
        when: !options.subscriptionName,
      },
    ])
    .then(async answers => {
      const { target, email, password, subscriptionName } = {
        ...options,
        ...answers,
      };

      // Dynamically setup the env vars needed for @doodle/billing-client
      setupEnvVarsForEnviornment(target);

      let spinner;

      let userToken;

      try {
        const planId = Number(subscriptionName.split(':')[0].trim());
        spinner = ora(`Creating subscription: ${chalk.yellow(subscriptionName)}`).start();

        userToken = await getTokenForUser(target, email, password);

        if (verboseLogging) {
          console.log({ target, email, password, subscriptionName, userToken });
        }

        const sub = await createSubscriptionForUser(userToken.access_token, planId);

        if (!sub || sub.status !== 'SUCCESS') {
          throw new Error('Could not create subscription');
        }

        if (verboseLogging) {
          console.log(sub);
        }

        const { subscriptionId } = sub.document;
        spinner.succeed(`Subscription created: ${chalk.yellow(subscriptionName)} (subscriptionId: ${subscriptionId})`);
      } catch (error) {
        spinner.fail('Failed to start the trial');
        console.log(error);
      }
    });
}

module.exports = startTrialPrompt;