// Module ID: 5109
// Function ID: 5110
// Name: GuildsNodeType
// Dependencies: [38, 12, 2]
// Exports: createFolderNode, createGuildNode

// Module 5109 (GuildsNodeType)
let obj = { ROOT: "root", FOLDER: "folder", GUILD: "guild" };
const result = require("set").fileFinishedImporting("modules/guilds_bar/GuildsTree.tsx");
class GuildsTree {
  constructor() {
    obj = Object.create(new.target.prototype);
    obj = { type: closure_3.ROOT, children: [] };
    obj.root = obj;
    obj.nodes = {};
    obj.version = 0;
    return obj;
  }
}
const prototype = GuildsTree.prototype;
prototype["getSnapshot"] = function getSnapshot() {
  const self = this;
  let obj = {};
  for (const key10005 in this.nodes) {
    let tmp = key10005;
    let tmp2 = self.nodes[key10005];
    obj = {};
    let tmp3 = obj;
    let tmp4 = tmp2;
    let merged = Object.assign(tmp2);
    obj.children = undefined;
    let children = tmp2.children;
    obj.childrenIds = children.map((id) => id.id);
    obj[key10005] = obj;
    continue;
  }
  obj = { rootChildrenIds: children1.map((id) => id.id), nodes: obj };
  children1 = self.root.children;
  return obj;
};
prototype["loadSnapshot"] = function loadSnapshot(tree) {
  let self = this;
  self = this;
  this.nodes = tree.nodes;
  for (const key10006 in this.nodes) {
    let tmp3 = key10006;
    let tmp4 = self.nodes[key10006];
    if (!("childrenIds" in tmp4)) {
      continue;
    } else {
      let childrenIds = tmp4.childrenIds;
      tmp4.children = childrenIds.map((arg0) => self.nodes[arg0]);
      delete tmp2[tmp];
      continue;
    }
    continue;
  }
  const rootChildrenIds = tree.rootChildrenIds;
  self.root.children = rootChildrenIds.map((arg0) => self.nodes[arg0]);
  self.version = self.version + 1;
};
prototype["moveNextTo"] = function moveNextTo(node, node1, moveToBelow) {
  let flag = moveToBelow;
  if (moveToBelow === undefined) {
    flag = false;
  }
  const self = this;
  this._pluckNode(node);
  if (null != node1.parentId) {
    let root = self.nodes[node1.parentId];
  } else {
    root = self.root;
  }
  const children = root.children;
  const index = children.indexOf(node1);
  let tmp7 = node.type === obj.FOLDER;
  if (tmp7) {
    tmp7 = root.type === tmp6.FOLDER;
  }
  importDefault(38)(!tmp7, "[GUILDS TREE] Tried moving a folder (" + node.id + ") inside of another folder (" + root.id + ")");
  const tmp3 = importDefault;
  const tmp5 = importDefault(38);
  importDefault(38)(index >= 0, "[GUILDS TREE] target node (" + node1.id + ") did not exist within its specified parent (" + node1.parentId + ")");
  let num = 0;
  if (flag) {
    num = 1;
  }
  const items = [...root.children];
  root.children = items;
  const children1 = root.children;
  children1.splice(index + num, 0, node);
  node.parentId = root.id;
  self.version = self.version + 1;
  return self;
};
prototype["moveInto"] = function moveInto(node, c0, flag) {
  if (flag === undefined) {
    flag = true;
  }
  const self = this;
  this._pluckNode(node);
  let num = 0;
  if (flag) {
    num = c0.children.length;
  }
  const items = [...c0.children];
  c0.children = items;
  const children = c0.children;
  children.splice(num, 0, node);
  node.parentId = c0.id;
  self.version = self.version + 1;
  return self;
};
prototype["addNode"] = function addNode(type, c0, flag) {
  const self = this;
  let root = c0;
  if (c0 === undefined) {
    root = self.root;
  }
  if (flag === undefined) {
    flag = true;
  }
  importDefault(38)(type.type !== obj.ROOT, "[GUILDS TREE] Tried adding another root node into the tree");
  importDefault(38)(null != type.id, "[GUILDS TREE] Tried adding a node without an id");
  importDefault(38)(null == self.nodes[type.id], "[GUILDS TREE] Tried adding a node that already exists (" + type.id + ")");
  self.nodes[type.id] = type;
  self.version = self.version + 1;
  return self.moveInto(type, root, flag);
};
prototype["removeNode"] = function removeNode(id) {
  importDefault(38)(id !== this.root, "[GUILDS TREE] Tried removing the root node from the tree");
  importDefault(38)(null != id.id, "[GUILDS TREE] Tried removing a node without an id");
  this._pluckNode(id);
  id.parentId = undefined;
  delete tmp2[tmp];
  this.version = this.version + 1;
  return this;
};
prototype["replaceNode"] = function replaceNode(node, cloneNodeResult) {
  const self = this;
  importDefault(38)(null != node.id, "[GUILDS TREE] Tried replacing a node without an id");
  importDefault(38)(null != cloneNodeResult.id, "[GUILDS TREE] Tried replacing a node with one that does not have an id");
  if (null != node.parentId) {
    let root = self.nodes[node.parentId];
  } else {
    root = self.root;
  }
  const children = root.children;
  const index = children.indexOf(node);
  importDefault(38)(index >= 0, "[GUILDS TREE] existing node (" + node.id + ") did not exist within its specified parent (" + node.parentId + ")");
  const items = [...root.children];
  root.children = items;
  const children1 = root.children;
  children1.splice(index, 1, cloneNodeResult);
  cloneNodeResult.parentId = root.id;
  node.parentId = undefined;
  delete tmp2[tmp];
  self.nodes[cloneNodeResult.id] = cloneNodeResult;
  self.version = self.version + 1;
  return self;
};
prototype["cloneNode"] = function cloneNode(node) {
  return require(12) /* apply */.clone(node);
};
prototype["convertToFolder"] = function convertToFolder(node) {
  const self = this;
  let rounded = Math.floor(4294967296 * Math.random());
  if (null != this.getNode(rounded)) {
    do {
      let _Math = Math;
      let _Math2 = Math;
      let rounded1 = Math.floor(4294967296 * Math.random());
      rounded = rounded1;
      node = self.getNode(rounded1);
    } while (null != node);
  }
  obj = { type: obj.FOLDER, id: rounded, expanded: false, children: [] };
  self.replaceNode(node, obj);
  self.removeNode(node);
  self.addNode(node, obj, false);
  self.version = self.version + 1;
  return obj;
};
prototype["allNodes"] = function allNodes() {
  return Object.values(this.nodes);
};
prototype["getNode"] = function getNode(arg0) {
  return this.nodes[arg0];
};
prototype["getRoots"] = function getRoots() {
  return this.root.children;
};
Object.defineProperty(prototype, "size", {
  get: function size() {
    return this.allNodes().length;
  },
  set: undefined
});
prototype["sortedGuildNodes"] = function sortedGuildNodes() {
  const root = this.root;
  if (root.type === obj.GUILD) {
    const items = [root];
    let items1 = items;
  } else if (null == root.children) {
    items1 = [];
  } else {
    const children = root.children;
    const mapped = children.map((type) => {
      if (type.type === closure_3.GUILD) {
        let items = [type];
        let items1 = items;
      } else if (null == type.children) {
        items1 = [];
      } else {
        let children = type.children;
        let mapped = children.map((type) => {
          if (type.type === closure_3.GUILD) {
            let items = [type];
            let items1 = items;
          } else if (null == type.children) {
            items1 = [];
          } else {
            let children = type.children;
            let mapped = children.map((type) => {
              if (type.type === closure_3.GUILD) {
                let items = [type];
                let items1 = items;
              } else if (null == type.children) {
                items1 = [];
              } else {
                let children = type.children;
                let mapped = children.map((type) => {
                  if (type.type === closure_3.GUILD) {
                    let items = [type];
                    let items1 = items;
                  } else if (null == type.children) {
                    items1 = [];
                  } else {
                    let children = type.children;
                    let mapped = children.map(() => { ... });
                    items1 = mapped.flat();
                  }
                  return items1;
                });
                items1 = mapped.flat();
              }
              return items1;
            });
            items1 = mapped.flat();
          }
          return items1;
        });
        items1 = mapped.flat();
      }
      return items1;
    });
    items1 = mapped.flat();
  }
  return items1;
};
prototype["_pluckNode"] = function _pluckNode(parentId) {
  const self = this;
  let closure_0 = parentId;
  if (null != parentId.parentId) {
    let root = self.nodes[parentId.parentId];
  } else {
    root = self.root;
  }
  importDefault(38)(null != root, "[GUILDS TREE] source node (" + parentId.id + ") had a parent id (" + parentId.parentId + ") which doesn't exist in the tree");
  const children = root.children;
  const tmp = importDefault(38);
  const tmp2 = null != root;
  importDefault(38)(null != children, "[GUILDS TREE] source node (" + parentId.id + ") had a parent id (" + parentId.parentId + ") which contains no children");
  root.children = children.filter((arg0) => arg0 !== closure_0);
  parentId.parentId = undefined;
  self.version = self.version + 1;
};

export const GuildsNodeType = obj;
export { GuildsTree };
export const createGuildNode = function createGuildNode(item10030, id) {
  obj = { type: obj.GUILD, id: item10030, parentId: id, children: [], unavailable: false };
  return obj;
};
export const createFolderNode = function createFolderNode(folderId, parentId, closure_7) {
  obj = { type: obj.FOLDER, id: folderId.folderId, parentId, name: null, color: null, expanded: null, children: null };
  const folderName = folderId.folderName;
  obj[3] = folderName;
  const folderColor = folderId.folderColor;
  let tmp = closure_7;
  obj[4] = folderColor;
  if (null == closure_7) {
    let flag = folderId.expanded;
    if (flag == null) {
      flag = false;
    }
    tmp = flag;
  }
  obj[5] = tmp;
  obj[6] = [];
  return obj;
};