'use strict';

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; }; })();

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

var ESCAPE_LOOKUP = {
  '&': '&amp;',
  '>': '&gt;',
  '<': '&lt;',
  '"': '&quot;',
  '\'': '&#x27;'
};
var ESCAPE_REGEX = /[&><'']/g;

global.Rev = (function () {
  function Revelry() {
    _classCallCheck(this, Revelry);
  }

  _createClass(Revelry, null, [{
    key: 'appObject',
    value: function appObject(name, object) {
      return Revelry.registerObject('App.' + name, object);
    }
  }, {
    key: 'registerObject',
    value: function registerObject(name, object) {
      var parts = name.split('.');
      var container = Revelry;

      _(parts).each(function (part, i) {

        if (i === parts.length - 1) {
          if (container[part] !== null && typeof container[part] !== 'undefined' && name !== 'App.Components.Main') {
            console.warn('Object previously defined: ' + name);
          }
          container[part] = object;
        } else {
          container[part] = container[part] || {};
          container = container[part];
        }
      });

      return object;
    }
  }, {
    key: 'appComponent',
    value: function appComponent(name, object) {
      name = 'App.Components.' + name;
      return Revelry.registerObject(name, Revelry.createReactClass(name, object));
    }
  }, {
    key: 'registerComponent',
    value: function registerComponent(name, object) {
      name = 'Components.' + name;
      return Revelry.registerObject(name, Revelry.createReactClass('Rev.' + name, object));
    }
  }, {
    key: 'createReactClass',
    value: function createReactClass(displayName, object) {
      object.displayName = displayName;

      // Initialize mixins to an empty array if it doesn't exist yet
      if (!object.mixins) {
        object.mixins = [];
      } else if (!(object.mixins instanceof Array)) {
        throw new Error(displayName + '\'s mixins property must be an array.');
      }

      // Check for inclusion of missing mixins
      object.mixins.forEach(function (mixin, index) {
        if (mixin === null || typeof mixin === 'undefined') {
          console.warn(displayName + ' attempted to include a missing mixin at index ' + index + '.');
        }
      });

      // Add Revelry Core mixin
      object.mixins.unshift(Revelry.Mixins.Core);

      if (typeof object === 'function') {
        // ES6 or Coffeescript class, OK as-is
        return object;
      }
      // Old style react class - pass to createClass
      return React.createClass(object);
    }
  }, {
    key: 'appMixin',
    value: function appMixin(name, object) {
      if (object === null || typeof object === 'undefined') {
        throw new Error('Missing mixin `' + name + '`');
      }
      return Revelry.registerObject('App.Mixins.' + name, object);
    }
  }, {
    key: 'registerMixin',
    value: function registerMixin(name, object) {
      if (object === null || typeof object === 'undefined') {
        throw new Error('Missing mixin `' + name + '`');
      }
      return Revelry.registerObject('Mixins.' + name, object);
    }
  }, {
    key: 'registerExample',
    value: function registerExample(name, object) {
      name = 'Examples.' + name;
      return Revelry.registerObject(name, Revelry.createReactClass('Rev.' + name, object));
    }
  }, {
    key: 'appExample',
    value: function appExample(name, object) {
      name = 'App.Examples.' + name;
      return Revelry.registerObject(name, Revelry.createReactClass(name, object));
    }
  }, {
    key: 'registerModel',
    value: function registerModel(name, object) {
      return Revelry.registerObject('Models.' + name, object);
    }
  }, {
    key: 'appModel',
    value: function appModel(name, object) {
      return Revelry.registerObject('App.Models.' + name, object);
    }
  }, {
    key: 'pullInto',
    value: function pullInto(context) {
      console.warn('`Rev.pullInto` is deprecated.');
      return function () {
        for (var _len = arguments.length, names = Array(_len), _key = 0; _key < _len; _key++) {
          names[_key] = arguments[_key];
        }

        names.forEach(function (name) {
          return context[name] = Rev.Components[name];
        });
      };
    }
  }, {
    key: '_escaper',
    value: function _escaper(match) {
      return ESCAPE_LOOKUP[match];
    }
  }, {
    key: 'escapeTextForBrowser',
    value: function escapeTextForBrowser(text) {
      return ('' + text).replace(ESCAPE_REGEX, Revelry._escaper);
    }
  }, {
    key: '_resetUniqueId',
    value: function _resetUniqueId() {
      var idCounter = 0;

      _.uniqueId = function (prefix) {
        var id = '' + ++idCounter;

        return prefix ? prefix + id : id;
      };
    }
  }, {
    key: 'hasView',
    value: function hasView(path) {
      return Revelry.Components.Main.hasView(path);
    }
  }, {
    key: 'viewToString',
    value: function viewToString(path, options) {
      Revelry._resetUniqueId();

      var Main = Revelry.App.Components.Main;

      var props = {
        path: path,
        options: JSON.parse(options)
      };

      var json = Revelry.escapeTextForBrowser(JSON.stringify(props));

      var tag = function tag(inner) {
        return '<div data-react-class=\'App.Components.Main\' data-react-props=\'' + json + '\'>' + inner + '</div>';
      };

      var component = React.createElement(Main, props);

      // 2 checks: One is for standard Rails apps and one for jsonapi-resources.
      if (props.options.disable_prerender || props.options.meta && props.options.meta['disable-prerender']) {
        return tag;
      }

      try {
        if (React.renderComponentToString !== null && typeof React.renderComponentToString !== 'undefined') {
          // < 0.13
          return tag(React.renderComponentToString(component));
        } else {
          // >= 0.13
          return tag(React.renderToString(component));
        }
      } catch (e) {
        return '<pre><code>' + path + '</code></pre>' + ('<pre><code>' + Revelry.escapeTextForBrowser(e.stack) + '</code></pre>') + tag('') + ('<pre><code>' + json + '</code></pre>');
      }
    }
  }, {
    key: 'initExecjsRails',
    value: function initExecjsRails() {
      global.execjs_rails_has_view = Revelry.hasView.bind(Revelry);
      global.execjs_rails_handler = Revelry.viewToString.bind(Revelry);
    }
  }]);

  return Revelry;
})();

global.App = Rev.App = {
  Mixins: {},
  Components: {},
  Examples: {}
};