import { AnalysisResultObject } from "ResponseTypes";
import commander from "commander";
import { pick } from "lodash";
import { DebugBear } from "./DebugBear";

const version = require("../package.json").version;

export async function __runCli() {
  let urlValue;
  const program = commander
    .arguments("[url]")
    .option("--pageId <id>")
    .option("--path <path>")
    .option("--waitForResult")
    .option("--fail", "Return non-zero exit code if build status is 'failure'.")
    .option(
      "--inferBuildInfo",
      "look at environment variables and local git to determine e.g. branch name and commit title",
    )
    .option("--ngrokWebPort <ngrokWebPort>")
    .option(
      "--output <output>",
      "Write test result including metrics to this path",
    )
    .option("--commitHash <commitHash>")
    .option("--commitBranch <commitBranch>")
    .option("--baseHash <baseHash>")
    .option("--baseBranch <baseBranch>")
    .option("--repoOwner <repoOwner>")
    .option("--repoName <repoName>")
    .option(
      "--buildTitle <buildTitle>",
      "title of the build, e.g. a commit message",
    )
    .option(
      "--customHeader <customHeader>",
      "custom header, name and value separated by a colon",
      function collect(value, previous) {
        const parts = value.split(":");
        if (parts.length !== 2) {
          throw Error(
            "Custom header needs to have two parts separated by a colon",
          );
        }
        return Object.assign(previous || {}, { [parts[0]]: parts[1] });
      },
    )
    .option(
      "--userFlowReplacement <replacement>",
      "string to be replaced in user/setup flow, name and value separated by a colon",
      function collect(value, previous) {
        const parts = value.split(":");
        if (parts.length !== 2) {
          throw Error(
            "User flow replacement needs to have two parts separated by a colon",
          );
        }
        return Object.assign(previous || {}, { [parts[0]]: parts[1] });
      },
    )
    .action(function (url) {
      urlValue = url;
    })
    .version(version)
    .parse(process.argv);

  const options = program.opts();

  if (process.env.DEBUG) {
    console.log("Options: ", options);
  }

  let baseUrl = undefined;

  try {
    if (options.fail && !options.waitForResult) {
      throw Error("--fail option requires --waitForResult option");
    }

    await analyzePage(
      Object.assign(
        {
          url: urlValue,
          baseUrl,
          isCliFail: options.fail,
          output: options.output,
        },
        {
          customHeaders: options.customHeader,
          userFlowReplacements: options.userFlowReplacement,
        },
        pick(options, [
          "pageId",
          "waitForResult",
          "commitHash",
          "commitBranch",
          "baseHash",
          "baseBranch",
          "repoOwner",
          "repoName",
          "path",
          "buildTitle",
          "inferBuildInfo",
          "ngrokWebPort",
        ]),
      ),
    );
  } catch (err: any) {
    console.log("\nCLI command failed");
    console.log(err && err.message);
    process.exit(1);
  }
}

async function analyzePage(options) {
  if (!process.env.DEBUGBEAR_API_KEY) {
    throw Error(
      "Need to provide API key via DEBUGBEAR_API_KEY environment variable",
    );
  }
  const dbbClient = new DebugBear(process.env.DEBUGBEAR_API_KEY);
  if (!options || !options.pageId) {
    console.log(
      "The pageId option is required. You can find the page ID in the top right corner on the results page.",
    );
  }

  const analysis = await dbbClient.pages.analyze(options.pageId, options);

  console.log(`| Repo: ${analysis.repoOwner}/${analysis.repoName}`);
  console.log(
    `| Commit: ${analysis.commitHash || "(no commit hash)"} ${
      analysis.buildTitle || "(no build title)"
    }`,
  );

  console.log("When the result is ready you can see it here: " + analysis.url);

  let result: AnalysisResultObject | null = null;
  if (options.waitForResult) {
    console.log("Waiting for result");

    result = await analysis.waitForResult();

    console.log("Build complete: ", result.build!.oneLineSummary);
    console.log("Build status: " + result.build!.status);

    if (options.output) {
      require("fs").writeFileSync(
        options.output,
        JSON.stringify(result, null, 2),
      );
      console.log("Wrote test result JSON to " + options.output);
    }

    if (options.isCliFail && result.build!.status === "failure") {
      process.exit(2);
    }
  }
}