"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.logWithLevel = logWithLevel;
exports.logDebug = logDebug;
exports.getPlatformTag = getPlatformTag;
exports.logInfo = logInfo;
exports.logError = logError;
exports.logWarning = logWarning;
exports.clearNotification = clearNotification;
exports.attachLoggerStream = attachLoggerStream;
exports.readExpRcAsync = readExpRcAsync;
exports.readConfigJsonAsync = readConfigJsonAsync;

function ConfigUtils() {
  const data = _interopRequireWildcard(require("@expo/config"));

  ConfigUtils = function () {
    return data;
  };

  return data;
}

function _path() {
  const data = _interopRequireDefault(require("path"));

  _path = function () {
    return data;
  };

  return data;
}

function _chalk() {
  const data = _interopRequireDefault(require("chalk"));

  _chalk = function () {
    return data;
  };

  return data;
}

function Analytics() {
  const data = _interopRequireWildcard(require("../Analytics"));

  Analytics = function () {
    return data;
  };

  return data;
}

function _Logger() {
  const data = _interopRequireDefault(require("../Logger"));

  _Logger = function () {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

const MAX_MESSAGE_LENGTH = 200;
let _projectRootToLogger = {};

function _getLogger(projectRoot) {
  let logger = _projectRootToLogger[projectRoot];

  if (!logger) {
    logger = _Logger().default.child({
      type: 'project',
      project: _path().default.resolve(projectRoot)
    });
    _projectRootToLogger[projectRoot] = logger;
  }

  return logger;
}

function logWithLevel(projectRoot, level, fields, msg, id) {
  if (id) {
    fields.issueId = id;
  }

  let logger = _getLogger(projectRoot);

  switch (level) {
    case 'debug':
      logger.debug(fields, msg);
      break;

    case 'info':
      logger.info(fields, msg);
      break;

    case 'warn':
      logger.warn(fields, msg);
      break;

    case 'error':
      logger.error(fields, msg);
      break;

    default:
      logger.debug(fields, msg);
      break;
  }
}

function logDebug(projectRoot, tag, message, id) {
  _getLogger(projectRoot).debug({
    tag
  }, message.toString());
}

function getPlatformTag(platform) {
  const input = platform.toLowerCase().trim();

  switch (input) {
    case 'ios':
      return _chalk().default.bgWhite.black(' iOS ');

    case 'android':
      return _chalk().default.bgGreen.black(' Android ');

    case 'node':
      return _chalk().default.bgCyan.black(' Node ');

    case 'web':
      return _chalk().default.bgMagenta.black(' web ');

    default:
      return _chalk().default.bgWhite.black(` ${platform} `);
  }
}

function logInfo(projectRoot, tag, message, id) {
  const fields = {
    tag
  };

  if (id) {
    fields.issueId = id;
  }

  _getLogger(projectRoot).info(fields, message.toString());
}

function logError(projectRoot, tag, message, id) {
  const fields = {
    tag
  };

  if (id) {
    fields.issueId = id;
  }

  _getLogger(projectRoot).error(fields, message.toString());

  let truncatedMessage = message.toString();

  if (truncatedMessage.length > MAX_MESSAGE_LENGTH) {
    truncatedMessage = truncatedMessage.substring(0, MAX_MESSAGE_LENGTH);
  } // temporarily remove sentry until we can trim events
  // send error to Sentry
  // Sentry.logError(message.toString(), {
  //   tags: { tag },
  // });

}

function logWarning(projectRoot, tag, message, id) {
  const fields = {
    tag
  };

  if (id) {
    fields.issueId = id;
  }

  _getLogger(projectRoot).warn(fields, message.toString());

  let truncatedMessage = message.toString();

  if (truncatedMessage.length > MAX_MESSAGE_LENGTH) {
    truncatedMessage = truncatedMessage.substring(0, MAX_MESSAGE_LENGTH);
  }

  Analytics().logEvent('Project Warning', {
    projectRoot,
    tag,
    message: truncatedMessage
  });
}

function clearNotification(projectRoot, id) {
  _getLogger(projectRoot).info({
    tag: 'expo',
    issueCleared: true,
    issueId: id
  }, `No issue with ${id}`);
}

function attachLoggerStream(projectRoot, stream) {
  _getLogger(projectRoot).addStream(stream);
} // Wrap with logger


async function readExpRcAsync(projectRoot) {
  try {
    return await ConfigUtils().readExpRcAsync(projectRoot);
  } catch (e) {
    logError(projectRoot, 'expo', e.message);
    return {};
  }
}

async function readConfigJsonAsync(projectRoot, skipValidation = false) {
  try {
    return await ConfigUtils().readConfigJsonAsync(projectRoot, skipValidation);
  } catch (error) {
    logError(projectRoot, 'expo', error.message);
    return {
      exp: null,
      pkg: null
    };
  }
}
//# sourceMappingURL=../__sourcemaps__/project/ProjectUtils.js.map