'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var fetch = _interopDefault(require('node-fetch'));
var child_process = require('child_process');
var chalk = _interopDefault(require('chalk'));
var consola = _interopDefault(require('consola'));
var path = _interopDefault(require('path'));
var fs = _interopDefault(require('fs'));

var reportAndThrowError = function reportAndThrowError(msg) {
  report(msg);
  throw new Error(msg);
};
var report = function report(message) {
  consola.debug({
    message: String(message),
    tag: 'opencollective'
  });
};
var hideMessage = function hideMessage() {
  var env = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : process.env;

  // Show message if it is forced
  if (env.OPENCOLLECTIVE_FORCE) {
    return false;
  } // Don't show after oracle postinstall


  if (env.OC_POSTINSTALL_TEST) {
    return true;
  } // Don't show if opted-out


  if (env.OPENCOLLECTIVE_HIDE) {
    return true;
  } // Compatability with opencollective-postinstall


  if (!!env.DISABLE_OPENCOLLECTIVE && env.DISABLE_OPENCOLLECTIVE !== '0' && env.DISABLE_OPENCOLLECTIVE !== 'false') {
    return true;
  } // Don't show if on CI


  if (env.CI || env.CONTINUOUS_INTEGRATION) {
    return true;
  } // Only show in dev environment


  return Boolean(env.NODE_ENV) && !['dev', 'development'].includes(env.NODE_ENV);
};
var formatMoney = function formatMoney(currency) {
  return function (amount) {
    amount = amount / 100; // converting cents

    var precision = 0;
    return amount.toLocaleString(currency, {
      style: 'currency',
      currency: currency,
      minimumFractionDigits: precision,
      maximumFractionDigits: precision
    });
  };
};
var isWin32 = process.platform === 'win32';
var stripLeadingSlash = function stripLeadingSlash(s) {
  return s.startsWith('/') ? s.substring(1) : s;
};
var stripTrailingSlash = function stripTrailingSlash(s) {
  return s.endsWith('/') ? s.slice(0, -1) : s;
};

/* eslint-disable no-console */
var print = function print() {
  var color = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
  return function () {
    var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
    var terminalCols = retrieveCols();
    var strLength = str.replace(/\u001b\[[0-9]{2}m/g, '').length;
    var leftPaddingLength = Math.floor((terminalCols - strLength) / 2);
    var leftPadding = ' '.repeat(Math.max(leftPaddingLength, 0));

    if (color) {
      str = chalk[color](str);
    }

    console.log(leftPadding, str);
  };
};
var retrieveCols = function () {
  var result = false;
  return function () {
    if (result) {
      return result;
    }

    var defaultCols = 80;

    try {
      var terminalCols = child_process.execSync('tput cols', {
        stdio: ['pipe', 'pipe', 'ignore']
      });
      result = parseInt(terminalCols.toString()) || defaultCols;
    } catch (e) {
      result = defaultCols;
    }

    return result;
  };
}();
var printStats = function printStats(stats, color) {
  if (!stats) {
    return;
  }

  var colored = print(color);
  var bold = print('bold');
  var formatWithCurrency = formatMoney(stats.currency);
  colored("Number of contributors: ".concat(stats.contributorsCount));
  colored("Number of backers: ".concat(stats.backersCount));
  colored("Annual budget: ".concat(formatWithCurrency(stats.yearlyIncome)));
  bold("Current balance: ".concat(formatWithCurrency(stats.balance)), 'bold');
};
var printLogo = function printLogo(logoText) {
  if (!logoText) {
    return;
  }

  logoText.split('\n').forEach(print('blue'));
};
/**
 * Only show emoji on OSx (Windows shell doesn't like them that much ¯\_(ツ)_/¯ )
 * @param {*} emoji
 */

var emoji = function emoji(_emoji) {
  return process.stdout.isTTY && !isWin32 ? _emoji : '';
};
function printFooter(collective) {
  var dim = print('dim');
  var yellow = print('yellow');
  var emptyLine = print();
  yellow("Thanks for installing ".concat(collective.slug, " ").concat(emoji('🙏')));
  dim('Please consider donating to our open collective');
  dim('to help us maintain this package.');
  emptyLine();
  printStats(collective.stats);
  emptyLine();
  print()("".concat(chalk.bold("".concat(emoji('👉 '), " ").concat(collective.donationText)), " ").concat(chalk.underline(collective.donationUrl)));
  emptyLine();
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var FETCH_TIMEOUT = 3000;

function _catch(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
}

var fetchJson = _async(function (url) {
  return _catch(function () {
    return _await(global.fetch("".concat(url, ".json"), {
      timeout: FETCH_TIMEOUT
    }), function (_global$fetch) {
      return _global$fetch.json();
    });
  }, function (e) {
    report(e);
    reportAndThrowError("Could not fetch ".concat(url, ".json"));
  });
});

function _async(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var fetchStats = _async(function (collectiveUrl) {
  return _catch(function () {
    return _await(fetchJson(collectiveUrl));
  }, function (e) {
    report(e);
    report("Could not load the stats for ".concat(collectiveSlugFromUrl(collectiveUrl)));
  });
});
var fetchLogo = _async(function (logoUrl) {
  if (!logoUrl) {
    // Silent return if no logo has been provided
    return;
  }

  if (!logoUrl.match(/^https?:\/\//)) {
    reportAndThrowError("Your logo URL isn't well-formatted - ".concat(logoUrl));
  }

  return _catch(function () {
    return _await(global.fetch(logoUrl, {
      timeout: FETCH_TIMEOUT
    }), function (res) {
      if (isLogoResponseWellFormatted(res)) {
        return res.text();
      }

      report("Error while fetching logo from ".concat(logoUrl, ". The response wasn't well-formatted"));
    });
  }, function () {
    report("Error while fetching logo from ".concat(logoUrl));
  });
});

var isLogoResponseWellFormatted = function isLogoResponseWellFormatted(res) {
  return res.status === 200 && res.headers.get('content-type').match(/^text\/plain/);
};

var fetchPkg = function fetchPkg(pathToPkg) {
  var fullPathToPkg = path.resolve("".concat(pathToPkg, "/package.json"));

  try {
    return JSON.parse(fs.readFileSync(fullPathToPkg, 'utf8'));
  } catch (e) {
    reportAndThrowError("Could not find package.json at ".concat(fullPathToPkg));
  }
};

function _await$1(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$1(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var collectiveSlugFromUrl = function collectiveSlugFromUrl(url) {
  return url.substr(url.lastIndexOf('/') + 1).toLowerCase().replace(/\.json/g, '');
};
var collectiveUrl = function collectiveUrl(pkg) {
  var url = pkg.collective && pkg.collective.url;

  if (!url) {
    reportAndThrowError('No collective URL set!');
  }

  return stripTrailingSlash(url);
}; // use pkg.collective.logo for "legacy"/compatibility reasons

var collectiveLogoUrl = function collectiveLogoUrl(pkg) {
  return pkg.collective.logo || pkg.collective.logoUrl || false;
};
var collectiveDonationText = function collectiveDonationText(pkg) {
  return pkg.collective.donation && pkg.collective.donation.text || 'Donate:';
};
var getCollective = _async$1(function (pkgPath) {
  var pkg = fetchPkg(pkgPath);
  var url = collectiveUrl(pkg);
  var baseCollective = {
    url: url,
    slug: collectiveSlugFromUrl(url),
    logoUrl: collectiveLogoUrl(pkg),
    donationUrl: collectiveDonationUrl(pkg),
    donationText: collectiveDonationText(pkg)
  };
  var logoUrl = baseCollective.logoUrl;
  var promises = [fetchStats(url)].concat(logoUrl ? fetchLogo(logoUrl) : []);
  return _await$1(Promise.all(promises), function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        stats = _ref2[0],
        logo = _ref2[1];

    return Object.assign(baseCollective, {
      stats: stats,
      logo: logo
    });
  });
});
var collectiveDonationUrl = function collectiveDonationUrl(pkg) {
  var defaultDonationAmount = pkg.collective.donation && pkg.collective.donation.amount;
  var donateUrl = "".concat(collectiveUrl(pkg), "/").concat(retrieveDonationSlug(pkg));

  if (defaultDonationAmount) {
    return "".concat(donateUrl, "/").concat(defaultDonationAmount);
  }

  return donateUrl;
};
var retrieveDonationSlug = function retrieveDonationSlug(pkg) {
  var rawDonationSlug = pkg.collective.donation && pkg.collective.donation.slug;

  if (!rawDonationSlug) {
    return 'donate';
  }

  return stripLeadingSlash(rawDonationSlug);
};

function _await$2(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

function _async$2(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var init = _async$2(function (path, hide) {
  if (hide === undefined) hide = hideMessage();

  if (hide) {
    return;
  }

  global.fetch = global.fetch || fetch;
  return _await$2(getCollective(path), function (collective) {
    printLogo(collective.logo);
    printFooter(collective);
  });
});

exports.init = init;