'use strict';

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

var _slicedToArray = function () { function sliceIterator(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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _chalk;

function _load_chalk() {
  return _chalk = _interopRequireDefault(require('chalk'));
}

var _path;

function _load_path() {
  return _path = _interopRequireWildcard(require('path'));
}

var _command;

function _load_command() {
  return _command = _interopRequireDefault(require('../../command'));
}

var _scope;

function _load_scope() {
  return _scope = require('../../../api/scope');
}

var _consumer;

function _load_consumer() {
  return _consumer = require('../../../api/consumer');
}

var _constants;

function _load_constants() {
  return _constants = require('../../../constants');
}

var _generalError;

function _load_generalError() {
  return _generalError = _interopRequireDefault(require('../../../error/general-error'));
}

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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Init = function (_Command) {
  _inherits(Init, _Command);

  function Init() {
    var _ref;

    var _temp, _this, _ret;

    _classCallCheck(this, Init);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Init.__proto__ || Object.getPrototypeOf(Init)).call.apply(_ref, [this].concat(args))), _this), _this.name = 'init [path]', _this.description = `initialize an empty bit scope\n  https://${(_constants || _load_constants()).BASE_DOCS_DOMAIN}/docs/cli-init.html`, _this.alias = '', _this.opts = [['b', 'bare [name]', 'initialize an empty bit bare scope'], ['s', 'shared <groupname>', 'add group write permissions to a scope properly'], ['t', 'standalone [boolean]', 'do not nest component store within .git directory '], ['r', 'reset', 'write missing or damaged Bit files'], ['', 'reset-hard', 'delete all Bit files and directories, including Bit configuration, tracking and model data. Useful for re-start using Bit from scratch']], _temp), _possibleConstructorReturn(_this, _ret);
  }

  _createClass(Init, [{
    key: 'action',
    value: function action(_ref2, _ref3) {
      var _ref4 = _slicedToArray(_ref2, 1),
          path = _ref4[0];

      var bare = _ref3.bare,
          shared = _ref3.shared,
          standalone = _ref3.standalone,
          reset = _ref3.reset,
          resetHard = _ref3.resetHard;

      if (path) path = (_path || _load_path()).resolve(path);
      if (bare) {
        if (reset || resetHard) throw new (_generalError || _load_generalError()).default('--reset and --reset-hard flags are not available for bare scope');
        if (typeof bare === 'boolean') bare = '';
        return (0, (_scope || _load_scope()).initScope)(path, bare, shared).then(function (_ref5) {
          var created = _ref5.created;

          return {
            created,
            bare: true
          };
        });
      }
      if (reset && resetHard) throw new (_generalError || _load_generalError()).default('please use --reset or --reset-hard. not both');
      return (0, (_consumer || _load_consumer()).init)(path, standalone, reset, resetHard).then(function (_ref6) {
        var created = _ref6.created,
            addedGitHooks = _ref6.addedGitHooks,
            existingGitHooks = _ref6.existingGitHooks;

        return {
          created,
          addedGitHooks,
          existingGitHooks,
          reset,
          resetHard
        };
      });
    }
  }, {
    key: 'report',
    value: function report(_ref7) {
      var created = _ref7.created,
          bare = _ref7.bare,
          addedGitHooks = _ref7.addedGitHooks,
          existingGitHooks = _ref7.existingGitHooks,
          reset = _ref7.reset,
          resetHard = _ref7.resetHard;

      if (bare) {
        // if (!created) return `${chalk.grey('successfully reinitialized a bare bit scope.')}`;
        // @TODO - a case that you already have a bit scope
        return `${(_chalk || _load_chalk()).default.green('successfully initialized an empty bare bit scope.')}`;
      }

      var initMessage = `${(_chalk || _load_chalk()).default.green('successfully initialized a bit workspace.')}`;

      if (!created) initMessage = `${(_chalk || _load_chalk()).default.grey('successfully reinitialized a bit workspace.')}`;
      if (reset) initMessage = `${(_chalk || _load_chalk()).default.grey('your bit workspace has been reset successfully.')}`;
      if (resetHard) initMessage = `${(_chalk || _load_chalk()).default.grey('your bit workspace has been hard-reset successfully.')}`;
      // const addedGitHooksTemplate = _generateAddedGitHooksTemplate(addedGitHooks);
      // const existingGitHooksTemplate = _generateExistingGitHooksTemplate(existingGitHooks);
      // return `${initMessage}\n${addedGitHooksTemplate}\n${existingGitHooksTemplate}`;
      return initMessage;
    }
  }]);

  return Init;
}((_command || _load_command()).default);

exports.default = Init;


function _generateAddedGitHooksTemplate(addedGitHooks) {
  if (addedGitHooks && addedGitHooks.length > 0) {
    return (_chalk || _load_chalk()).default.green(`the following git hooks were added: ${addedGitHooks.join(', ')}`);
  }
  return '';
}

function _generateExistingGitHooksTemplate(existingGitHooks) {
  if (existingGitHooks && existingGitHooks.length > 0) {
    return (_chalk || _load_chalk()).default.yellow(`warning: the following git hooks are already existing: ${existingGitHooks.join(', ')}\nplease add the following code to your hooks: \`bit import\``);
  }
  return '';
}