text: /* tslint:disable: no-console */
  const exec = require('shell-utils').exec;
  const semver = require('semver');
  const fs = require('fs');
  const cp = require('child_process');
  const includes = require('lodash/includes');
  const documentation = require('./documentation');
  
  const packageJsonPath = `${process.cwd()}/package.json`;
  
  // Export buildkite variables for Release build
  // We cast toString() because 'buildkite-agent meta-data get' function returns 'object'
  const BRANCH = process.env.BUILDKITE_BRANCH;
  const isRelease = process.env.BUILDKITE_MESSAGE.match(/^release$/i);
  let VERSION, VERSION_TAG, BUILD_DOCUMENTATION_VERSION, REMOVE_DOCUMENTATION_VERSION;
  if (isRelease) {
    VERSION = cp.execSync(`buildkite-agent meta-data get version`).toString();
    VERSION_TAG = cp.execSync(`buildkite-agent meta-data get npm-tag`).toString();
    BUILD_DOCUMENTATION_VERSION = cp
      .execSync(`buildkite-agent meta-data get build-documentation-version`)
      .toString();
    REMOVE_DOCUMENTATION_VERSION = cp
      .execSync(`buildkite-agent meta-data get remove-documentation-version`)
      .toString();
  }
  
  console.log(typeof VERSION);
  // Workaround JS
  if (VERSION_TAG == 'null') {
    VERSION_TAG = isRelease ? 'latest' : 'snapshot';
  }
  const VERSION_INC = 'patch';
  
  function run() {
    if (!validateEnv()) {
      return;
    }
    setupGit();
    createNpmRc();
    versionTagAndPublish();
  }
  
  function validateEnv() {
    if (!process.env.CI) {
      throw new Error(`releasing is only available from CI`);
    }
    return true;
  }
  
  function setupGit() {
    exec.execSyncSilent(`git config --global push.default simple`);
    exec.execSyncSilent(`git config --global user.email "${process.env.GIT_EMAIL}"`);
    exec.execSyncSilent(`git config --global user.name "${process.env.GIT_USER}"`);
    const remoteUrl = new RegExp(`https?://(\\S+)`).exec(exec.execSyncRead(`git remote -v`))[1];
    exec.execSyncSilent(
      `git remote add deploy "https://${process.env.GIT_USER}:${process.env.GIT_TOKEN}@${remoteUrl}"`
    );
    // exec.execSync(`git checkout ${ONLY_ON_BRANCH}`);
  }
  
  function createNpmRc() {
    exec.execSync(`rm -f package-lock.json`);
    const content = `
  email=\${NPM_EMAIL}
  //registry.npmjs.org/:_authToken=\${NPM_TOKEN}
  `;
    fs.writeFileSync(`.npmrc`, content);
  }
  
  function versionTagAndPublish() {
    const packageVersion = semver.clean(process.env.npm_package_version);
    console.log(`package version: ${packageVersion}`);
  
    const currentPublished = findCurrentPublishedVersion();
    console.log(`current published version: ${currentPublished}`);
  
    const version = isRelease
      ? VERSION
      : semver.gt(packageVersion, currentPublished)
      ? `${packageVersion}-snapshot.${process.env.BUILDKITE_BUILD_NUMBER}`
      : `${currentPublished}-snapshot.${process.env.BUILDKITE_BUILD_NUMBER}`;
  
    console.log(`Publishing version: ${version}`);
  
    tryPublishAndTag(version);
  }
  
  function findCurrentPublishedVersion() {
    return exec.execSyncRead(`npm view ${process.env.npm_package_name} dist-tags.latest`);
  }
  
  function tryPublishAndTag(version) {
    let theCandidate = version;
    for (let retry = 0; retry < 5; retry++) {
      try {
        tagAndPublish(theCandidate);
        console.log(`Released ${theCandidate}`);
        return;
      } catch (err) {
        const alreadyPublished = includes(
          err.toString(),
          'You cannot publish over the previously published version'
        );
        if (!alreadyPublished) {
          throw err;
        }
        console.log(`previously published. retrying with increased ${VERSION_INC}...`);
        theCandidate = semver.inc(theCandidate, VERSION_INC);
      }
    }
  }
  
  function tagAndPublish(newVersion) {
    console.log(`trying to publish ${newVersion}...`);
    if (BUILD_DOCUMENTATION_VERSION && BUILD_DOCUMENTATION_VERSION !== 'null')
      documentation.release(BUILD_DOCUMENTATION_VERSION, REMOVE_DOCUMENTATION_VERSION);
    exec.execSync(`npm --no-git-tag-version version ${newVersion}`);
    exec.execSync(`npm publish --tag ${VERSION_TAG}`);
    if (isRelease) {
      exec.execSync(`git tag -a ${newVersion} -m "${newVersion}"`);
      exec.execSyncSilent(`git push deploy ${newVersion} || true`);
      updatePackageJsonGit(newVersion);
    }
  }
  
  function writePackageJson(packageJson) {
    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
  }
  
  function readPackageJson() {
    return JSON.parse(fs.readFileSync(packageJsonPath));
  }
  
  function updatePackageJsonGit(version) {
    exec.execSync(`git checkout ${BRANCH}`);
    const packageJson = readPackageJson();
    packageJson.version = version;
    writePackageJson(packageJson);
    exec.execSync(`git add package.json`);
    exec.execSync(`git commit -m"Update package.json version to ${version} [buildkite skip]"`);
    exec.execSync(`git push deploy ${BRANCH}`);
    draftGitRelease(version);
  }
  
  function draftGitRelease(version) {
    exec.execSync(`npx gren release --tags=${version}`);
    exec.execSync(`sleep 30`);
    // For some unknown reason, gren release works well only when calling it twice.
    exec.execSync(`npx gren release --tags=${version}`);
  }
  
  run();
  