#!/usr/bin/env node

// Packages
const chalk = require("chalk");
const minimist = require("minimist");
const ms = require("ms");
const stripAnsi = require("strip-ansi");

// Ours
const login = require("../lib/login");
const cfg = require("../lib/cfg");
const NowPlans = require("../lib/plans");
const indent = require("../lib/indent");
const listInput = require("../lib/utils/input/list");
const code = require("../lib/utils/output/code");
const error = require("../lib/utils/output/error");
const success = require("../lib/utils/output/success");
const cmd = require("../lib/utils/output/cmd");
const logo = require("../lib/utils/output/logo");

const argv = minimist(process.argv.slice(2), {
  string: ["config", "token"],
  boolean: ["help", "debug"],
  alias: {
    help: "h",
    config: "c",
    debug: "d",
    token: "t"
  }
});

const help = () => {
  console.log(
    `
  ${chalk.bold(`${logo} now upgrade`)} [plan]

  ${chalk.dim("Options:")}

    -h, --help              Output usage information
    -c ${chalk.bold.underline("FILE")}, --config=${chalk.bold.underline("FILE")}  Config file
    -d, --debug             Debug mode [off]
    -t ${chalk.bold.underline("TOKEN")}, --token=${chalk.bold.underline("TOKEN")} Login token

  ${chalk.dim("Examples:")}

  ${chalk.gray("–")} List available plans and pick one interactively

      ${chalk.cyan("$ now upgrade")}

      ${chalk.yellow("NOTE:")} ${chalk.gray("Make sure you have a payment method, or add one:")}

      ${chalk.cyan(`$ now billing add`)}

  ${chalk.gray("–")} Pick a specific plan (premium):

      ${chalk.cyan(`$ now upgrade premium`)}
  `
  );
};

// options
const debug = argv.debug;
const apiUrl = argv.url || "https://api.zeit.co";

if (argv.config) {
  cfg.setConfigFile(argv.config);
}

const exit = code => {
  // we give stdout some time to flush out
  // because there's a node bug where
  // stdout writes are asynchronous
  // https://github.com/nodejs/node/issues/6456
  setTimeout(() => process.exit(code || 0), 100);
};

if (argv.help) {
  help();
  exit(0);
} else {
  const config = cfg.read();

  Promise.resolve(argv.token || config.token || login(apiUrl))
    .then(async token => {
      try {
        await run(token);
      } catch (err) {
        if (err.userError) {
          error(err.message);
        } else {
          error(`Unknown error: ${err.stack}`);
        }
        exit(1);
      }
    })
    .catch(e => {
      error(`Authentication error – ${e.message}`);
      exit(1);
    });
}

function buildInquirerChoices(current, until) {
  if (until) {
    until = until.split(" ");
    until = " for " + chalk.bold(until[0]) + " more " + until[1];
  } else {
    until = "";
  }
  const ossTitle = current === "oss"
    ? `oss FREE ${" ".repeat(28)} (current)`
    : "oss FREE";
  const premiumTitle = current === "premium"
    ? `premium $15/mo ${" ".repeat(24 - stripAnsi(until).length)} (current${until})`
    : "premium $15/mo";
  return [
    {
      name: [
        ossTitle,
        indent("✓ All code is public and open-source", 2),
        indent("✓ 20 deploys per month | 1GB monthly bandwidth", 2),
        indent("✓ 1GB FREE storage | 1MB size limit per file", 2)
      ].join("\n"),
      value: "oss",
      short: "oss FREE"
    },
    {
      name: [
        premiumTitle,
        indent("✓ All code is private and secure", 2),
        indent("✓ 1000 deploys per month | 50GB monthly bandwidth", 2),
        indent("✓ 100GB storage | No filesize limit", 2)
      ].join("\n"),
      value: "premium",
      short: "premium $15/mo"
    }
  ];
}

async function run(token) {
  const args = argv._;
  if (args.length > 1) {
    error("Invalid number of arguments");
    return exit(1);
  }

  const start = new Date();
  const plans = new NowPlans(apiUrl, token, { debug });

  let planId = args[0];

  if (![undefined, "oss", "premium"].includes(planId)) {
    error(`Invalid plan name – should be ${code("oss")} or ${code("premium")}`);
    return exit(1);
  }

  const currentPlan = await plans.getCurrent();

  if (planId === undefined) {
    const elapsed = ms(new Date() - start);

    let message = `To manage this from the web UI, head to https://zeit.co/account\n`;
    message += `> Selecting a plan for your account ${chalk.gray(`[${elapsed}]`)}`;
    const choices = buildInquirerChoices(currentPlan.id, currentPlan.until);

    planId = await listInput({
      message,
      choices,
      separator: true,
      abort: "end"
    });
  }

  if (
    planId === undefined ||
    (planId === currentPlan.id && currentPlan.until === undefined)
  ) {
    return console.log("No changes made");
  }

  let newPlan;

  try {
    newPlan = await plans.set(planId);
  } catch (err) {
    let errorBody;
    if (err.res && err.res.status === 400) {
      errorBody = err.res.json();
    } else {
      const message = "A network error has occurred. Please retry.";
      errorBody = { message };
    }

    const _err = (await errorBody).error;
    const { code, message } = _err;

    if (code === "customer_not_found" || code === "source_not_found") {
      error(
        `You have no payment methods available. Run ${cmd("now billing add")} to add one`
      );
    } else {
      error(`An unknow error occured. Please try again later ${message}`);
    }
    plans.close();
    return;
  }

  if (currentPlan.until && newPlan.id === "premium") {
    success(
      `The cancelation has been undone. You're back on the ${chalk.bold("Premium plan")}`
    );
  } else if (newPlan.until) {
    success(
      `Your plan will be switched to OSS in ${chalk.bold(newPlan.until)}. Your card will not be charged again`
    );
  } else {
    success(`You're now on the ${chalk.bold("Premium plan")}`);
  }

  plans.close();
}