// Module ID: 9937
// Function ID: 9938
// Name: useGuildEventRecurrences
// Dependencies: [32, 19, 7636, 504, 9938, 9805, 12, 11, 1091, 9921, 2]
// Exports: default

// Module 9937 (useGuildEventRecurrences)
import _modDef12 from "module_12" /* 12 */;
import ScheduleUtils from "ScheduleUtils" /* 9805 */;
import GuildScheduledEventManagerDefault from "GuildScheduledEventManager" /* 9921 */;
import usePrevValueDefault from "usePrevValue" /* 9938 */;
import _slicedToArray from "module_32" /* 32 */;
import noop from "module_19" /* 19 */;
import GuildScheduledEventStore from "GuildScheduledEventStore" /* 7636 */;

const require = globalThis.__r;

require = fn;
const size = fn(2);
const result = size.fileFinishedImporting("modules/guild_scheduled_events/useGuildEventRecurrences.tsx");

export default function useGuildEventRecurrences(arg0, arg1, byWeekday) {
  _require = arg0;
  importDefault = arg1;
  dependencyMap = byWeekday;
  let items = [recurrenceStartTimes];
  const stateFromStores = require("initialize").useStateFromStores(items, () => GuildScheduledEventStore.getGuildScheduledEvent(closure_0));
  const tmp4 = usePrevValueDefault(byWeekday);
  closure_4 = tmp4;
  if (null != byWeekday) {
    if (null != stateFromStores) {
      const tmpResult = tmp(9805);
      let _Date = Date;
      let rRule = tmp(9805).getRRule(byWeekday);
      let date = new Date(stateFromStores.scheduled_start_time);
      const nextRecurrences = tmpResult.generateNextRecurrences(4, rRule, date);
      const tmpResult2 = tmp(9805);
    }
    const tmp14 = stateFromStores(tmp5([]), 2);
    recurrenceStartTimes = tmp14[0];
    closure_6 = tmp14[1];
    const items1 = [byWeekday, recurrenceStartTimes.length, stateFromStores, tmp4];
    const effect = obj2.useEffect(() => {
      if (null != closure_4) {
        if (null != closure_2) {
          if (null != stateFromStores) {
            if (!obj3.isEqual(tmp, tmp12)) {
              const rRule = ScheduleUtils.getRRule(tmp12);
              const _Date = Date;
              const date = new Date(tmp13.scheduled_start_time);
              closure_6(ScheduleUtils.generateNextRecurrences(first.length, rRule, date));
            }
            obj3 = _modDef12;
          }
        }
      }
    }, items1);
    const items2 = [arg0, arg1, recurrenceStartTimes];
    const effect1 = obj2.useEffect(() => {
      if (null != closure_1) {
        const mapped = first.map((getTime) => {
          const time = getTime.getTime();
          const rounded = Math.floor(time / closure_1_1(1091).Millis.SECOND);
          return closure_1_1(11).fromTimestamp(rounded * closure_1_1(1091).Millis.SECOND);
        });
        const guildEventUserCounts = GuildScheduledEventManagerDefault.getGuildEventUserCounts(tmp, closure_0, mapped);
      }
    }, items2);
    const items3 = [byWeekday, recurrenceStartTimes, ];
    let scheduled_start_time;
    if (stateFromStores != null) {
      scheduled_start_time = stateFromStores.scheduled_start_time;
    }
    items3[2] = scheduled_start_time;
    let obj3 = {
      recurrenceStartTimes,
      canViewMoreRecurrences: obj2.useMemo(() => {
          if (null != closure_2) {
            if (0 !== first.length) {
              let scheduled_start_time;
              if (stateFromStores != null) {
                scheduled_start_time = stateFromStores.scheduled_start_time;
              }
              if (null != scheduled_start_time) {
                const _Date = Date;
                const date = new Date();
                const fullYear = date.getFullYear();
                date.setFullYear(fullYear + ScheduleUtils.MAX_YEARS_AHEAD_RECURRING_EVENT);
                const rRule = ScheduleUtils.getRRule(tmp);
                const afterResult = rRule.after(arr[arr.length - 1]);
                return null != afterResult && afterResult <= date;
              }
            }
          }
          return false;
        }, items3),
      updateRecurrenceStartTimes() {
          if (null != closure_2) {
            if (null != stateFromStores) {
              const rRule = ScheduleUtils.getRRule(tmp);
              const items = [];
              const arraySpreadResult = HermesBuiltin.arraySpread(first, 0);
              const obj2 = ScheduleUtils;
              HermesBuiltin.arraySpread(obj2.generateNextRecurrences(4, rRule, first[first.length - 1], true), arraySpreadResult);
              closure_6(items);
            }
          }
        }
    };
    return obj3;
  }
};