// Module ID: 6078
// Function ID: 6079
// Name: GuildReadStateStore
// Dependencies: [6079, 6057, 6034, 4752, 2069, 2083, 502, 2065, 2087, 1084, 4750, 6035, 2116, 5966, 1390, 1085, 2072, 5967, 6077, 11, 5943, 2090, 12, 4758, 2]

// Module 6078 (GuildReadStateStore)
import SnowflakeUtilsDefault from "SnowflakeUtils" /* 11 */;
import _modDef12 from "module_12" /* 12 */;
import Constants from "Constants" /* 1085 */;
import ChannelConstants from "ChannelConstants" /* 2072 */;
import GuildRecord from "GuildRecord" /* 2083 */;
import FavoritesUtils from "FavoritesUtils" /* 2090 */;
import ThreadActionUtils from "ThreadActionUtils" /* 4758 */;
import NSFWContentGate from "NSFWContentGate" /* 5943 */;
import isOptInEnabled from "isOptInEnabled" /* 6077 */;
import RecentMentionsStore from "RecentMentionsStore" /* 6079 */;
import NotificationCenterItemsStore from "NotificationCenterItemsStore" /* 6057 */;
import ActiveJoinedThreadsStore from "ActiveJoinedThreadsStore" /* 6034 */;
import JoinedThreadsStore from "JoinedThreadsStore" /* 4752 */;
import ChannelRecord from "ChannelRecord" /* 2069 */;
import AuthenticationStore from "AuthenticationStore" /* 502 */;
import ChannelStore from "ChannelStore" /* 2065 */;
import GuildStore from "GuildStore" /* 2087 */;
import MobileCacheSnapshotStore from "MobileCacheSnapshotStore" /* 1084 */;
import PermissionStore from "PermissionStore" /* 4750 */;
import ReadStateStore from "ReadStateStore" /* 6035 */;
import SelectedChannelStore from "SelectedChannelStore" /* 2116 */;
import UserGuildSettingsStore from "UserGuildSettingsStore" /* 5966 */;
import UserStore from "UserStore" /* 1390 */;
import ReadStateConstants from "ReadStateConstants" /* 5967 */;
import size from "module_2" /* 2 */;

const require = globalThis.__r;
let count, importDefault, nsfwAllowed;

let c10;
let c9;
let closure_21;
let closure_22;
let metroImportAll;
const f92980 = (item) => {
  let tmp;
  let tmp2;
  [tmp, tmp2] = item;
  const tmp3 = Number(tmp) !== constants.GUILD_EVENT && tmp2;
  return tmp3;
};
function updateGuildUnreadSentinel(arg0) {
  let num;
  let tmp = arg0;
  let tmp3 = arg0;
  const tmp2 = guilds;
  if (arg0 == null) {
    tmp3 = NULL_STRING_GUILD_ID;
  }
  let tmp5 = tmp;
  const tmp4 = guilds;
  if (tmp == null) {
    tmp5 = NULL_STRING_GUILD_ID;
  }
  let tmp6 = tmp4[tmp5];
  if (tmp6 == null) {
    const tmp7 = guilds;
    if (tmp == null) {
      tmp = NULL_STRING_GUILD_ID;
    }
    const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
    num = undefined;
    if (tmp7[tmp] != null) {
      num = tmp8.sentinel;
    }
    if (num == null) {
      num = 0;
    }
    tmp6 = obj;
  }
  tmp2[tmp3] = tmp6;
  tmp6.sentinel = tmp6.sentinel + 1;
  closure_26 = closure_26 + 1;
}
function isCountableChannel(channel, mentionCount) {
  let num = mentionCount;
  if (mentionCount === undefined) {
    num = 0;
  }
  if (null == channel) {
    return false;
  } else {
    if (channel.isGuildVocal()) {
      if (0 === num) {
        return false;
      }
    }
    if (channel.hasFlag(ChannelFlags.IS_GUILD_RESOURCE_CHANNEL)) {
      return false;
    } else {
      if (0 === num) {
        let result;
        if (channel.isThread()) {
          result = JoinedThreadsStore.isMuted(channel.id) || UserGuildSettingsStore.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.parent_id);
          const isMutedResult = JoinedThreadsStore.isMuted(channel.id) || UserGuildSettingsStore.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.parent_id);
        } else {
          result = UserGuildSettingsStore.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.id);
        }
        if (result) {
          return false;
        }
      }
      if (!channel.isPrivate()) {
        const obj = isOptInEnabled;
        let result1 = obj.isOptInEnabledForGuild(channel.guild_id);
        let tmp11 = null != channel.guild_id;
        if (tmp11) {
          if (result1) {
            const result2 = authStore(channel.type) || UserGuildSettingsStore.isChannelRecordOrParentOptedIn(channel);
            result1 = !result2;
          }
          if (result1) {
            result1 = tmp2;
          }
          tmp11 = result1;
        }
        if (tmp11) {
          return false;
        } else if (!PermissionStore.can(channel.accessPermissions, channel)) {
          return false;
        }
      }
      const tmp16 = num > 0 || UserGuildSettingsStore.resolveUnreadSetting(channel) === constants2.ALL_MESSAGES;
      return tmp16;
    }
  }
}
function updateNotificationCenterMentions(mentionCounts, mentionCounts2) {
  let c1;
  const f92981 = (item) => {
    const _ackMessageId = notifCenterReadState1._ackMessageId;
    const lastMessageIdResult = ReadStateStore.lastMessageId(item);
    const obj = c1(notifCenterReadState[19]);
    if (obj.compare(lastMessageIdResult, _ackMessageId) > 0) {
      closure_1 = closure_1 + mentionCounts.mentionCounts[item].count;
    }
  };
  if (!NotificationCenterItemsStore.tabFocused) {
    let closure_0 = mentionCounts;
    importDefault = 0;
    let obj = UserStore;
    const currentUser = UserStore.getCurrentUser();
    let notifCenterReadState;
    if (null != currentUser) {
      notifCenterReadState = ReadStateStore.getNotifCenterReadState(currentUser.id);
    }
    if (null != notifCenterReadState) {
      const obj2 = require("SnowflakeUtils");
      const keys = obj2.keys(mentionCounts.mentionCounts);
      const item = keys.forEach(f92981);
    }
    closure_0 = mentionCounts2;
    let closure_1 = 0;
    const currentUser1 = obj.getCurrentUser();
    let notifCenterReadState1;
    const tmp10 = importDefault;
    if (null != currentUser1) {
      notifCenterReadState1 = ReadStateStore.getNotifCenterReadState(currentUser1.id);
    }
    const tmp14 = null == mentionCounts2 || null == notifCenterReadState1;
    if (!tmp14) {
      const obj3 = require("SnowflakeUtils");
      const keys1 = obj3.keys(mentionCounts2.mentionCounts);
      const item1 = keys1.forEach(f92981);
    }
    let num2;
    const _Math = Math;
    const tmp18 = closure_1;
    if (mentionCounts2 != null) {
      num2 = mentionCounts2.ncMentionCount;
    }
    if (num2 == null) {
      num2 = 0;
    }
    mentionCounts.ncMentionCount = max(num2 + (tmp10 - tmp18), 0);
  }
}
function aggregateGuildState(guild_id, unreadByType, unread) {
  let closure_0 = unreadByType;
  const entries = Object.entries(unreadByType.unreadByType);
  unreadByType.unread = entries.some(f92980);
  unreadByType.lowImportanceMentionCount = 0;
  unreadByType.highImportanceMentionCount = 0;
  const arr = SnowflakeUtilsDefault;
  const item = arr.forEach(unreadByType.mentionCounts, (count) => {
    count = count.count;
    if (count.isMentionLowImportance) {
      closure_0.lowImportanceMentionCount = closure_0.lowImportanceMentionCount + count;
    } else {
      closure_0.highImportanceMentionCount = closure_0.highImportanceMentionCount + count;
    }
  });
  let flag = unreadByType.unread !== unread.unread || unreadByType.lowImportanceMentionCount !== unread.lowImportanceMentionCount || unreadByType.highImportanceMentionCount !== unread.highImportanceMentionCount;
  if (flag) {
    let tmp2 = guild_id;
    let tmp5 = guild_id;
    const tmp3 = guilds;
    if (guild_id == null) {
      tmp5 = NULL_STRING_GUILD_ID;
    }
    tmp3[tmp5] = unreadByType;
    if (null != tmp2) {
      if (unreadByType.unread) {
        set.add(tmp2);
      } else {
        set.delete(tmp2);
      }
    }
    closure_26 = closure_26 + 1;
    const tmp9 = updateGuildUnreadSentinel;
    if (tmp2 == null) {
      tmp2 = NULL_STRING_GUILD_ID;
    }
    tmp9(tmp2);
    updateNotificationCenterMentions(unreadByType, unread);
    flag = true;
  }
  return flag;
}
function recountChannels(guildId, items) {
  let num;
  let num2;
  let obj3;
  let obj4;
  let tmp = guildId;
  if (NULL_STRING_GUILD_ID !== guildId) {
    const tmp3 = null;
    let closure_0 = tmp;
    let tmp6 = tmp;
    const tmp4 = guilds;
    if (tmp == null) {
      tmp6 = tmp2;
    }
    let tmp8 = tmp;
    const tmp7 = guilds;
    if (tmp == null) {
      tmp8 = tmp2;
    }
    let tmp9 = tmp7[tmp8];
    if (tmp9 == null) {
      let tmp11 = tmp;
      const tmp10 = guilds;
      if (tmp == null) {
        tmp11 = tmp2;
      }
      const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
      num = undefined;
      if (tmp10[tmp11] != null) {
        num = tmp12.sentinel;
      }
      if (num == null) {
        num = 0;
      }
      tmp9 = obj;
    }
    tmp4[tmp6] = tmp9;
    let tmp14 = tmp;
    const tmp13 = guilds;
    if (tmp == null) {
      tmp14 = tmp2;
    }
    let obj2 = { unread: false, unreadByType: obj4, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: obj3, ncMentionCount: 0, sentinel: num2 };
    num2 = undefined;
    if (tmp13[tmp14] != null) {
      num2 = tmp15.sentinel;
    }
    if (num2 == null) {
      num2 = 0;
    }
    obj3 = {};
    const merged = Object.assign(tmp9.mentionCounts);
    obj4 = {};
    const merged1 = Object.assign(tmp9.unreadByType);
    let c2 = false;
    const item = items.forEach((item) => {
      const channel = ChannelStore.getChannel(item);
      const tmp = item;
      if (null != channel) {
        if (channel.getGuildId() === guildId) {
          const mentionCount = ReadStateStore.getMentionCount(item);
          const hasUnreadResult = null !== tmp3 && !c2 && obj3.hasUnread(channel.id) && isCountableChannel(channel, mentionCount, true);
          if (hasUnreadResult) {
            c2 = true;
            obj2.unreadChannelId = channel.id;
          }
          if (mentionCount > 0) {
            if (isCountableChannel(channel, mentionCount)) {
              obj2 = { count: mentionCount, isMentionLowImportance: ReadStateStore.getIsMentionLowImportance(item) };
              const mentionCounts = obj2.mentionCounts;
              const id = channel.id;
              mentionCounts[id] = obj2;
            }
          }
          delete obj2.mentionCounts[obj.id];
        }
      } else {
        delete obj2.mentionCounts[tmp];
      }
    });
    obj2.unreadByType[constants.CHANNEL] = c2;
    if (obj2.unreadByType[constants.CHANNEL] !== tmp9.unreadByType[constants.CHANNEL]) {
      if (!obj2.unreadByType[constants.CHANNEL]) {
        let channel = ChannelStore.getChannel(tmp9.unreadChannelId);
        if (null != channel) {
          if (!items.includes(channel.id)) {
            if (ReadStateStore.hasUnread(channel.id)) {
              if (isCountableChannel(channel)) {
                if (null != tmp) {
                  set.add(tmp);
                }
                obj2.unreadByType[constants.CHANNEL] = true;
              }
            }
          }
        }
        return recountGuild(tmp);
      }
    }
    return aggregateGuildState(tmp, obj2, tmp9);
  }
  tmp = null;
}
function updateNonChannel(guild_id, GUILD_EVENT) {
  let num;
  let num2;
  let obj3;
  let obj4;
  if (null != guild_id) {
    let tmp2 = guild_id;
    const tmp = guilds;
    if (guild_id == null) {
      tmp2 = NULL_STRING_GUILD_ID;
    }
    let tmp4 = guild_id;
    const tmp3 = guilds;
    if (guild_id == null) {
      tmp4 = NULL_STRING_GUILD_ID;
    }
    let tmp5 = tmp3[tmp4];
    if (tmp5 == null) {
      let tmp7 = guild_id;
      const tmp6 = guilds;
      if (guild_id == null) {
        tmp7 = NULL_STRING_GUILD_ID;
      }
      const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
      num = undefined;
      if (tmp6[tmp7] != null) {
        num = tmp8.sentinel;
      }
      if (num == null) {
        num = 0;
      }
      tmp5 = obj;
    }
    tmp[tmp2] = tmp5;
    let tmp10 = guild_id;
    const tmp9 = guilds;
    if (guild_id == null) {
      tmp10 = NULL_STRING_GUILD_ID;
    }
    const obj2 = { unread: false, unreadByType: obj4, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: obj3, ncMentionCount: 0, sentinel: num2 };
    num2 = undefined;
    if (tmp9[tmp10] != null) {
      num2 = tmp11.sentinel;
    }
    if (num2 == null) {
      num2 = 0;
    }
    obj3 = {};
    const merged = Object.assign(tmp5.mentionCounts);
    obj4 = {};
    const merged1 = Object.assign(tmp5.unreadByType);
    const unreadByType = obj2.unreadByType;
    GUILD_EVENT = constants.GUILD_EVENT;
    const hasUnreadResult = ReadStateStore.hasUnread(guild_id, GUILD_EVENT);
    let tmp20 = hasUnreadResult;
    if (GUILD_EVENT === constants.GUILD_EVENT) {
      let tmp22 = !UserGuildSettingsStore.isMuted(guild_id);
      UserGuildSettingsStore.isMuted(guild_id);
      const obj5 = UserGuildSettingsStore;
      if (tmp22) {
        const result = obj5.isMuteScheduledEventsEnabled(guild_id);
        tmp22 = !result && hasUnreadResult;
      }
      tmp20 = tmp22;
    }
    unreadByType[GUILD_EVENT] = tmp20;
    return aggregateGuildState(guild_id, obj2, tmp5);
  }
}
function recountGuild(guildId, arg1) {
  let entries;
  let isMentionLowImportance;
  let mentionCount;
  let num;
  let num4;
  let tmp15;
  let tmp3;
  let tmp2 = guildId;
  if (NULL_STRING_GUILD_ID !== guildId) {
    let tmp7 = tmp2;
    const tmp5 = guilds;
    if (tmp2 == null) {
      tmp7 = tmp3;
    }
    const obj = { unread: entries.some(f92980), unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
    num = undefined;
    if (tmp5[tmp7] != null) {
      num = tmp8.sentinel;
    }
    if (num == null) {
      num = 0;
    }
    if (null == tmp2) {
      const mutablePrivateChannels = ChannelStore.getMutablePrivateChannels();
      for (const key10166 in mutablePrivateChannels) {
        let tmp106 = mutablePrivateChannels[key10166];
        let mentionCount1 = ReadStateStore.getMentionCount(key10166);
        let tmp80 = mentionCount1 > 0;
        if (tmp80) {
          tmp80 = isCountableChannel(tmp106, mentionCount1);
        }
        if (!tmp80) {
          continue;
        } else {
          obj.highImportanceMentionCount = obj.highImportanceMentionCount + mentionCount1;
          let obj2 = { count: mentionCount1, isMentionLowImportance: false };
          obj.mentionCounts[tmp106.id] = obj2;
          continue;
        }
        continue;
      }
    } else {
      const isMutedResult = UserGuildSettingsStore.isMuted(tmp2);
      if (isMutedResult) {
        if (false === arg1) {
          return false;
        }
      }
      const mutedChannels = obj13.getMutedChannels(tmp2);
      const channelOverrides = obj13.getChannelOverrides(tmp2);
      const obj3 = isOptInEnabled;
      const result = obj3.isOptInEnabledForGuild(tmp2);
      const obj4 = NSFWContentGate;
      const result1 = obj4.currentUserCanSeeNSFW();
      const obj5 = { userCanSeeNSFW: result1, guildIsNSFW: tmp15 };
      tmp15 = !result1 && isGuildNSFW(GuildStore.getGuild(tmp2));
      const mutableBasicGuildChannelsForGuild = ChannelStore.getMutableBasicGuildChannelsForGuild(tmp2);
      for (const key10044 in mutableBasicGuildChannelsForGuild) {
        let obj14 = mutableBasicGuildChannelsForGuild[key10044];
        let hasItem = isMutedResult || mutedChannels.has(key10044);
        if (!hasItem) {
          let hasItem1 = null != obj14.parent_id && mutedChannels.has(obj14.parent_id);
          hasItem = hasItem1;
        }
        let tmp24 = obj.unreadByType[constants.CHANNEL];
        let tmp23 = constants;
        let guildChannelUnreadState = ReadStateStore.getGuildChannelUnreadState(obj14, result, channelOverrides, hasItem, tmp24, obj5);
        ({ mentionCount, isMentionLowImportance } = guildChannelUnreadState);
        let tmp35 = mentionCount > 0;
        if (tmp35) {
          let tmp37 = !tmp24;
          if (tmp37) {
            let tmp38 = !hasItem || tmp35;
            tmp37 = tmp38;
          }
          if (tmp37) {
            tmp37 = tmp34;
          }
          if (tmp37) {
            let tmp40 = React4(obj14.type);
            let tmp41 = !tmp40 || 0 !== mentionCount;
            if (tmp41) {
              let canBasicChannelResult = PermissionStore.canBasicChannel(metroImportAll(obj14.type), obj14);
              if (canBasicChannelResult) {
                let tmp45 = null != obj14.guild_id;
                if (tmp45) {
                  let tmp46 = result;
                  if (tmp46) {
                    let result2 = authStore(obj14.type);
                    if (!result2) {
                      result2 = UserGuildSettingsStore.isChannelRecordOrParentOptedIn(obj14);
                    }
                    tmp46 = !result2;
                  }
                  if (tmp46) {
                    tmp46 = 0 === mentionCount;
                  }
                  tmp45 = tmp46;
                }
                let tmp50 = !tmp45;
                if (tmp50) {
                  let tmp51 = "flags" in obj14;
                  let tmp52 = !tmp51;
                  if (!tmp52) {
                    tmp52 = !obj14.hasFlag(ChannelFlags.IS_GUILD_RESOURCE_CHANNEL);
                  }
                  if (tmp52) {
                    let tmp54 = mentionCount > 0;
                    if (!tmp54) {
                      tmp54 = UserGuildSettingsStore.resolveUnreadSetting(obj14) === constants2.ALL_MESSAGES;
                    }
                    tmp52 = tmp54;
                  }
                  tmp50 = tmp52;
                }
                canBasicChannelResult = tmp50;
              }
              tmp41 = canBasicChannelResult;
            }
            if (!tmp41) {
              continue;
            } else {
              if (tmp37) {
                obj.unreadByType[tmp23.CHANNEL] = true;
                obj.unreadChannelId = key10044;
              }
              if (!tmp35) {
                continue;
              } else {
                if (isMentionLowImportance) {
                  obj.lowImportanceMentionCount = obj.lowImportanceMentionCount + mentionCount;
                } else {
                  obj.highImportanceMentionCount = obj.highImportanceMentionCount + mentionCount;
                }
                let obj6 = { count: mentionCount, isMentionLowImportance };
                obj.mentionCounts[obj14.id] = obj6;
                continue;
              }
              continue;
            }
            continue;
          }
          continue;
        }
        continue;
      }
      const activeJoinedThreadsForGuild = ActiveJoinedThreadsStore.getActiveJoinedThreadsForGuild(tmp2);
      for (const key10119 in activeJoinedThreadsForGuild) {
        let keys = Object.keys();
        if (keys === undefined) {
          continue;
        } else {
          let tmp60 = keys[tmp];
          while (tmp60 !== undefined) {
            let isMutedResult1 = obj.unreadByType[constants.CHANNEL];
            let tmp104 = constants;
            if (!isMutedResult1) {
              isMutedResult1 = !ReadStateStore.hasUnread(tmp60);
            }
            if (!isMutedResult1) {
              isMutedResult1 = JoinedThreadsStore.isMuted(tmp60);
            }
            if (!isMutedResult1) {
              isMutedResult1 = isMutedResult;
            }
            if (!isMutedResult1) {
              obj.unreadByType[tmp104.CHANNEL] = true;
              obj.unreadChannelId = tmp60;
            }
            let mentionCount2 = ReadStateStore.getMentionCount(tmp60);
            let isMentionLowImportance1 = ReadStateStore.getIsMentionLowImportance(tmp60);
            if (mentionCount2 <= 0) {
              continue;
            } else {
              if (isMentionLowImportance1) {
                obj.lowImportanceMentionCount = obj.lowImportanceMentionCount + mentionCount2;
              } else {
                obj.highImportanceMentionCount = obj.highImportanceMentionCount + mentionCount2;
              }
              let obj7 = { count: mentionCount2, isMentionLowImportance: isMentionLowImportance1 };
              obj.mentionCounts[tmp60] = obj7;
              continue;
            }
            continue;
          }
        }
        continue;
      }
      let tmp68 = !obj.unreadByType[constants.GUILD_EVENT];
      if (tmp68) {
        const GUILD_EVENT = tmp67.GUILD_EVENT;
        const hasUnreadResult = ReadStateStore.hasUnread(tmp2, GUILD_EVENT);
        let tmp71 = hasUnreadResult;
        if (GUILD_EVENT === constants.GUILD_EVENT) {
          let tmp73 = !UserGuildSettingsStore.isMuted(tmp2);
          UserGuildSettingsStore.isMuted(tmp2);
          const obj8 = UserGuildSettingsStore;
          if (tmp73) {
            const result3 = obj8.isMuteScheduledEventsEnabled(tmp2);
            tmp73 = !result3 && hasUnreadResult;
          }
          tmp71 = tmp73;
        }
        tmp68 = tmp71;
      }
      if (tmp68) {
        obj.unreadByType[constants.GUILD_EVENT] = true;
      }
    }
    const _Object = Object;
    entries = Object.entries(obj.unreadByType);
    let tmp83 = tmp2;
    const tmp82 = guilds;
    if (tmp2 == null) {
      tmp83 = NULL_STRING_GUILD_ID;
    }
    let tmp85 = tmp2;
    const tmp84 = guilds;
    if (tmp2 == null) {
      tmp85 = NULL_STRING_GUILD_ID;
    }
    let tmp86 = tmp84[tmp85];
    if (tmp86 == null) {
      let tmp88 = tmp2;
      const tmp87 = guilds;
      if (tmp2 == null) {
        tmp88 = NULL_STRING_GUILD_ID;
      }
      const obj9 = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num4 };
      num4 = undefined;
      if (tmp87[tmp88] != null) {
        num4 = tmp89.sentinel;
      }
      if (num4 == null) {
        num4 = 0;
      }
      tmp86 = obj9;
    }
    tmp82[tmp83] = tmp86;
    let flag3 = obj.unread !== tmp86.unread || obj.highImportanceMentionCount !== tmp86.highImportanceMentionCount || obj.lowImportanceMentionCount !== tmp86.lowImportanceMentionCount;
    if (flag3) {
      let tmp91 = tmp2;
      const tmp90 = guilds;
      if (tmp2 == null) {
        tmp91 = NULL_STRING_GUILD_ID;
      }
      tmp90[tmp91] = obj;
      if (null != tmp2) {
        if (obj.unread) {
          set.add(tmp2);
        } else {
          set.delete(tmp2);
        }
      }
      closure_26 = closure_26 + 1;
      const tmp95 = updateGuildUnreadSentinel;
      if (tmp2 == null) {
        tmp2 = NULL_STRING_GUILD_ID;
      }
      tmp95(tmp2);
      updateNotificationCenterMentions(obj, tmp86);
      flag3 = true;
    }
    return flag3;
  }
  tmp2 = null;
}
function handleOverlayInitialize(guilds) {
  let num;
  guilds = {};
  closure_26 = 0;
  new Set();
  recountGuild(null);
  const length = guilds.length;
  for (let num = 0; num < length; num = num + 1) {
    let tmp3 = guilds[num];
    if (null != tmp3) {
      let tmp6 = recountGuild(tmp3.properties.id);
    }
  }
}
function handleConnectionOpen(arg0) {
  let readState;
  ({ guilds, readState } = arg0);
  let set1;
  let closure_24 = {};
  let c26 = 0;
  new Set();
  const currentUser = UserStore.getCurrentUser();
  nsfwAllowed = undefined;
  if (currentUser != null) {
    nsfwAllowed = currentUser.nsfwAllowed;
  }
  set1 = new Set();
  if (readState.entries.length < 500) {
    const entries = readState.entries;
    const item = entries.forEach((mention_count) => {
      const tmp = null != mention_count.mention_count && mention_count.mention_count > 0;
      if (tmp) {
        if (null != mention_count.read_state_type) {
          if (mention_count.read_state_type !== constants.CHANNEL) {
            set1.add(mention_count.id);
          }
        }
        const add = set1.add;
        const channel = ChannelStore.getChannel(mention_count.id);
        let guild_id;
        if (channel != null) {
          guild_id = channel.guild_id;
        }
        add(guild_id);
      }
    });
  }
  recountGuild(null);
  for (const item10037 of guilds) {
    let hasItem;
    let tmp8 = recountGuild;
    let id = item10037.id;
    if (tmp4) {
      hasItem = set1.has(tmp7.id);
    }
    let tmp8Result = tmp8(id, hasItem);
    continue;
  }
}
function recomputeAllGuilds() {
  guilds = {};
  new Set();
  recountGuild(null);
  const values = Object.values(GuildStore.getGuildIds());
  for (const item10021 of values) {
    let tmp5 = recountGuild(item10021);
    continue;
  }
}
function handleGuildCreate(guild) {
  return recountGuild(guild.guild.id);
}
function handleGuildDelete(guild) {
  guild = guild.guild;
  let flag = null != guilds[guild.id];
  if (flag) {
    delete guilds[guild.id];
    set.delete(guild.id);
    closure_26 = closure_26 + 1;
    flag = true;
  }
  return flag;
}
function handleChannelDelete(channel) {
  channel = channel.channel;
  const items = [channel.id];
  return recountChannels(channel.guild_id, items);
}
function handleWindowFocus() {
  const channel = ChannelStore.getChannel(SelectedChannelStore.getChannelId());
  let tmp = null != channel;
  if (tmp) {
    const items = [channel.id];
    tmp = recountChannels(channel.getGuildId(), items);
  }
  return tmp;
}
function handleGuildMemberUpdate(guildId) {
  guildId = guildId.guildId;
  const tmp = guildId.user.id === AuthenticationStore.getId() && recountGuild(guildId);
  return tmp;
}
function handleGenericUpdate(channelId) {
  const channel = ChannelStore.getChannel(channelId.channelId);
  let tmp = null != channel;
  if (tmp) {
    const items = [channel.id];
    tmp = recountChannels(channel.getGuildId(), items);
  }
  return tmp;
}
function handleMessageCreate(channelId) {
  let num;
  channelId = channelId.channelId;
  const channel = ChannelStore.getChannel(channelId);
  if (null == channel) {
    return false;
  } else {
    if (null != channel.guild_id) {
      let result;
      let guild_id = channel.guild_id;
      let tmp = guild_id;
      const tmp14 = guilds;
      if (guild_id == null) {
        tmp = NULL_STRING_GUILD_ID;
      }
      let tmp3 = guild_id;
      const tmp2 = guilds;
      if (guild_id == null) {
        tmp3 = NULL_STRING_GUILD_ID;
      }
      let tmp4 = tmp2[tmp3];
      if (tmp4 == null) {
        const tmp5 = guilds;
        if (guild_id == null) {
          guild_id = NULL_STRING_GUILD_ID;
        }
        const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
        num = undefined;
        if (tmp5[guild_id] != null) {
          num = tmp6.sentinel;
        }
        if (num == null) {
          num = 0;
        }
        tmp4 = obj;
      }
      tmp14[tmp] = tmp4;
      if (channel.isThread()) {
        const hasJoinedResult = JoinedThreadsStore.hasJoined(channel.id);
        let isMutedResult = !hasJoinedResult;
        const obj3 = JoinedThreadsStore;
        if (hasJoinedResult) {
          isMutedResult = obj3.isMuted(channel.id);
        }
        result = isMutedResult;
      } else {
        result = UserGuildSettingsStore.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.id);
      }
      if (result) {
        if (0 === ReadStateStore.getMentionCount(channelId)) {
          return false;
        }
      }
    }
    const items = [channel.id];
    return recountChannels(channel.getGuildId(), items);
  }
}
function handleChannelSelect(arg0) {
  let channelId;
  let guildId;
  ({ channelId, guildId } = arg0);
  const obj = FavoritesUtils;
  let tmp2 = !obj.isFavoritesGuildId(guildId);
  obj.isFavoritesGuildId(guildId);
  if (tmp2) {
    let tmp4 = null != channelId;
    if (tmp4) {
      const items = [channelId];
      tmp4 = recountChannels(guildId, items);
    }
    tmp2 = tmp4;
  }
  return tmp2;
}
function handleChannelUpdate(channel) {
  channel = channel.channel;
  const items = [channel.id];
  return recountChannels(channel.getGuildId(), items);
}
function handleChannelUpdates(channels) {
  const obj = _modDef12(channels.channels);
  const groupByResult = obj.groupBy((getGuildId) => getGuildId.getGuildId());
  return groupByResult.reduce((acc, arr, index) => {
    const tmp = recountChannels(index, arr.map((id) => id.id)) || acc;
    return tmp;
  }, false);
}
function handleBulkAck(channels) {
  const arr = _modDef12(channels.channels);
  const mapped = arr.map((channelId) => channelId.channelId);
  const found = mapped.filter((item) => null != ChannelStore.getChannel(item));
  const groupByResult = found.groupBy((arg0) => {
    const channel = ChannelStore.getChannel(arg0);
    let guildId;
    if (channel != null) {
      guildId = channel.getGuildId();
    }
    return guildId;
  });
  return groupByResult.reduce((acc, item, index) => {
    const tmp = recountChannels(index, item) || acc;
    return tmp;
  }, false);
}
function handleThreadUpdate(channel) {
  channel = channel.channel;
  const items = [, ];
  ({ id: arr[0], parent_id: arr[1] } = channel);
  return recountChannels(channel.getGuildId(), items);
}
function handleGuildEventUpdate(guildScheduledEvent) {
  return updateNonChannel(guildScheduledEvent.guildScheduledEvent.guild_id, constants.GUILD_EVENT);
}
function handleGuildEventDelete(guildScheduledEvent) {
  return updateNonChannel(guildScheduledEvent.guildScheduledEvent.guild_id, constants.GUILD_EVENT);
}
function handleGuildFeatureAck(id) {
  return updateNonChannel(id.id, id.ackType);
}
function handleThreadMemberUpdate(id) {
  const items = [id.id];
  return recountChannels(id.guildId, items);
}
function handleThreadMembersUpdate(id) {
  const obj = ThreadActionUtils;
  let result = obj.doesThreadMembersActionAffectMe(id);
  if (result) {
    const items = [id.id];
    result = recountChannels(id.guildId, items);
  }
  return result;
}
function handleThreadListSync(threads) {
  threads = threads.threads;
  const guildId = threads.guildId;
  const found = threads.filter((id) => JoinedThreadsStore.hasJoined(id.id));
  return recountChannels(guildId, found.map((id) => id.id));
}
function handlePassiveUpdateV2(channels) {
  let tmp = channels.channels.length > 0;
  if (tmp) {
    channels = channels.channels;
    tmp = recountChannels(channels.guildId, channels.map((id) => id.id));
  }
  return tmp;
}
function handleMarkGuildAsRead(guildId) {
  return recountGuild(guildId.guildId);
}
function handleGuildUpdate(guildId) {
  return recountGuild(guildId.guildId);
}
function handleGuildNSFWLevelUpdate(guild) {
  guild = guild.guild;
  const obj = NSFWContentGate;
  const result = obj.currentUserCanSeeNSFW();
  const tmp2 = !result && recountGuild(guild.id);
  return tmp2;
}
function handleCurrentUserNSFWAllowedUpdate() {
  const currentUser = UserStore.getCurrentUser();
  nsfwAllowed = undefined;
  if (currentUser != null) {
    nsfwAllowed = currentUser.nsfwAllowed;
  }
  let flag = nsfwAllowed !== nsfwAllowed;
  if (flag) {
    recomputeAllGuilds();
    flag = true;
  }
  return flag;
}
function handleUserGuildSettingsFullUpdate(userGuildSettings) {
  userGuildSettings = userGuildSettings.userGuildSettings;
  set = new Set(userGuildSettings.map((guild_id) => {
    guild_id = guild_id.guild_id;
    if (guild_id == null) {
      guild_id = NULL_STRING_GUILD_ID;
    }
    return guild_id;
  }));
  const obj = SnowflakeUtilsDefault;
  const keys = obj.keys(guilds);
  return keys.reduce((acc, item) => {
    const hasItem = set.has(item) && recountGuild(item) || acc;
    return hasItem;
  }, false);
}
function handleClearNotifCenterGuildMentions() {
  for (const key10003 in guilds) {
    guilds[key10003].ncMentionCount = 0;
    continue;
  }
}
function handleUserGuildSettingsUpdate(guildId) {
  return recountGuild(guildId.guildId);
}
function handleRecentMentionsSuccess(messages) {
  messages = messages.messages;
  set = new Set(messages.map((channel_id) => channel_id.channel_id));
  const item = set.forEach((item) => {
    channel = channel.getChannel(item);
    if (null != channel) {
      const items = [item];
      recountChannels(channel.getGuildId(), items);
    }
  });
}
({ getBasicAccessPermissions: metroImportAll, isGuildVocalChannelType: c9, isThread: c10 } = ChannelRecord);
const isGuildNSFW = GuildRecord.isGuildNSFW;
const NULL_STRING_GUILD_ID = Constants.NULL_STRING_GUILD_ID;
const ChannelFlags = ChannelConstants.ChannelFlags;
({ ReadStateTypes: closure_21, UnreadSetting: closure_22 } = ReadStateConstants);
let guilds = {};
let set = new Set();
let closure_26 = 0;
class GuildReadStateStore extends MobileCacheSnapshotStore {
  constructor() {
    const obj = {
      CONNECTION_OPEN: handleConnectionOpen,
      OVERLAY_INITIALIZE: handleOverlayInitialize,
      CACHE_LOADED_LAZY() {
        return closure_0.loadCache();
      },
      GUILD_CREATE: handleGuildCreate,
      GUILD_DELETE: handleGuildDelete,
      MESSAGE_CREATE: handleMessageCreate,
      MESSAGE_ACK: handleGenericUpdate,
      BULK_ACK: handleBulkAck,
      UPDATE_CHANNEL_DIMENSIONS: handleGenericUpdate,
      CHANNEL_SELECT: handleChannelSelect,
      CHANNEL_DELETE: handleChannelDelete,
      WINDOW_FOCUS: handleWindowFocus,
      GUILD_ACK: handleMarkGuildAsRead,
      GUILD_ROLE_CREATE: handleGuildUpdate,
      GUILD_ROLE_DELETE: handleGuildUpdate,
      GUILD_ROLE_UPDATE: handleGuildUpdate,
      GUILD_UPDATE: handleGuildNSFWLevelUpdate,
      CURRENT_USER_UPDATE: handleCurrentUserNSFWAllowedUpdate,
      CHANNEL_CREATE: handleChannelUpdate,
      CHANNEL_UPDATES: handleChannelUpdates,
      THREAD_CREATE: handleThreadUpdate,
      THREAD_UPDATE: handleThreadUpdate,
      THREAD_DELETE: handleThreadUpdate,
      THREAD_LIST_SYNC: handleThreadListSync,
      THREAD_MEMBER_UPDATE: handleThreadMemberUpdate,
      THREAD_MEMBERS_UPDATE: handleThreadMembersUpdate,
      PASSIVE_UPDATE_V2: handlePassiveUpdateV2,
      GUILD_MEMBER_UPDATE: handleGuildMemberUpdate,
      USER_GUILD_SETTINGS_FULL_UPDATE: handleUserGuildSettingsFullUpdate,
      USER_GUILD_SETTINGS_CHANNEL_UPDATE: handleUserGuildSettingsUpdate,
      USER_GUILD_SETTINGS_CHANNEL_UPDATE_BULK: handleUserGuildSettingsUpdate,
      USER_GUILD_SETTINGS_GUILD_UPDATE: handleUserGuildSettingsUpdate,
      USER_GUILD_SETTINGS_GUILD_AND_CHANNELS_UPDATE: handleUserGuildSettingsUpdate,
      GUILD_FEATURE_ACK: handleGuildFeatureAck,
      GUILD_SCHEDULED_EVENT_CREATE: handleGuildEventUpdate,
      GUILD_SCHEDULED_EVENT_UPDATE: handleGuildEventUpdate,
      GUILD_SCHEDULED_EVENT_DELETE: handleGuildEventDelete,
      CHANNEL_RTC_UPDATE_CHAT_OPEN: handleGenericUpdate,
      LOAD_MESSAGES_SUCCESS: handleGenericUpdate,
      CHANNEL_ACK: handleGenericUpdate,
      CHANNEL_LOCAL_ACK: handleGenericUpdate,
      NOTIFICATION_SETTINGS_UPDATE: recomputeAllGuilds,
      RECOMPUTE_READ_STATES: recomputeAllGuilds,
      VOICE_CHANNEL_SELECT: handleGenericUpdate,
      ENABLE_AUTOMATIC_ACK: handleGenericUpdate,
      RESORT_THREADS: handleGenericUpdate,
      NOTIFICATION_CENTER_CLEAR_GUILD_MENTIONS: handleClearNotifCenterGuildMentions,
      TRY_ACK: handleGenericUpdate,
      LOAD_RECENT_MENTIONS_SUCCESS: handleRecentMentionsSuccess
    };
    const tmp2 = new tmp(obj, handleClearNotifCenterGuildMentions, handleGenericUpdate, new.target);
    let closure_0 = tmp2;
    return tmp2;
  }
  initialize() {
    this.waitFor(ChannelStore, GuildStore, SelectedChannelStore, ReadStateStore, PermissionStore, AuthenticationStore, UserStore, UserGuildSettingsStore, ActiveJoinedThreadsStore, JoinedThreadsStore, RecentMentionsStore);
  }
  loadCache() {
    const snapshot = this.readSnapshot(GuildReadStateStore.LATEST_SNAPSHOT_VERSION);
    if (null != snapshot) {
      guilds = snapshot.guilds;
      const _Set = Set;
      const self = this;
      const self2 = this;
      new Set(snapshot.unreadGuilds);
    }
  }
  takeSnapshot() {
    const obj = { version: GuildReadStateStore.LATEST_SNAPSHOT_VERSION, data: { guilds, unreadGuilds: Array.from(set) } };
    ({ guilds, unreadGuilds: Array.from(set) });
    return obj;
  }
  hasAnyUnread() {
    return set.size > 0;
  }
  getStoreChangeSentinel() {
    return closure_26;
  }
  getMutableUnreadGuilds() {
    return set;
  }
  getMutableGuildStates() {
    return guilds;
  }
  shouldCountChannelUnread(channel, mentionCount) {
    let num = mentionCount;
    if (mentionCount === undefined) {
      num = 0;
    }
    return isCountableChannel(channel, num, true);
  }
  hasUnread(arg0) {
    return set.has(arg0);
  }
  getMentionCount(arg0) {
    let num;
    let tmp = arg0;
    let tmp3 = arg0;
    const tmp2 = guilds;
    if (arg0 == null) {
      tmp3 = NULL_STRING_GUILD_ID;
    }
    let tmp5 = tmp;
    const tmp4 = guilds;
    if (tmp == null) {
      tmp5 = NULL_STRING_GUILD_ID;
    }
    let tmp6 = tmp4[tmp5];
    if (tmp6 == null) {
      const tmp7 = guilds;
      if (tmp == null) {
        tmp = NULL_STRING_GUILD_ID;
      }
      const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
      num = undefined;
      if (tmp7[tmp] != null) {
        num = tmp8.sentinel;
      }
      if (num == null) {
        num = 0;
      }
      tmp6 = obj;
    }
    tmp2[tmp3] = tmp6;
    return tmp6.highImportanceMentionCount + tmp6.lowImportanceMentionCount;
  }
  getIsMentionLowImportance(arg0) {
    let num;
    let tmp = arg0;
    let tmp3 = arg0;
    const tmp2 = guilds;
    if (arg0 == null) {
      tmp3 = NULL_STRING_GUILD_ID;
    }
    let tmp5 = tmp;
    const tmp4 = guilds;
    if (tmp == null) {
      tmp5 = NULL_STRING_GUILD_ID;
    }
    let tmp6 = tmp4[tmp5];
    if (tmp6 == null) {
      const tmp7 = guilds;
      if (tmp == null) {
        tmp = NULL_STRING_GUILD_ID;
      }
      const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
      num = undefined;
      if (tmp7[tmp] != null) {
        num = tmp8.sentinel;
      }
      if (num == null) {
        num = 0;
      }
      tmp6 = obj;
    }
    tmp2[tmp3] = tmp6;
    return 0 === tmp6.highImportanceMentionCount;
  }
  getGuildHasUnreadIgnoreMuted(id) {
    const mutableGuildChannelsForGuild = ChannelStore.getMutableGuildChannelsForGuild(id);
    for (const key10008 in mutableGuildChannelsForGuild) {
      let obj = mutableGuildChannelsForGuild[key10008];
      if (null == obj) {
        continue;
      } else {
        if (!obj.isGuildVocal()) {
          if (!PermissionStore.can(obj.accessPermissions, obj)) {
            continue;
          } else if (!ReadStateStore.hasUnreadOrMentions(key10008)) {
            continue;
          } else {
            let flag = true;
            return true;
          }
          continue;
        }
        continue;
      }
      continue;
    }
    const activeJoinedThreadsForGuild = ActiveJoinedThreadsStore.getActiveJoinedThreadsForGuild(id);
    for (const key10027 in activeJoinedThreadsForGuild) {
      if (null == ChannelStore.getChannel(key10027)) {
        continue;
      } else {
        let keys = Object.keys();
        if (keys === undefined) {
          continue;
        } else {
          let tmp8 = keys[tmp];
          while (tmp8 !== undefined) {
            if (!ReadStateStore.hasUnreadOrMentions(tmp8)) {
              continue;
            } else {
              let flag2 = true;
              return true;
            }
          }
        }
        continue;
      }
      continue;
    }
    return ReadStateStore.hasUnreadOrMentions(id, constants.GUILD_EVENT);
  }
  getTotalMentionCount(arg0) {
    let num = 0;
    let num2 = 0;
    const keys = Object.keys();
    if (keys !== undefined) {
      num2 = num;
      while (keys[tmp] !== undefined) {
        let tmp7 = tmp2;
        let tmp10 = guilds[tmp5];
        if (tmp2) {
          tmp7 = tmp5 === NULL_STRING_GUILD_ID;
        }
        if (tmp7) {
          continue;
        } else {
          num = tmp4 + tmp10.highImportanceMentionCount;
          continue;
        }
        continue;
      }
    }
    return num2;
  }
  getTotalNotificationsMentionCount(arg0) {
    let num = 0;
    let num2 = 0;
    const keys = Object.keys();
    if (keys !== undefined) {
      num2 = num;
      while (keys[tmp] !== undefined) {
        let tmp7 = tmp2;
        let tmp10 = guilds[tmp5];
        if (tmp2) {
          tmp7 = tmp5 === NULL_STRING_GUILD_ID;
        }
        if (tmp7) {
          continue;
        } else {
          num = tmp4 + tmp10.ncMentionCount;
          continue;
        }
        continue;
      }
    }
    return num2;
  }
  getPrivateChannelMentionCount() {
    let num;
    if (guilds[NULL_STRING_GUILD_ID] != null) {
      num = tmp.highImportanceMentionCount;
    }
    if (num == null) {
      num = 0;
    }
    return num;
  }
  getMentionCountForPrivateChannel(channelId) {
    let num;
    if (guilds[NULL_STRING_GUILD_ID] != null) {
      num = tmp.mentionCounts[channelId];
    }
    if (num == null) {
      num = 0;
    }
    return num;
  }
  getHighImportanceMentionCountForChannel(guild_id, currentlySelectedChannelId) {
    let tmp = guild_id;
    const tmp2 = guilds;
    if (guild_id == null) {
      tmp = NULL_STRING_GUILD_ID;
    }
    let tmp4;
    if (tmp2[tmp] != null) {
      tmp4 = tmp3.mentionCounts[currentlySelectedChannelId];
    }
    let num = 0;
    if (null != tmp4) {
      num = 0;
      if (!tmp4.isMentionLowImportance) {
        num = tmp4.count;
      }
    }
    return num;
  }
  getGuildChangeSentinel(arg0) {
    let num;
    let tmp = arg0;
    let tmp3 = arg0;
    const tmp2 = guilds;
    if (arg0 == null) {
      tmp3 = NULL_STRING_GUILD_ID;
    }
    let tmp5 = tmp;
    const tmp4 = guilds;
    if (tmp == null) {
      tmp5 = NULL_STRING_GUILD_ID;
    }
    let tmp6 = tmp4[tmp5];
    if (tmp6 == null) {
      const tmp7 = guilds;
      if (tmp == null) {
        tmp = NULL_STRING_GUILD_ID;
      }
      const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0, sentinel: num };
      num = undefined;
      if (tmp7[tmp] != null) {
        num = tmp8.sentinel;
      }
      if (num == null) {
        num = 0;
      }
      tmp6 = obj;
    }
    tmp2[tmp3] = tmp6;
    return tmp6.sentinel;
  }
}
const prototype = GuildReadStateStore.prototype;
GuildReadStateStore.displayName = "GuildReadStateStore";
GuildReadStateStore.LATEST_SNAPSHOT_VERSION = 1;
const guildReadStateStore = new GuildReadStateStore();
let result = size.fileFinishedImporting("stores/GuildReadStateStore.tsx");

export default guildReadStateStore;