"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var Notifications =
/*#__PURE__*/
function () {
  function Notifications(userId, companyId) {
    _classCallCheck(this, Notifications);

    this.userId = userId;
    this.companyId = companyId;
    this.connected = false;
    this.socket = null;
    this.listeners = [];
  }

  _createClass(Notifications, [{
    key: "connect",
    value: function connect(userId, companyId) {
      this.userId = userId || this.userId;
      this.companyId = companyId || this.companyId;
      this.socket = new BFSSocket(this.userId, this.companyId, this.run.bind(this));
      this.connected = true;
    }
  }, {
    key: "on",
    value: function on(nameOrFunc, func) {
      var forMeToo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      var once = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

      if (!func) {
        func = nameOrFunc;
        nameOrFunc = "*";
      }

      this.listeners.push({
        name: nameOrFunc,
        func: func,
        forMeToo: forMeToo,
        once: once,
        active: true
      });
    }
  }, {
    key: "once",
    value: function once(nameOrFunc, func) {
      var forMeToo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      return this.on(nameOrFunc, func, forMeToo, true);
    }
  }, {
    key: "off",
    value: function off(nameOrFunc, func, forMeToo) {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = this.listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var listener = _step.value;

          if (func && nameOrFunc == listener.name && func == listener.func || !func && typeof nameOrFunc == 'string' && nameOrFunc == listener.name || !func && typeof nameOrFunc == 'function' && nameOrFunc == listener.func) {
            if (!forMeToo || forMeToo == listener.forMeToo) {
              listener.active = false;
            }
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
            _iterator["return"]();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
  }, {
    key: "run",
    value: function run(data) {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = this.listeners[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var listener = _step2.value;

          if ((data.name == listener.name || listener.name == "*") && (listener.forMeToo || data.userId != this.userId) && listener.active) {
            listener.func.call(this, data);

            if (listener.once) {
              listener.active = false;
            }
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
            _iterator2["return"]();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
  }]);

  return Notifications;
}();

$(function () {
  $.ajaxSetup({
    cache: false,
    xhrFields: {
      withCredentials: true
    }
  });
  var globalDialog = $("#global-dialog");
  var modalEventButtons = $("[settings-button]");
  ModernJs.Linker.config(modalEventButtons, {
    parser: function parser(href) {
      globalDialog.dialog("open");
      loader.setOnceTarget(globalDialog);
      return href;
    }
  });
  window.loader = {};

  loader.parser = function (code) {
    return code;
  };

  loader.done = function (code) {
    return code;
  };

  loader.wait = config.waitCode;
  loader.clear = true;
  loader.dontLoadToken = "{X}";
  loader.forceHash = false;
  loader.lastHash = location.hash;
  window.context = new Context();
  window.notifications = new Notifications();
  var iframe = $("#IframeMainFrame");
  loader.target = iframe;

  loader.setTarget = function (target) {
    loader.target = target;
  };

  loader.setOnceTarget = function (target) {
    var forceHash = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    loader.onceTarget = target;
    loader.forceHash = forceHash; // TODO !!!
  };

  function loadPage(pageQuery, page) {
    $("#new-data-for-page").css("display", "");
    $(".tooltip-inner").remove();
    var target = loader.onceTarget || loader.target;

    if (target == loader.dontLoadToken) {
      loader.onceTarget = null;
      return;
    }

    if (page.dialog && target.is(iframe)) {
      history.back();
      return;
    }

    ModernJs.Templater.config(target, {
      parser: function parser(code) {
        code = loader.parser(code);

        if (!ModernJs.isDefined(code)) {
          return null;
        }

        var redirectAlias = config.redirectAlias;

        if (code.indexOf(redirectAlias) == 0) {
          context.redirect(code.split(redirectAlias)[1]);
          return null;
        }

        return code;
      },
      done: function done(code) {
        var quillNodes = $("[quill-editor]");

        for (var i = 0; i < quillNodes.length; i++) {
          var quillNode = $(quillNodes[i]);
          var quill = new Quill(quillNode[0], {
            theme: 'snow'
          });
          quillNode.removeAttr("quill-editor");
          quillNode.data("quill", quill);
        }

        code = loader.done(code);

        if (!ModernJs.isDefined(code)) {
          return null;
        }

        var ctx = new Context();

        if (target.is(iframe)) {
          window.context.unload();
          window.context = ctx;
        } else {
          var _globalDialog = $("#global-dialog");

          _globalDialog.find("[translate-input]:not([translate-language])").translate();

          globalDialogFooterCreate();
          var redirect = ctx.redirect;

          ctx.redirect = function () {
            loader.setOnceTarget(target);
            redirect.apply(void 0, arguments);
          };

          context.add(target, ctx);
        }

        ctx.reload = hashChange;
        ctx.page = page;

        try {
          var mainUserInfo = target.find("[main-user-info]");
          var mainCompanyInfo = target.find("[main-company-info]");
          ctx.user = JSON.parse(mainUserInfo.attr("main-user-info"));
          ctx.company = JSON.parse(mainCompanyInfo.attr("main-company-info"));
          mainUserInfo.remove();

          if (!notifications.connected || window.notifications.userId != ctx.user.id) {} // notifications.connect(ctx.user.id, ctx.company.id);
          // let userLogoContainer = $(`.user-logo-container img`);
          // let userLogoLetters = $(`.user-logo-letters`);
          // let userAvatarContainer = $(`.user-avatar-container img`);
          // let userAvatarLetters = $(`.user-avatar-letters`);
          //
          // userLogoContainer.attr(`src`, `${config.imagePath}/${ctx.user.logo}`);
          // userAvatarContainer.attr(`src`, `${config.imagePath}/${ctx.user.avatar}`);
          // userLogoContainer.off(`error`);
          // userLogoContainer.on(`error`, function(){
          //   userLogoContainer.hide();
          //   userLogoLetters.text(`${ctx.company.Nazwa_skrot}`);
          //   userLogoLetters.show();
          // });
          // userAvatarContainer.off(`error`);
          // userAvatarContainer.on(`error`, function(){
          //   userAvatarContainer.hide();
          //   userAvatarLetters.text(`${ctx.user.Imie.charAt(0)}${ctx.user.Nazwisko.charAt(0)}`);
          //   userAvatarLetters.show();
          // });

        } catch (e) {}

        try {
          var mainQueryInfo = target.find("[main-query-info]");
          ctx.query = JSON.parse(mainQueryInfo.attr("main-query-info"));
          mainQueryInfo.remove();
        } catch (e) {
          context.query = '';
        }

        if (target.is(iframe)) {
          $("title").html(dictionary.config.titles[page.title]);
          $("#IframeMainCss").remove();
          $("<link id='IframeMainCss' />").attr({
            href: "/pages/".concat(page.css || "".concat(page.name, ".css")),
            type: "text/css",
            rel: "stylesheet"
          }).appendTo('head');
          $("#IframeMainJs").remove();
          $("<script id='IframeMainJs' ></script>").attr({
            src: "/pages/".concat(page.js || "".concat(page.name, ".js")),
            type: "text/javascript"
          }).appendTo('head');
        } else {
          target.find("link[iframe-main-css]").remove();
          $("<link iframe-main-css />").attr({
            href: "/pages/".concat(page.css || "".concat(page.name, ".css")),
            type: "text/css",
            rel: "stylesheet"
          }).prependTo(target);
          target.find("script[iframe-main-js]").remove();
          $("<script iframe-main-js ></script>").attr({
            src: "/pages/".concat(page.js || "".concat(page.name, ".js")),
            type: "text/javascript"
          }).prependTo(target);
        }

        var requiredInputs = $("[required]");
        requiredInputs.parent().find("label").addClass("required-label");
        context.load();
      }
    });
    ModernJs.Templater.ajax(target, {
      url: "/pages/".concat(page.url || page.name).concat(pageQuery),
      wait: loader.wait,
      clear: loader.clear
    });

    if (loader.onceTarget != null) {
      if (loader.forceHash) {
        loader.forceHash = false;
        loader.onceTarget = null;
        return;
      }

      location.hash = loader.lastHash;
      loader.onceTarget = loader.dontLoadToken;
    }
  }

  function keyup(event) {
    if (event.keyCode == 13) {
      //enter
      context.enter();
      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

      try {
        for (var _iterator3 = context.list[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var item = _step3.value;
          item.context.enter();
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
            _iterator3["return"]();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }
    }
  }

  function hashChange() {
    var hash = location.hash;
    loader.lastHash = loader.hash;
    loader.hash = hash;
    var alias = config.alias;
    var query = config.query;

    if (hash.indexOf(alias) == 0 && !loader.paralax && !loader.afterParalax) {
      var pageName = hash.substr(alias.length);
      var pageQuery = "";

      if (pageName.indexOf(query) != -1) {
        var parts = pageName.split(query);
        pageName = parts[0];
        pageQuery = "?".concat(parts[1]);
      }

      var page404 = null;
      var _iteratorNormalCompletion4 = true;
      var _didIteratorError4 = false;
      var _iteratorError4 = undefined;

      try {
        for (var _iterator4 = config.pages[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
          var page = _step4.value;

          if (page['404']) {
            page404 = page;
          }

          if (page.name == pageName) {
            if (page.menu === false) {
              context.hideMenu();
            }

            loadPage(pageQuery, page);
            return;
          }
        }
      } catch (err) {
        _didIteratorError4 = true;
        _iteratorError4 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
            _iterator4["return"]();
          }
        } finally {
          if (_didIteratorError4) {
            throw _iteratorError4;
          }
        }
      }

      if (ModernJs.isDefined(page404)) {
        loadPage(pageQuery, page404);
      }
    } else if (!loader.paralax && !loader.afterParalax) {
      var _iteratorNormalCompletion5 = true;
      var _didIteratorError5 = false;
      var _iteratorError5 = undefined;

      try {
        for (var _iterator5 = config.pages[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
          var _page = _step5.value;

          if (_page["default"]) {
            loadPage("", _page);
          }
        }
      } catch (err) {
        _didIteratorError5 = true;
        _iteratorError5 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion5 && _iterator5["return"] != null) {
            _iterator5["return"]();
          }
        } finally {
          if (_didIteratorError5) {
            throw _iteratorError5;
          }
        }
      }
    } else {
      loader.paralax = null;

      if (!loader.afterParalax) {
        loader.afterParalax = true;
        location.hash = loader.lastHash;
      } else {
        loader.afterParalax = null;
      }
    }
  }

  $(window).off("hashchange");
  $(window).off("keyup");
  $(window).on("hashchange", hashChange);
  $(window).on("keyup", keyup);
  hashChange();
});