// Metro module 1213 (f1214).
import _objectWithoutProperties from "./_objectWithoutProperties";
import { WebAnalyticsEvents } from "./Module505";
import { Logger } from "./log";
import * as _Module1214 from "./Module1214";
import { UnitType, UnitTypeToKind, ExperimentFlags, LOGGED_OUT_USER_ID_SENTINEL } from "./Module1215";
import MurmurHashV3 from "./MurmurHashV3";
import Module589 from "./Module589";
import { Storage } from "./Module595";
let c1021_7, c1021_8, evaluatedExperiments, c1021_10, clientOverrides, c1021_12, c1021_13, c1021_14, c1021_15, c1021_16, c1021_17, c1021_18, c1021_19, c1021_20;
const _toPropertyKey = function _toPropertyKey(a0) {
  let r2 = a0;
  if (typeof a0 === "object") {
    r2 = a0;
    if (a0) {
      const r5 = a0[Symbol.toPrimitive];
      if (r5 !== void 0) {
        r2 = r5.call(a0, "string");
        if (typeof r2 === "object") {
          throw new TypeError("@@toPrimitive must return a primitive value.");
        }
      } else {
        r2 = String(a0);
      }
    }
  }
  let r19 = r2;
  if (typeof r19 !== "symbol") {
    r19 = "" + r2;
  }
  return r19;
};
c1021_7 = new Logger("ApexExperimentStore");
const window2 = globalThis.window;
if (!(typeof window2 !== "undefined" ? window.TextEncoder != null && window.TextDecoder != null : typeof window2 === "undefined")) {
  _Module1214;
}
c1021_8 = [UnitType.User, UnitType.Installation];
evaluatedExperiments = {
  user: {},
  guild: {},
  installation: {}
};
c1021_10 = {};
clientOverrides = {};
c1021_12 = {};
c1021_13 = {};
c1021_14 = {};
c1021_15 = new Set();
c1021_16 = new Set();
c1021_17 = "apexTrackedExposures";
c1021_18 = 604800000;
c1021_19 = {};
c1021_20 = {};
class BaseApexExperimentStore extends Module589.PersistedStore {
  static displayName = "ApexExperimentStore";
  static persistKey = "ApexExperimentStore";
  track = () => Promise.resolve();
  surface = "unset";
  loadStoredState(a0, a1) {
    if (a0 != null && a0.version === 3) {
      clientOverrides = a0.clientOverrides;
      evaluatedExperiments = a0.evaluatedExperiments;
    } else if (a0 != null && a0.version === 2) {
      clientOverrides = a0.clientOverrides;
      evaluatedExperiments = {
        ...a0.evaluatedExperiments,
        installation: {}
      };
    }
    c1021_13 = {};
    for (const key in a1) {
      let hashedName = c1021_20[key];
      if (hashedName == null) {
        const r33 = MurmurHashV3.v3(key);
        c1021_20[key] = r33;
        hashedName = r33;
      }
      c1021_13[key] = {
        hashedName,
        variantId: a1[key],
        isOverride: true,
        exposureTrackingEnabled: false,
        useAsEligibility: false
      };
    }
    c1021_19 = this.loadTrackedExposures();
  }
  getState() {
    return {
      version: 3,
      evaluatedExperiments,
      clientOverrides
    };
  }
  setExperimentAssignments(a0, a1) {
    if (a0 == null && a1 == null) {
      return false;
    }
    this.clearSessionOverrides();
    if (a0 != null) {
      for (const item of c1021_8) {
        const r58 = UnitTypeToKind[item];
        const r60 = a0.assignments[item];
        if (r60 != null && r58 != null) {
          const r65 = evaluatedExperiments[r58];
          for (const key in r60) {
            c1021_16.add(key);
            const r72 = r60[key];
            let evaluation_id4 = r72.evaluation_id;
            const assignments2 = r72.assignments;
            if (evaluation_id4 == null) {
              evaluation_id4 = void 0;
            }
            const r75 = {
              evaluationId: evaluation_id4,
              assignments: {}
            };
            r65[key] = r75;
            for (const item2 of assignments2) {
              const [r88, variantId, r90, revision2, trackedVariantId, config] = item2;
              let r91 = r90;
              if (r90 == null) {
                r91 = 0;
              }
              const assignments = r75.assignments;
              const r33 = r91;
              assignments[r88] = {
                hashedName: r88,
                variantId,
                trackedVariantId,
                isOverride: !!(r33 & ExperimentFlags.IsOverride),
                revision: revision2,
                exposureTrackingEnabled: !!(r33 & ExperimentFlags.ExposureTrackingEnabled),
                useAsEligibility: !!(r33 & ExperimentFlags.UseAsEligibility),
                config
              };
            }
          }
        }
      }
    }
    if (a1 != null) {
      this.setGuildExperimentAssignments(a1);
    }
    return true;
  }
  setGuildExperimentAssignments(a0) {
    let r3 = a0;
    const guild = evaluatedExperiments.guild;
    const r2 = Object;
    if (a0 == null) {
      r3 = {};
    }
    for (const item of r2.entries(r3)) {
      const [r48, r49] = item;
      let evaluation_id4 = r49.evaluation_id;
      const assignments = r49.assignments;
      if (evaluation_id4 == null) {
        evaluation_id4 = void 0;
      }
      const r52 = {
        evaluationId: evaluation_id4,
        assignments: {}
      };
      guild[r48] = r52;
      for (const item2 of assignments) {
        const [r63, variantId, r65, revision2, trackedVariantId] = item2;
        let r66 = r65;
        if (r65 == null) {
          r66 = 0;
        }
        const r22 = r66;
        r52.assignments[r63] = {
          hashedName: r63,
          variantId,
          trackedVariantId,
          isOverride: !!(r22 & ExperimentFlags.IsOverride),
          revision: revision2,
          exposureTrackingEnabled: !!(r22 & ExperimentFlags.ExposureTrackingEnabled),
          useAsEligibility: !!(r22 & ExperimentFlags.UseAsEligibility)
        };
      }
    }
  }
  createOverride(a0, a1) {
    const r1 = {
      ...clientOverrides
    };
    let hashedName = c1021_20[a0];
    if (hashedName == null) {
      const r15 = MurmurHashV3.v3(a0);
      c1021_20[a0] = r15;
      hashedName = r15;
    }
    r1[a0] = {
      hashedName,
      variantId: a1,
      isOverride: true,
      exposureTrackingEnabled: false
    };
    clientOverrides = r1;
    this.trackExposureSuppression(a0, "client_override");
  }
  deleteOverride(a0) {
    const r4 = clientOverrides;
    r4[a0];
    clientOverrides = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
  }
  createSessionOverride(a0, a1) {
    const r1 = {
      ...c1021_12
    };
    let hashedName = c1021_20[a0];
    if (hashedName == null) {
      const r15 = MurmurHashV3.v3(a0);
      c1021_20[a0] = r15;
      hashedName = r15;
    }
    r1[a0] = {
      hashedName,
      variantId: a1,
      isOverride: true,
      exposureTrackingEnabled: false
    };
    c1021_12 = r1;
  }
  deleteSessionOverride(a0) {
    const r4 = c1021_12;
    r4[a0];
    c1021_12 = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
  }
  setExperimentsMetadata(a0) {
    c1021_14 = {
      ...c1021_14,
      ...Object.fromEntries(a0.map((item) => [item.name, item]))
    };
  }
  getExperimentsMetadata() {
    return c1021_14;
  }
  getClientOverrides() {
    return clientOverrides;
  }
  getSessionOverrides() {
    return c1021_12;
  }
  getExperimentClientOverride(a0) {
    return clientOverrides[a0];
  }
  getExperimentSessionOverride(a0) {
    return c1021_12[a0];
  }
  handleLogout(a0) {
    if (!a0) {
      this.clearUserServerAssignments();
      this.clearSessionOverrides();
    }
    Storage.remove(c1021_17);
    this.clearAllTrackedExposures();
  }
  registerExperiment(a0) {
    c1021_10[a0.name] = a0;
    if (c1021_13[a0.name] != null) {
      this.trackExposureSuppression(a0.name, "cookie_override");
    }
  }
  getRegisteredExperiments() {
    return c1021_10;
  }
  getAssignment(a0, a1, a2) {
    let r7 = this.getOverride(a2);
    if (r7 == null) {
      r7 = this.getServerAssignment(a0, a1, a2);
    }
    return r7;
  }
  getServerAssignment(a0, a1, a2) {
    let r3 = c1021_20[a2];
    if (r3 == null) {
      const r11 = MurmurHashV3.v3(a2);
      c1021_20[a2] = r11;
      r3 = r11;
    }
    const r16 = evaluatedExperiments[a0][a1];
    if (r16 != null) {
      return r16.assignments[r3];
    }
  }
  getEvaluation(a0, a1) {
    return evaluatedExperiments[a0][a1]?.evaluationId;
  }
  getEvaluationAndAssignmentInner(a0, a1, a2) {
    let r14;
    const override = this.getOverride(a2);
    if (override != null) {
      return [void 0, override];
    }
    const r12 = evaluatedExperiments[a0][a1];
    if (r12 == null) {
      r14 = [void 0, void 0];
    } else {
      r14 = [r12.evaluationId, ,];
      const assignments = r12.assignments;
      let r16 = c1021_20[a2];
      if (r16 == null) {
        const r22 = MurmurHashV3.v3(a2);
        c1021_20[a2] = r22;
        r16 = r22;
      }
      r14[1] = assignments[r16];
    }
    return r14;
  }
  getEvaluationAndAssignment(a0, a1, a2, a3) {
    const [r14, r15] = this.getEvaluationAndAssignmentInner(a0, a1, a2);
    if (a0 !== "guild") {
      return [r14, r15];
    }
    let r16 = a3;
    const getEvaluationAndAssignmentInner2 = this.getEvaluationAndAssignmentInner;
    if (a3 == null) {
      r16 = LOGGED_OUT_USER_ID_SENTINEL;
    }
    const [, r25] = getEvaluationAndAssignmentInner2.call(this, "user", r16, a2);
    return r25 == null ? [void 0, void 0] : r25.isOverride ? [r14, r25] : r25.useAsEligibility ? r15 == null ? [void 0, void 0] : r15.variantId != null ? [r14, r15] : [void 0, void 0] : [void 0, void 0];
  }
  trackExperimentExposure(evaluation_id, a1, a2, a3, a4, a5, a6) {
    const experiment = a1;
    const exposure_location = a2;
    const unit_type = a3;
    const revision = a4;
    const tracked_variation_id = a5;
    const installation_id = a6;
    const r7 = `${a1}|${a4}|${a5}|${a2}|${a6}|1`;
    let r28 = c1021_20[r7];
    if (r28 == null) {
      const r35 = MurmurHashV3.v3(r7);
      c1021_20[r7] = r35;
      r28 = r35;
    }
    if (a3 === "user") {
      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
        evaluation_id,
        experiment,
        exposure_location,
        unit_type,
        tracked_variation_id
      }, {
        flush: true
      }));
    } else if (a3 === "installation") {
      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
        evaluation_id,
        installation_id,
        experiment,
        exposure_location,
        unit_type,
        tracked_variation_id
      }, {
        flush: true
      }));
    } else if (a3 === "guild") {
      this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EVALUATION_EXPOSED, {
        evaluation_id,
        guild_id: installation_id,
        experiment,
        exposure_location,
        unit_type,
        tracked_variation_id,
        revision
      }, {
        flush: true
      }));
    }
  }
  trackCommonTriggerPointExposures(exposure_location2) {
    const _this = this;
    const _loop = function _loop(a0) {
      const evaluation_id2 = a0;
      const r11 = `${a0}|${exposure_location2}`;
      let r13 = c1021_20[r11];
      if (r13 == null) {
        const r20 = MurmurHashV3.v3(r11);
        c1021_20[r11] = r20;
        r13 = r20;
      }
      _this.withExposureTracking(r13, () => _this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
        evaluation_id: evaluation_id2,
        exposure_location: exposure_location2,
        unit_type: "user"
      }, {
        flush: true
      }));
    };
    for (const item of this.evaluationsWithUnitIds("user")) {
      _loop(item.evaluationId);
    }
    const _loop2 = function _loop2(a0, installation_id2) {
      const evaluation_id3 = a0;
      const r12 = `${a0}|${exposure_location2}`;
      let r14 = c1021_20[r12];
      if (r14 == null) {
        const r21 = MurmurHashV3.v3(r12);
        c1021_20[r12] = r21;
        r14 = r21;
      }
      _this.withExposureTracking(r14, () => _this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
        evaluation_id: evaluation_id3,
        exposure_location: exposure_location2,
        unit_type: "installation",
        installation_id: installation_id2
      }, {
        flush: true
      }));
    };
    for (const item2 of this.evaluationsWithUnitIds("installation")) {
      _loop2(item2.evaluationId, item2.unitId);
    }
  }
  withExposureTracking(a0, a1) {
    if (this.shouldTrackExposure(a0)) {
      a1();
      c1021_19[a0] = Date.now();
      this.saveTrackedExposures(c1021_19);
    }
  }
  trackExposureSuppression(a0, a1) {
    const r6 = c1021_10[a0];
    if (r6 != null) {
      if (r6.kind === "user") {
        this.track(WebAnalyticsEvents.EXPERIMENT_USER_EXPOSURE_SUPPRESSED, {
          experiment: a0,
          unit_type: r6.kind,
          suppression_source: a1
        }, {
          flush: true
        });
      } else if (r6.kind === "installation") {
        const installation_id3 = Object.keys(evaluatedExperiments.installation)[0];
        if (installation_id3 != null) {
          this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EXPOSURE_SUPPRESSED, {
            experiment: a0,
            unit_type: r6.kind,
            suppression_source: a1,
            installation_id: installation_id3
          }, {
            flush: true
          });
        }
      } else if (r6.kind === "guild") {
        const guild_id = Object.keys(evaluatedExperiments.guild)[0];
        if (guild_id != null) {
          this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EXPOSURE_SUPPRESSED, {
            experiment: a0,
            unit_type: r6.kind,
            suppression_source: a1,
            guild_id
          }, {
            flush: true
          });
        }
      }
    }
  }
  evaluationIds(a0) {
    return Object.values(evaluatedExperiments[a0]).map((item) => item.evaluationId).filter((item) => item != null);
  }
  evaluationsWithUnitIds(a0) {
    return Object.entries(evaluatedExperiments[a0]).filter((item) => {
      const [, r13] = item;
      return r13.evaluationId != null;
    }).map((item) => {
      const [unitId, r14] = item;
      return {
        evaluationId: r14.evaluationId,
        unitId
      };
    });
  }
  shouldTrackExposure(a0) {
    const r6 = c1021_19[a0];
    return r6 == null || Date.now() - r6 > c1021_18;
  }
  loadTrackedExposures() {
    let r3;
    const r19 = Storage.get(c1021_17);
    if (r19 != null && r19.version === 2) {
      const exposures = r19.exposures;
      const r11 = Date.now();
      let r2 = false;
      let r27 = false;
      for (const key in exposures) {
        r3 = r2;
        r27 = r3;
        const r30 = r11 - exposures[key];
        r2 = r3;
        if (r30 > c1021_18) {
          delete exposures[key];
          r2 = true;
        }
      }
      r3 = r2;
      r27 = r3;
      if (r27) {
        this.saveTrackedExposures(exposures);
      }
      return exposures;
    }
    return {};
  }
  saveTrackedExposures(a0) {
    try {
      Storage.set(c1021_17, {
        version: 2,
        exposures: a0
      });
    } catch ($e) {
      c1021_7.error("Error saving tracked exposures", $e);
      this.track(WebAnalyticsEvents.EXPERIMENT_SAVE_EXPOSURE_FAILED, {
        module: this.surface,
        call: "ApexExperimentStore.saveTrackedExposures"
      }, {
        flush: true
      });
    }
  }
  clearForTests() {
    this.clearAllServerAssignments();
    this.clearAllOverrides();
    this.clearAllTrackedExposures();
    c1021_15.clear();
    c1021_16.clear();
  }
  clearAllServerAssignments() {
    evaluatedExperiments = {
      user: {},
      guild: {},
      installation: {}
    };
  }
  clearUserServerAssignments() {
    evaluatedExperiments = {
      user: {},
      guild: {},
      installation: evaluatedExperiments.installation
    };
  }
  clearAllOverrides() {
    clientOverrides = {};
    c1021_12 = {};
    c1021_13 = {};
  }
  clearSessionOverrides() {
    c1021_12 = {};
  }
  clearAllTrackedExposures() {
    c1021_19 = {};
  }
  getHash(a0) {
    let r1 = c1021_20[a0];
    if (r1 == null) {
      const r11 = MurmurHashV3.v3(a0);
      c1021_20[a0] = r11;
      r1 = r11;
    }
    return r1;
  }
  handleFetchStart(a0) {
    c1021_15.add(a0);
  }
  handleFetchSuccess(a0, a1) {
    c1021_15.delete(a0);
    c1021_16.add(a0);
    this.setExperimentAssignments(a1);
  }
  handleFetchFailure(a0) {
    c1021_15.delete(a0);
    c1021_16.add(a0);
  }
  isFetching(a0) {
    return c1021_15.has(a0);
  }
  hasLoaded(a0) {
    return c1021_16.has(a0);
  }
  getOverride(a0) {
    let r5 = c1021_12[a0];
    if (r5 == null) {
      r5 = clientOverrides[a0];
    }
    if (r5 == null) {
      r5 = c1021_13[a0];
    }
    return r5;
  }
}
export default BaseApexExperimentStore;