// Module ID: 7269
// Function ID: 7270
// Name: ScheduledMessageUtils
// Dependencies: [32, 4472, 1378, 1086, 1380, 7270, 3, 38, 1441, 7101, 1391, 1253, 558, 576, 504, 4424, 1127, 11, 1976, 5059, 7271, 1376, 2]
// Exports: canSendScheduledMessagesInChannel, canUseScheduledMessages, convertServerScheduledMessageCreateArgs, convertServerScheduledMessageSend, getDefaultScheduledTime, getEarliestScheduledTime, getLatestScheduledTime, getMessageForState, getPresetScheduledTimes, getScheduledMessagesLimit, getScheduledTimeError, parseContentAndFlagsForSilentMessage, trackScheduledMessageTimePickerOpened, unparseContentAndFlagsForSilentMessage

// Module 7269 (ScheduledMessageUtils)
import LoggerDefault from "Logger" /* 3 */;
import SnowflakeUtilsDefault from "SnowflakeUtils" /* 11 */;
import _modDef38 from "module_38" /* 38 */;
import react from "react" /* 576 */;
import intl7 from "intl" /* 1127 */;
import AnalyticsUtilsDefault from "AnalyticsUtils" /* 1253 */;
import GlobalUtils from "GlobalUtils" /* 1376 */;
import PremiumConstants from "PremiumConstants" /* 1380 */;
import FlagUtils from "FlagUtils" /* 1391 */;
import PremiumTypeUtils from "PremiumTypeUtils" /* 1976 */;
import _modDef4424 from "module_4424" /* 4424 */;
import MessageRecordUtils from "MessageRecordUtils" /* 5059 */;
import parseContentForSuppressNotificationsDefault from "parseContentForSuppressNotifications" /* 7101 */;
import ScheduledMessageTypes from "ScheduledMessageTypes" /* 7271 */;
import _slicedToArray from "_slicedToArray" /* 32 */;
import PermissionStore from "PermissionStore" /* 4472 */;
import UserStore from "UserStore" /* 1378 */;
import Constants from "Constants" /* 1086 */;
import ScheduledMessagesConstants from "ScheduledMessagesConstants" /* 7270 */;
import ApexExperiment from "ApexExperiment" /* 1441 */;
import ReactCompilerGating_mod from "ReactCompilerGating" /* 558 */;
import size from "module_2" /* 2 */;

const require = globalThis.__r;
let _require;

let c10;
let closure_12;
let map1;
let merged;
let metroImportAll;
let metroImportDefault;
let metroRequire;
let obj2;
let tmp;
let unpackModuleId;
const get_initialized = tmp(504);
const parseContentForSuppressNotifications = tmp(7101);
({ AnalyticEvents: metroRequire, MessageFlags: metroImportDefault, Permissions: metroImportAll } = Constants);
const PremiumTypes = PremiumConstants.PremiumTypes;
({ MAX_SCHEDULE_TIME_AFTER_CREATION_SECONDS: c10, MAX_SCHEDULE_TIME_INTO_FUTURE_SECONDS: unpackModuleId, MAX_SCHEDULED_MESSAGES_PER_USER: closure_12, MIN_SCHEDULE_TIME_INTO_FUTURE_SECONDS: map1 } = ScheduledMessagesConstants);
let tmp4 = new LoggerDefault("Scheduled Messages");
class ScheduledMessagesConfig {
  constructor(enabled, limit) {
    const merged = Object.assign({ enabled: false, limit: 0 });
    _modDef38(null != limit.limit, "Config is missing scheduled message limit");
    merged.enabled = enabled;
    merged.limit = limit.limit;
    return merged;
  }
}
let obj = { name: "2026-08-scheduled-messages", kind: "user", defaultConfig: merged, variations: obj2 };
const createApexExperiment = ApexExperiment.createApexExperiment;
merged = Object.assign({ enabled: false, limit: 0 });
let tmp7 = _modDef38(true, "Config is missing scheduled message limit");
merged.enabled = false;
merged.limit = 0;
obj2 = {
  1: null,
  2: (arg0) => {
    const parsed = JSON.parse(arg0);
    if (typeof ScheduledMessagesConfig === "function") {
      const merged = Object.assign({ enabled: false, limit: 0 });
      _modDef38(null != parsed.limit, "Config is missing scheduled message limit");
      merged.enabled = true;
      merged.limit = parsed.limit;
      return merged;
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  }
};
obj2[2] = (arg0) => {
  const parsed = JSON.parse(arg0);
  if (typeof ScheduledMessagesConfig === "function") {
    const merged = Object.assign({ enabled: false, limit: 0 });
    _modDef38(null != parsed.limit, "Config is missing scheduled message limit");
    merged.enabled = true;
    merged.limit = parsed.limit;
    return merged;
  } else {
    throw new TypeError("Trying to call a non-function");
  }
};
let closure_15 = createApexExperiment(obj);
let ReactCompilerGating = ReactCompilerGating_mod;
const tmp8 = ReactCompilerGating.isReactCompilerEnabled() ? (() => {
  let first;
  const obj = react;
  const cResult = obj.c(1);
  if (cResult[0] === Symbol.for("react.memo_cache_sentinel")) {
    const obj2 = { location: "useCanUseScheduledMessages" };
    cResult[0] = obj2;
    first = obj2;
  } else {
    first = cResult[0];
  }
  return closure_15.useConfig(first).enabled;
}) : (() => closure_15.useConfig({ location: "useCanUseScheduledMessages" }).enabled);
let closure_16 = tmp8;
ReactCompilerGating = ReactCompilerGating_mod;
let tmp9 = ReactCompilerGating.isReactCompilerEnabled() ? ((arg0) => {
  let closure_0;
  let first;
  let tmp7;
  _require = arg0;
  let tmp = _require;
  const obj = require("react");
  const cResult = obj.c(3);
  let stateFromStores = closure_16();
  if (cResult[0] === Symbol.for("react.memo_cache_sentinel")) {
    const items = [PermissionStore];
    cResult[0] = items;
    first = items;
  } else {
    first = cResult[0];
  }
  if (cResult[1] !== arg0) {
    const fn = function l() {
      let tmp = null != closure_0;
      if (tmp) {
        tmp = obj.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, obj);
        const canResult = obj.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, obj);
      }
      return tmp;
    };
    cResult[1] = arg0;
    cResult[2] = fn;
    tmp7 = fn;
  } else {
    tmp7 = cResult[2];
  }
  const tmpResult = tmp(504);
  if (stateFromStores) {
    stateFromStores = tmpResult.useStateFromStores(first, tmp7);
  }
  return stateFromStores;
}) : ((arg0) => {
  let closure_0;
  _require = arg0;
  let stateFromStores = closure_16();
  const obj = require("get initialized");
  const items = [PermissionStore];
  if (stateFromStores) {
    stateFromStores = obj.useStateFromStores(items, () => {
      let tmp = null != closure_0;
      if (tmp) {
        tmp = obj.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, obj);
        const canResult = obj.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, obj);
      }
      return tmp;
    });
  }
  return stateFromStores;
});
ReactCompilerGating = ReactCompilerGating_mod;
let tmp10 = ReactCompilerGating.isReactCompilerEnabled() ? ((location) => {
  let TIER_2;
  let currentUser;
  let obj5;
  let tmp4;
  let tmp6;
  let tmp7;
  let obj = react;
  const cResult = obj.c(7);
  if (cResult[0] !== location) {
    const obj2 = { location };
    cResult[0] = location;
    cResult[1] = obj2;
    tmp4 = obj2;
  } else {
    tmp4 = cResult[1];
  }
  const config = closure_15.useConfig(tmp4);
  if (cResult[2] === Symbol.for("react.memo_cache_sentinel")) {
    const items = [UserStore];
    const fn = function c() {
      const obj = require("PremiumTypeUtils");
      return obj.isPremium(currentUser.getCurrentUser(), TIER_2.TIER_2);
    };
    cResult[2] = items;
    cResult[3] = fn;
    tmp7 = fn;
    tmp6 = items;
  } else {
    tmp6 = cResult[2];
    tmp7 = cResult[3];
  }
  const tmpResult = get_initialized;
  const stateFromStores = tmpResult.useStateFromStores(tmp6, tmp7);
  if (cResult[4] === config) {
    let tmp10;
    if (cResult[5] === stateFromStores) {
      tmp10 = cResult[6];
    }
    return tmp10;
  }
  if (config.enabled) {
    let obj4;
    if (stateFromStores) {
      obj4 = { limit, isUpgradable: false };
      const obj3 = { limit, isUpgradable: false };
    } else {
      obj4 = { limit: config.limit, isUpgradable: true };
    }
    obj5 = obj4;
  } else {
    obj5 = { limit: 0, isUpgradable: false };
  }
  cResult[4] = config;
  cResult[5] = stateFromStores;
  cResult[6] = obj5;
  tmp10 = obj5;
}) : ((location) => {
  let TIER_2;
  let currentUser;
  let obj5;
  let obj = { location };
  const config = closure_15.useConfig(obj);
  const items = [UserStore];
  const obj2 = get_initialized;
  if (config.enabled) {
    let obj4;
    if (obj2.useStateFromStores(items, () => {
      const obj = require("PremiumTypeUtils");
      return obj.isPremium(currentUser.getCurrentUser(), TIER_2.TIER_2);
    })) {
      obj4 = { limit, isUpgradable: false };
      const obj3 = { limit, isUpgradable: false };
    } else {
      obj4 = { limit: config.limit, isUpgradable: true };
    }
    obj5 = obj4;
  } else {
    obj5 = { limit: 0, isUpgradable: false };
  }
  return obj5;
});
function canUseScheduledMessages(location) {
  const obj = { location };
  return closure_15.getConfig(obj).enabled;
}
function getEarliestScheduledTime() {
  const obj = _modDef4424();
  return obj.add(map1, "seconds");
}
function getLatestScheduledTime(arg0) {
  const obj = _modDef4424();
  const addResult = obj.add(unpackModuleId, "seconds");
  if (null == arg0) {
    return addResult;
  } else {
    const tmpResult = _modDef4424;
    const tmpResult3 = SnowflakeUtilsDefault;
    const tmpResultResult = tmpResult(tmpResult3.extractTimestamp(arg0));
    const tmpResult4 = _modDef4424;
    return tmpResult4.min(addResult, tmpResultResult.add(authStore, "seconds"));
  }
}
function convertServerScheduledMessageCreateArgs(channelId) {
  return { channelId: channelId.channel_id, content: channelId.content, type: channelId.type, flags: channelId.flags, messageReference: channelId.message_reference };
}
let result = size.fileFinishedImporting("modules/scheduled_messages/ScheduledMessageUtils.tsx");

export const scheduledMessageLogger = tmp4;
export const parseContentAndFlagsForSilentMessage = function parseContentAndFlagsForSilentMessage(arg0) {
  let content;
  let flags;
  let tmp4;
  ({ content, flags } = arg0);
  const tmp2 = _slicedToArray(parseContentForSuppressNotificationsDefault(content), 2);
  const items = [, ];
  if (tmp2[0]) {
    items[0] = tmp2[1];
    const addFlag = FlagUtils.addFlag;
    FlagUtils;
    if (flags == null) {
      flags = 0;
    }
    items[1] = addFlag(flags, metroImportDefault.SUPPRESS_NOTIFICATIONS);
    tmp4 = items;
  } else {
    items[0] = content;
    let num = flags;
    if (flags == null) {
      num = 0;
    }
    items[1] = num;
    tmp4 = items;
  }
  return tmp4;
};
export const unparseContentAndFlagsForSilentMessage = function unparseContentAndFlagsForSilentMessage(createArgs) {
  let content;
  let flags;
  ({ content, flags } = createArgs);
  const hasFlag = FlagUtils.hasFlag;
  FlagUtils;
  if (flags == null) {
    flags = 0;
  }
  let combined = content;
  if (hasFlag(flags, metroImportDefault.SUPPRESS_NOTIFICATIONS)) {
    const _HermesInternal = HermesInternal;
    combined = "" + parseContentForSuppressNotifications.SILENT_SENTINEL + " " + content;
  }
  return combined;
};
export const trackScheduledMessageTimePickerOpened = function trackScheduledMessageTimePickerOpened(arg0) {
  let channelId;
  let entryPoint;
  let isEditing;
  ({ entryPoint, isEditing, channelId } = arg0);
  const obj = AnalyticsUtilsDefault;
  obj.track(metroRequire.SCHEDULED_MESSAGE_TIME_PICKER_OPENED, { entry_point: entryPoint, is_editing: isEditing, channel_id: channelId });
};
export const useCanUseScheduledMessages = tmp8;
export const useCanSendScheduledMessagesInChannel = tmp9;
export { canUseScheduledMessages };
export const canSendScheduledMessagesInChannel = function canSendScheduledMessagesInChannel(isPrivate, location) {
  const obj = { location };
  let enabled = closure_15.getConfig(obj).enabled;
  if (enabled) {
    enabled = isPrivate.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, isPrivate);
    const canResult = isPrivate.isPrivate() || PermissionStore.can(metroImportAll.SEND_MESSAGES, isPrivate);
  }
  return enabled;
};
export const getPresetScheduledTimes = function getPresetScheduledTimes() {
  let addResult1;
  let intl3;
  let tmp6;
  let tmp7;
  let tmp9;
  const obj = _modDef4424();
  const addResult = obj.add(map1, "seconds");
  const obj2 = _modDef4424();
  const startOfResult = obj2.startOf("day");
  const result = startOfResult.set("hours", 9);
  const obj5 = _modDef4424();
  const startOfResult1 = obj5.startOf("day");
  const result1 = startOfResult1.set("hours", 13);
  const obj3 = { label: null, value: null };
  const isAfterResult = result.isAfter(addResult);
  const intl = intl7.intl;
  const string = intl.string;
  const t = intl7.t;
  if (isAfterResult) {
    obj3.label = string(t["qINKo/"]);
    obj3.value = result;
    tmp6 = tmp5;
    tmp7 = obj3;
  } else {
    obj3.label = string(t.tjIn9i);
    obj3.value = result.add(1, "day");
    tmp6 = tmp5;
    tmp7 = obj3;
  }
  const items = [tmp7, , ];
  const obj4 = { label: null, value: null };
  const isAfterResult1 = result1.isAfter(addResult);
  const intl2 = tmp6(1127).intl;
  const string2 = intl2.string;
  const t2 = tmp6(1127).t;
  if (isAfterResult1) {
    obj4.label = string2(t2.qT6LjY);
    obj4.value = result1;
    tmp9 = obj4;
  } else {
    obj4.label = string2(t2.EMRZyS);
    obj4.value = result1.add(1, "day");
    tmp9 = obj4;
  }
  items[1] = tmp9;
  const obj6 = { label: intl3.string(tmp6(1127).t["+P5MmK"]), value: addResult1.set("hours", 9) };
  intl3 = tmp6(1127).intl;
  const obj11 = _modDef4424();
  const startOfResult2 = obj11.startOf("isoWeek");
  items[2] = obj6;
  addResult1 = startOfResult2.add(1, "week");
  return items;
};
export const getDefaultScheduledTime = function getDefaultScheduledTime() {
  const obj = _modDef4424();
  const startOfResult = obj.startOf("hour");
  const addResult = startOfResult.add(1, "hour");
  const isBefore = addResult.isBefore;
  let addResult1 = addResult;
  const obj4 = _modDef4424();
  if (isBefore(obj4.add(map1, "seconds"))) {
    addResult1 = addResult.add(1, "hour");
  }
  return addResult1;
};
export const getScheduledTimeError = function getScheduledTimeError(isBefore, arg1) {
  let stringResult;
  isBefore = isBefore.isBefore;
  const obj = _modDef4424();
  if (isBefore(obj.add(map1, "seconds"))) {
    const intl2 = intl7.intl;
    stringResult = intl2.string(intl7.t["w/fgvh"]);
  } else {
    const isAfter = isBefore.isAfter;
    const obj2 = _modDef4424();
    const addResult = obj2.add(unpackModuleId, "seconds");
    let minResult = addResult;
    if (null != arg1) {
      const tmpResult = _modDef4424;
      const tmpResult3 = SnowflakeUtilsDefault;
      const tmpResultResult = tmpResult(tmpResult3.extractTimestamp(arg1));
      const tmpResult4 = _modDef4424;
      minResult = tmpResult4.min(addResult, tmpResultResult.add(authStore, "seconds"));
    }
    stringResult = null;
    if (isAfter(minResult)) {
      const intl = intl7.intl;
      stringResult = intl.string(intl7.t.Nt0tz7);
    }
  }
  return stringResult;
};
export { getEarliestScheduledTime };
export { getLatestScheduledTime };
export const getScheduledMessagesLimit = function getScheduledMessagesLimit(ScheduledMessagesCreateRoadblock) {
  let obj5;
  const obj = PremiumTypeUtils;
  const obj2 = { location: ScheduledMessagesCreateRoadblock };
  const isPremiumResult = obj.isPremium(UserStore.getCurrentUser(), PremiumTypes.TIER_2);
  const config = closure_15.getConfig(obj2);
  if (config.enabled) {
    let obj4;
    if (isPremiumResult) {
      obj4 = { limit, isUpgradable: false };
      const obj3 = { limit, isUpgradable: false };
    } else {
      obj4 = { limit: config.limit, isUpgradable: true };
    }
    obj5 = obj4;
  } else {
    obj5 = { limit: 0, isUpgradable: false };
  }
  return obj5;
};
export const useScheduledMessagesLimit = tmp10;
export const convertServerScheduledMessageSend = function convertServerScheduledMessageSend(body) {
  let attachment_uploads;
  let createMessageRecord;
  let create_args;
  let obj2;
  const obj = { userId: body.user_id, scheduledMessageId: body.scheduled_message_id, sendAtTimestamp: body.send_at_timestamp, createArgs: { channelId: create_args.channel_id, content: create_args.content, type: create_args.type, flags: create_args.flags, messageReference: create_args.message_reference }, state: body.state, attachmentUploads: attachment_uploads.map((filename) => ({ filename: filename.filename, uploadedFilename: filename.uploaded_filename, description: filename.description, title: filename.title })), record: createMessageRecord(obj2) };
  create_args = body.create_args;
  attachment_uploads = body.attachment_uploads;
  if (attachment_uploads == null) {
    attachment_uploads = [];
  }
  obj2 = { timestamp: body.send_at_timestamp };
  createMessageRecord = MessageRecordUtils.createMessageRecord;
  MessageRecordUtils;
  const merged = Object.assign(body.message_preview);
  return obj;
};
export const getMessageForState = function getMessageForState(state) {
  let intl;
  let intl2;
  let intl3;
  let intl4;
  let intl5;
  let intl6;
  if (ScheduledMessageTypes.ScheduledMessageSendState.SCHEDULED === state) {
    const obj = { isError: false, stateMessage: intl6.string(intl7.t.Fn6Odn) };
    intl6 = tmp(1127).intl;
    return obj;
  } else if (ScheduledMessageTypes.ScheduledMessageSendState.ERROR_CHANNEL_NOT_FOUND === state) {
    const obj2 = { isError: true, stateMessage: intl5.string(intl7.t.v5O2dK) };
    intl5 = tmp(1127).intl;
    return obj2;
  } else if (ScheduledMessageTypes.ScheduledMessageSendState.ERROR_USER_NOT_FOUND === state) {
    const obj3 = { isError: true, stateMessage: intl4.string(intl7.t.j8uIfG) };
    intl4 = tmp(1127).intl;
    return obj3;
  } else if (ScheduledMessageTypes.ScheduledMessageSendState.ERROR_USER_CANNOT_USE_SCHEDULED_MESSAGES === state) {
    const obj4 = { isError: true, stateMessage: intl3.string(intl7.t["w6zHX/"]) };
    intl3 = tmp(1127).intl;
    return obj4;
  } else if (ScheduledMessageTypes.ScheduledMessageSendState.ERROR_SEND_FAILED === state) {
    const obj5 = { isError: true, stateMessage: intl2.string(intl7.t.pflV7z) };
    intl2 = tmp(1127).intl;
    return obj5;
  } else if (ScheduledMessageTypes.ScheduledMessageSendState.ERROR_SCHEDULED_MESSAGES_DISABLED === state) {
    const obj6 = { isError: true, stateMessage: intl.string(intl7.t.j8uIfG) };
    intl = tmp(1127).intl;
    return obj6;
  } else {
    const tmpResult = GlobalUtils;
    tmpResult.assertNever(state);
  }
};
export { convertServerScheduledMessageCreateArgs };