const stashListener = new EventTarget();

const { fetch: originalFetch } = window;

const baseURL = document.querySelector("base")?.getAttribute("href") ?? "/";

window.fetch = async (...args) => {
  let [resource, config] = args;
  // request interceptor here
  const response = await originalFetch(resource, config);
  // response interceptor here
  const contentType = response.headers.get("content-type");
  if (
    contentType &&
    contentType.indexOf("application/json") !== -1 &&
    resource.endsWith("/graphql")
  ) {
    try {
      const data = await response.clone().json();
      stashListener.dispatchEvent(
        new CustomEvent("response", {
          detail: data,
        })
      );
    } catch (e) {}
  }
  return response;
};

class Logger {
  constructor(enabled) {
    this.enabled = enabled;
  }
  debug() {
    if (!this.enabled) return;
    console.debug(...arguments);
  }
}

class Stash extends EventTarget {
  constructor({
    pageUrlCheckInterval = 100,
    detectReRenders = true,
    logging = false,
  } = {}) {
    super();
    this.log = new Logger(logging);
    this._pageUrlCheckInterval = pageUrlCheckInterval;
    this._detectReRenders = detectReRenders;
    this._lastPathStr = "";
    this._lastQueryStr = "";
    this._lastHref = "";
    this._lastStashPageEvent = "";
    this.waitForElement(this._detectReRenders ? ".main > div" : "html").then(
      () => {
        this._pageURLCheckTimerId = setInterval(() => {
          // Loop every 100 ms
          if (
            this._lastPathStr !== location.pathname ||
            this._lastHref !== location.href ||
            this._lastQueryStr !== location.search ||
            (!document.querySelector(".main > div[stashUserscriptLibrary]") &&
              this._detectReRenders)
          ) {
            this._dispatchPageEvent("stash:page", false);

            this._handlePageChange({
              lastPathStr: this._lastPathStr,
              lastQueryStr: this._lastQueryStr,
              lastHref: this._lastHref,
              lastStashPageEvent: this._lastStashPageEvent,
            });

            this._lastPathStr = location.pathname;
            this._lastQueryStr = location.search;
            this._lastHref = location.href;

            if (this._detectReRenders) {
              this.waitForElement(".main > div", 10000).then((element) => {
                if (element) element.setAttribute("stashUserscriptLibrary", "");
              });
            }
          }
        }, this._pageUrlCheckInterval);
      }
    );
    stashListener.addEventListener("response", (evt) => {
      if (evt.detail.data?.plugins) {
        this.getPluginVersion(evt.detail);
      }
      this.processRemoteScenes(evt.detail);
      this.processScene(evt.detail);
      this.processScenes(evt.detail);
      this.processStudios(evt.detail);
      this.processPerformers(evt.detail);
      this.processApiKey(evt.detail);
      this.dispatchEvent(
        new CustomEvent("stash:response", {
          detail: evt.detail,
        })
      );
    });
    stashListener.addEventListener("pluginVersion", (evt) => {
      if (this.pluginVersion !== evt.detail) {
        this.pluginVersion = evt.detail;
        this.dispatchEvent(
          new CustomEvent("stash:pluginVersion", {
            detail: evt.detail,
          })
        );
      }
    });
    this.version = [0, 0, 0];
    this.getVersion();
    this.pluginVersion = null;
    this.getPlugins().then((plugins) => this.getPluginVersion(plugins));
    this.visiblePluginTasks = ["Userscript Functions"];
    this.settingsCallbacks = [];
    this.settingsId = "userscript-settings";
    this.remoteScenes = {};
    this.scenes = {};
    this.studios = {};
    this.performers = {};
    this.userscripts = [];
    this._pageListeners = {};
    this._initDefaultPageListeners();
  }
  async getVersion() {
    const reqData = {
      operationName: "",
      variables: {},
      query: `query version {
                version {
                    version
                }
            }`,
    };
    const data = await this.callGQL(reqData);
    const versionString = data.data.version.version;
    this.version = versionString
      .substring(1)
      .split(".")
      .map((o) => parseInt(o));
  }
  compareVersion(minVersion) {
    let [currMajor, currMinor, currPatch = 0] = this.version;
    let [minMajor, minMinor, minPatch = 0] = minVersion
      .split(".")
      .map((i) => parseInt(i));
    if (currMajor > minMajor) return 1;
    if (currMajor < minMajor) return -1;
    if (currMinor > minMinor) return 1;
    if (currMinor < minMinor) return -1;
    return 0;
  }
  comparePluginVersion(minPluginVersion) {
    if (!this.pluginVersion) return -1;
    let [currMajor, currMinor, currPatch = 0] = this.pluginVersion
      .split(".")
      .map((i) => parseInt(i));
    let [minMajor, minMinor, minPatch = 0] = minPluginVersion
      .split(".")
      .map((i) => parseInt(i));
    if (currMajor > minMajor) return 1;
    if (currMajor < minMajor) return -1;
    if (currMinor > minMinor) return 1;
    if (currMinor < minMinor) return -1;
    return 0;
  }
  async runPluginTask(pluginId, taskName, args = []) {
    const reqData = {
      operationName: "RunPluginTask",
      variables: {
        plugin_id: pluginId,
        task_name: taskName,
        args: args,
      },
      query:
        "mutation RunPluginTask($plugin_id: ID!, $task_name: String!, $args: [PluginArgInput!]) {\n  runPluginTask(plugin_id: $plugin_id, task_name: $task_name, args: $args)\n}\n",
    };
    return this.callGQL(reqData);
  }
  async callGQL(reqData) {
    const options = {
      method: "POST",
      body: JSON.stringify(reqData),
      headers: {
        "Content-Type": "application/json",
      },
    };

    try {
      const res = await window.fetch(baseURL + "graphql", options);
      this.log.debug(res);
      return res.json();
    } catch (err) {
      console.error(err);
    }
  }
  async getFreeOnesStats(link) {
    try {
      const doc = await fetch(link)
        .then(function (response) {
          // When the page is loaded convert it to text
          return response.text();
        })
        .then(function (html) {
          // Initialize the DOM parser
          var parser = new DOMParser();

          // Parse the text
          var doc = parser.parseFromString(html, "text/html");

          // You can now even select part of that html as you would in the regular DOM
          // Example:
          // var docArticle = doc.querySelector('article').innerHTML;

          console.log(doc);
          return doc;
        })
        .catch(function (err) {
          console.log("Failed to fetch page: ", err);
        });

      var data = new Object();
      data.rank = doc.querySelector("rank-chart-button");
      console.log(data.rank);
      data.views = doc.querySelector(
        ".d-none.d-m-flex.flex-column.align-items-center.global-header > div.font-weight-bold"
      ).textContent;
      data.votes = "0";
      return JSON.stringify(data);
    } catch (err) {
      console.error(err);
    }
  }
  async getPlugins() {
    const reqData = {
      operationName: "Plugins",
      variables: {},
      query: `query Plugins {
              plugins {
                id
                name
                description
                url
                version
                tasks {
                  name
                  description
                  __typename
                }
                hooks {
                  name
                  description
                  hooks
                }
              }
            }
            `,
    };
    return this.callGQL(reqData);
  }
  async getPluginVersion(plugins) {
    let version = null;
    for (const plugin of plugins?.data?.plugins || []) {
      if (plugin.id === "userscript_functions") {
        version = plugin.version;
      }
    }
    stashListener.dispatchEvent(
      new CustomEvent("pluginVersion", {
        detail: version,
      })
    );
  }
  async getStashBoxes() {
    const reqData = {
      operationName: "Configuration",
      variables: {},
      query: `query Configuration {
                        configuration {
                          general {
                            stashBoxes {
                              endpoint
                              api_key
                              name
                            }
                          }
                        }
                      }`,
    };
    return this.callGQL(reqData);
  }
  async getApiKey() {
    const reqData = {
      operationName: "Configuration",
      variables: {},
      query: `query Configuration {
                        configuration {
                          general {
                            apiKey
                          }
                        }
                      }`,
    };
    return this.callGQL(reqData);
  }
  matchUrl(href, fragment) {
    const regexp = concatRegexp(
      new RegExp(window.location.origin + baseURL),
      fragment
    );
    return href.match(regexp) != null;
  }
  createSettings() {
    waitForElementId(
      "configuration-tabs-tabpane-system",
      async (elementId, el) => {
        let section;
        if (!document.getElementById(this.settingsId)) {
          section = document.createElement("div");
          section.setAttribute("id", this.settingsId);
          section.classList.add("setting-section");
          section.innerHTML = `<h1>Userscript Settings</h1>`;
          el.appendChild(section);

          const expectedApiKey =
            (await this.getApiKey())?.data?.configuration?.general?.apiKey ||
            "";
          const expectedUrl = window.location.origin;

          const serverUrlInput = await this.createSystemSettingTextbox(
            section,
            "userscript-section-server-url",
            "userscript-server-url",
            "Stash Server URL",
            "",
            "Server URL…",
            true
          );
          serverUrlInput.addEventListener("change", () => {
            const value = serverUrlInput.value || "";
            if (value) {
              this.updateConfigValueTask("STASH", "url", value);
              alert(`Userscripts plugin server URL set to ${value}`);
            } else {
              this.getConfigValueTask("STASH", "url").then((value) => {
                serverUrlInput.value = value;
              });
            }
          });
          serverUrlInput.disabled = true;
          serverUrlInput.value = expectedUrl;
          this.getConfigValueTask("STASH", "url").then((value) => {
            if (value !== expectedUrl) {
              return this.updateConfigValueTask("STASH", "url", expectedUrl);
            }
          });

          const apiKeyInput = await this.createSystemSettingTextbox(
            section,
            "userscript-section-server-apikey",
            "userscript-server-apikey",
            "Stash API Key",
            "",
            "API Key…",
            true
          );
          apiKeyInput.addEventListener("change", () => {
            const value = apiKeyInput.value || "";
            this.updateConfigValueTask("STASH", "api_key", value);
            if (value) {
              alert(`Userscripts plugin server api key set to ${value}`);
            } else {
              alert(`Userscripts plugin server api key value cleared`);
            }
          });
          apiKeyInput.disabled = true;
          apiKeyInput.value = expectedApiKey;
          this.getConfigValueTask("STASH", "api_key").then((value) => {
            if (value !== expectedApiKey) {
              return this.updateConfigValueTask(
                "STASH",
                "api_key",
                expectedApiKey
              );
            }
          });
        } else {
          section = document.getElementById(this.settingsId);
        }

        for (const callback of this.settingsCallbacks) {
          callback(this.settingsId, section);
        }

        if (this.pluginVersion) {
          this.dispatchEvent(
            new CustomEvent("stash:pluginVersion", {
              detail: this.pluginVersion,
            })
          );
        }
      }
    );
  }
  addSystemSetting(callback) {
    const section = document.getElementById(this.settingsId);
    if (section) {
      callback(this.settingsId, section);
    }
    this.settingsCallbacks.push(callback);
  }
  async createSystemSettingCheckbox(
    containerEl,
    settingsId,
    inputId,
    settingsHeader,
    settingsSubheader
  ) {
    const section = document.createElement("div");
    section.setAttribute("id", settingsId);
    section.classList.add("card");
    section.style.display = "none";
    section.innerHTML = `<div class="setting">
        <div>
        <h3>${settingsHeader}</h3>
        <div class="sub-heading">${settingsSubheader}</div>
        </div>
        <div>
        <div class="custom-control custom-switch">
        <input type="checkbox" id="${inputId}" class="custom-control-input">
        <label title="" for="${inputId}" class="custom-control-label"></label>
        </div>
        </div>
        </div>`;
    containerEl.appendChild(section);
    return document.getElementById(inputId);
  }
  async createSystemSettingTextbox(
    containerEl,
    settingsId,
    inputId,
    settingsHeader,
    settingsSubheader,
    placeholder,
    visible
  ) {
    const section = document.createElement("div");
    section.setAttribute("id", settingsId);
    section.classList.add("card");
    section.style.display = visible ? "flex" : "none";
    section.innerHTML = `<div class="setting">
        <div>
        <h3>${settingsHeader}</h3>
        <div class="sub-heading">${settingsSubheader}</div>
        </div>
        <div>
        <div class="flex-grow-1 query-text-field-group">
        <input id="${inputId}" class="bg-secondary text-white border-secondary form-control" placeholder="${placeholder}">
        </div>
        </div>
        </div>`;
    containerEl.appendChild(section);
    return document.getElementById(inputId);
  }
  get serverUrl() {
    return window.location.origin + baseURL;
  }
  async waitForElement(
    selector,
    timeout = null,
    location = document.body,
    disconnectOnPageChange = false
  ) {
    return new Promise((resolve) => {
      if (document.querySelector(selector)) {
        return resolve(document.querySelector(selector));
      }

      const observer = new MutationObserver(async () => {
        if (document.querySelector(selector)) {
          resolve(document.querySelector(selector));
          observer.disconnect();
        } else {
          if (timeout) {
            async function timeOver() {
              return new Promise((resolve) => {
                setTimeout(() => {
                  observer.disconnect();
                  resolve(false);
                }, timeout);
              });
            }
            resolve(await timeOver());
          }
        }
      });

      observer.observe(location, {
        childList: true,
        subtree: true,
      });

      if (disconnectOnPageChange) {
        const stash = this;
        function disconnect() {
          resolve(false);
          observer.disconnect();
          stash.removeEventListener("stash:page", disconnect);
        }
        stash.addEventListener("stash:page", disconnect);
      }
    });
  }
  async waitForElementDeath(
    selector,
    location = document.body,
    disconnectOnPageChange = false
  ) {
    return new Promise((resolve) => {
      const observer = new MutationObserver(async () => {
        if (!document.querySelector(selector)) {
          resolve(true);
          observer.disconnect();
        }
      });

      observer.observe(location, {
        childList: true,
        subtree: true,
      });

      if (disconnectOnPageChange) {
        const stash = this;
        function disconnect() {
          resolve(false);
          observer.disconnect();
          stash.removeEventListener("stash:page", disconnect);
        }
        stash.addEventListener("stash:page", disconnect);
      }
    });
  }
  async _listenForNonPageChanges({
    selector = "",
    location = document.body,
    listenType = "",
    event = "",
    recursive = false,
    reRunHandlePageChange = false,
    listenDefaultTab = true,
    callback = () => {},
  } = {}) {
    if (recursive) return;

    if (listenType === "tabs") {
      const tabsContainer = await this.waitForElement(
        selector,
        10000,
        location,
        true
      );
      const stash = this;
      let previousEvent = "";

      function listenForTabClicks(domEvent) {
        const clickedChild = domEvent.target ? domEvent.target : domEvent;

        if (!clickedChild.classList?.contains("nav-link")) return;

        const tagName = clickedChild.getAttribute("data-rb-event-key");
        const parentEvent = tagName.split("-")[0];
        const childEvent = tagName.split("-").slice(1, -1).join("-");

        event = `stash:page:${parentEvent}:${childEvent}`;

        if (previousEvent === event) return;
        previousEvent = event;

        stash._dispatchPageEvent(`stash:page:any:${childEvent}`, false);
        stash._dispatchPageEvent(event);
      }

      if (listenDefaultTab)
        listenForTabClicks(tabsContainer.querySelector(".nav-link.active"));

      tabsContainer.addEventListener("click", listenForTabClicks);

      function removeEventListenerOnPageChange() {
        tabsContainer.removeEventListener("click", listenForTabClicks);
        stash.removeEventListener(
          "stash:page",
          removeEventListenerOnPageChange
        );
      }
      stash.addEventListener("stash:page", removeEventListenerOnPageChange);
    } else if (await this.waitForElement(selector, null, location, true)) {
      this._dispatchPageEvent(event);

      if (await this.waitForElementDeath(selector, location, true)) {
        if (
          this._lastPathStr === window.location.pathname &&
          reRunHandlePageChange
        ) {
          // triggered after home, performer, studio, tag's edit page close
          this._handlePageChange({
            recursive: true,
            lastPathStr: this._lastPathStr,
            lastQueryStr: this._lastQueryStr,
            lastHref: this._lastHref,
            lastStashPageEvent: this._lastStashPageEvent,
          });
        }
      }
    }

    callback();
  }
  _dispatchPageEvent(event, addToHistory = true) {
    this.dispatchEvent(
      new CustomEvent(event, {
        detail: {
          event: event,
          lastEventState: {
            lastPathStr: this._lastPathStr,
            lastQueryStr: this._lastQueryStr,
            lastHref: this._lastHref,
            lastStashPageEvent: this._lastStashPageEvent,
          },
        },
      })
    );

    if (addToHistory) {
      this.log.debug(`[Navigation] ${event}`);
      if (event.startsWith("stash:")) {
        this._lastStashPageEvent = event;
      }
    }

    // if (event!=="stash:page" && !addToHistory) this.log.debug(`[Navigation] ${event}`); // log ":any:" events
  }
  addPageListener(eventData) {
    const {
      event,
      regex,
      callback = () => {},
      manuallyHandleDispatchEvent = false,
    } = eventData;
    if (
      event &&
      !event?.startsWith("stash:") &&
      regex &&
      this._pageListeners[event] === undefined
    ) {
      this._pageListeners[event] = {
        regex: regex,
        callback: callback,
        manuallyHandleDispatchEvent: manuallyHandleDispatchEvent,
      };

      return event;
    } else {
      if (this._pageListeners[event] !== undefined) {
        console.error(`Can't add page listener: Event ${event} already exists`);
      } else if (event?.startsWith("stash:")) {
        console.error(
          `Can't add page listener: Event name can't start with "stash:"`
        );
      } else {
        console.error(
          `Can't add page listener: Missing required argument(s) "event", "regex"`
        );
      }

      return false;
    }
  }
  removePageListener(event) {
    if (event && !event?.startsWith("stash:") && this._pageListeners[event]) {
      delete this._pageListeners[event];
      return event;
    } else {
      if (this._pageListeners[event] === undefined && event) {
        console.error(
          `Can't remove page listener: Event ${event} doesn't exists`
        );
      } else if (event?.startsWith("stash:")) {
        console.error(
          `Can't remove page listener: Event ${event} is a built in event`
        );
      } else {
        console.error(`Can't remove page listener: Missing "event" argument`);
      }

      return false;
    }
  }
  stopPageListener() {
    clearInterval(this._pageURLCheckTimerId);
  }
  _initDefaultPageListeners() {
    this._pageListeners = {
      // scenes tab
      "stash:page:scenes": {
        regex: /scenes\?/,
        manuallyHandleDispatchEvent: true,
        handleDisplayView: "ignoreDisplayViewCondition",
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
            this.processTagger();
          }
        },
      },
      "stash:page:scene:new": {
        regex: /scenes\/new/,
      },
      "stash:page:scene": {
        regex: /scenes\/\d+\?/,
        callback: ({ recursive = false }) =>
          this._listenForNonPageChanges({
            selector: ".scene-tabs .nav-tabs",
            listenType: "tabs",
            recursive: recursive,
          }),
      },

      // images tab
      "stash:page:images": {
        regex: /images\?/,
        handleDisplayView: true,
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:image": {
        regex: /images\/\d+/,
        callback: ({ recursive = false }) =>
          this._listenForNonPageChanges({
            selector: ".image-tabs .nav-tabs",
            listenType: "tabs",
            recursive: recursive,
          }),
      },

      // movies tab
      "stash:page:movies": {
        regex: /movies\?/,
      },
      "stash:page:movie": {
        regex: /movies\/\d+/,
      },
      "stash:page:movie:scenes": {
        regex: /movies\/\d+\?/,
        callback: () => this.processTagger(),
      },

      // markers tab
      "stash:page:markers": {
        regex: /scenes\/markers/,
      },

      // galleries tab
      "stash:page:galleries": {
        regex: /galleries\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:gallery:new": {
        regex: /galleries\/new/,
      },
      "stash:page:gallery:images": {
        regex: /galleries\/\d+\?/,
        manuallyHandleDispatchEvent: true,
        handleDisplayView: "ignoreDisplayViewCondition",
        callback: ({ lastHref, lastPathStr, recursive = false, event }) => {
          if (
            !this.matchUrl(lastHref, /\/galleries\/\d+\//) &&
            lastPathStr !== window.location.pathname
          ) {
            this._dispatchPageEvent("stash:page:gallery");
            this._listenForNonPageChanges({
              selector: ".gallery-tabs .nav-tabs .nav-link.active",
              event: "stash:page:gallery:details",
              recursive: recursive,
            });
          }

          this._dispatchPageEvent(event);

          this._listenForNonPageChanges({
            selector: ".gallery-tabs .nav-tabs",
            listenType: "tabs",
            recursive: recursive,
            listenDefaultTab: false,
          });
        },
      },
      "stash:page:gallery:add": {
        regex: /galleries\/\d+\/add/,
        manuallyHandleDispatchEvent: true,
        handleDisplayView: "ignoreDisplayViewCondition",
        callback: ({ lastHref, lastPathStr, recursive = false, event }) => {
          if (
            !this.matchUrl(lastHref, /\/galleries\/\d+/) &&
            lastPathStr !== window.location.pathname
          ) {
            this._dispatchPageEvent("stash:page:gallery");
            this._listenForNonPageChanges({
              selector: ".gallery-tabs .nav-tabs .nav-link.active",
              event: "stash:page:gallery:details",
              recursive: recursive,
            });
          }

          this._dispatchPageEvent(event);

          this._listenForNonPageChanges({
            selector: ".gallery-tabs .nav-tabs",
            listenType: "tabs",
            recursive: recursive,
            listenDefaultTab: false,
          });
        },
      },

      // performers tab
      "stash:page:performers": {
        regex: /performers\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex) || this._detectReRenders) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:performer:new": {
        regex: /performers\/new/,
      },
      "stash:page:performer": {
        regex: /performers\/\d+/,
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
            this.processTagger();
          }

          this._listenForNonPageChanges({
            selector: "#performer-edit",
            event: "stash:page:performer:edit",
            reRunHandlePageChange: true,
            callback: () =>
              this._detectReRenders ? this._dispatchPageEvent(event) : null,
          });
        },
      },
      "stash:page:performer:scenes": {
        regex: /performers\/\d+\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:performer:galleries": {
        regex: /performers\/\d+\/galleries/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:performer:images": {
        regex: /performers\/\d+\/images/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:performer:movies": {
        regex: /performers\/\d+\/movies/,
      },
      "stash:page:performer:appearswith": {
        regex: /performers\/\d+\/appearswith/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
            this.processTagger();
          }
        },
      },

      // studios tab
      "stash:page:studios": {
        regex: /studios\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:studio:new": {
        regex: /studios\/new/,
      },
      "stash:page:studio": {
        regex: /studios\/\d+/,
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
            this.processTagger();
          }

          this._listenForNonPageChanges({
            selector: "#studio-edit",
            event: "stash:page:studio:edit",
            reRunHandlePageChange: true,
            callback: () =>
              this._detectReRenders ? this._dispatchPageEvent(event) : null,
          });
        },
      },
      "stash:page:studio:scenes": {
        regex: /studios\/\d+\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:studio:galleries": {
        regex: /studios\/\d+\/galleries/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:studio:images": {
        regex: /studios\/\d+\/images/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:studio:performers": {
        regex: /studios\/\d+\/performers/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:studio:movies": {
        regex: /studios\/\d+\/movies/,
      },
      "stash:page:studio:childstudios": {
        regex: /studios\/\d+\/childstudios/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },

      // tags tab
      "stash:page:tags": {
        regex: /tags\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:tag:new": {
        regex: /tags\/new/,
      },
      "stash:page:tag": {
        regex: /tags\/\d+/,
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
            this.processTagger();
          }

          this._listenForNonPageChanges({
            selector: "#tag-edit",
            event: "stash:page:tag:edit",
            reRunHandlePageChange: true,
            callback: () =>
              this._detectReRenders ? this._dispatchPageEvent(event) : null,
          });
        },
      },
      "stash:page:tag:scenes": {
        regex: /tags\/\d+\?/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:tag:galleries": {
        regex: /tags\/\d+\/galleries/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:tag:images": {
        regex: /tags\/\d+\/images/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:tag:markers": {
        regex: /tags\/\d+\/markers/,
      },
      "stash:page:tag:performers": {
        regex: /tags\/\d+\/performers/,
        handleDisplayView: "ignoreDisplayViewCondition",
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },

      // settings page
      "stash:page:settings": {
        regex: /settings/,
        manuallyHandleDispatchEvent: true,
        callback: ({ lastHref, event, regex }) => {
          if (!this.matchUrl(lastHref, regex)) {
            this._dispatchPageEvent(event);
          }
        },
      },
      "stash:page:settings:tasks": {
        regex: /settings\?tab=tasks/,
        callback: () => this.hidePluginTasks(),
      },
      "stash:page:settings:library": {
        regex: /settings\?tab=library/,
      },
      "stash:page:settings:interface": {
        regex: /settings\?tab=interface/,
      },
      "stash:page:settings:security": {
        regex: /settings\?tab=security/,
      },
      "stash:page:settings:metadata-providers": {
        regex: /settings\?tab=metadata-providers/,
      },
      "stash:page:settings:services": {
        regex: /settings\?tab=services/,
      },
      "stash:page:settings:system": {
        regex: /settings\?tab=system/,
        callback: () => this.createSettings(),
      },
      "stash:page:settings:plugins": {
        regex: /settings\?tab=plugins/,
      },
      "stash:page:settings:logs": {
        regex: /settings\?tab=logs/,
      },
      "stash:page:settings:tools": {
        regex: /settings\?tab=tools/,
      },
      "stash:page:settings:changelog": {
        regex: /settings\?tab=changelog/,
      },
      "stash:page:settings:about": {
        regex: /settings\?tab=about/,
      },

      // stats page
      "stash:page:stats": {
        regex: /stats/,
      },

      // home page
      "stash:page:home": {
        regex: /$/,
        callback: () =>
          this._listenForNonPageChanges({
            selector: ".recommendations-container-edit",
            event: "stash:page:home:edit",
            reRunHandlePageChange: true,
          }),
      },
    };
  }
  _handlePageChange(args) {
    const events = Object.keys(this._pageListeners);

    for (const event of events) {
      const {
        regex,
        callback = () => {},
        manuallyHandleDispatchEvent = false,
        handleDisplayView = false,
      } = this._pageListeners[event];

      let isDisplayViewPage = false;
      let isGridPage, isListPage, isWallPage, isTaggerPage;

      const splitEvent = event.split(":");
      const tabPage = { page: "", tab: "" };
      let childAnyEventCondition = false;

      if (splitEvent.length === 4) {
        childAnyEventCondition = true;
        tabPage.page = splitEvent[2];
        tabPage.tab = splitEvent[3];
      }

      splitEvent.pop();

      if (handleDisplayView) {
        isGridPage = this.matchUrl(
          window.location.href,
          concatRegexp(regex, /(?!.*disp=)/)
        );
        isListPage = this.matchUrl(
          window.location.href,
          concatRegexp(regex, /.*disp=1/)
        );
        isWallPage = this.matchUrl(
          window.location.href,
          concatRegexp(regex, /.*disp=2/)
        );
        isTaggerPage = this.matchUrl(
          window.location.href,
          concatRegexp(regex, /.*disp=3/)
        );

        if (isListPage || isWallPage || isTaggerPage) isDisplayViewPage = true;
      }

      function dispatchViewEvent(view, stash) {
        stash._dispatchPageEvent(event + `:${view}`);
        if (childAnyEventCondition) {
          stash._dispatchPageEvent(
            "stash:page:" + tabPage.page + `:any:${view}`,
            false
          );
          stash._dispatchPageEvent(
            "stash:page:any:" + tabPage.tab + `:${view}`,
            false
          );
        } else {
          stash._dispatchPageEvent(`stash:page:any:${view}`, false);
        }
      }

      const handleDisplayViewCondition =
        handleDisplayView !== true ||
        (handleDisplayView && (!isDisplayViewPage || args.lastHref === ""));

      if (
        this.matchUrl(window.location.href, regex) &&
        handleDisplayViewCondition
      ) {
        if (!manuallyHandleDispatchEvent) this._dispatchPageEvent(event);
        callback({
          ...args,
          location: window.location,
          event: event,
          regex: regex,
        });

        if (isGridPage) dispatchViewEvent("grid", this);
      }

      if (handleDisplayView) {
        let view = "";
        switch (true) {
          case isListPage:
            view = "list";
            break;
          case isWallPage:
            view = "wall";
            break;
          case isTaggerPage:
            view = "tagger";
            break;
        }
        if (view) dispatchViewEvent(view, this);
      }
    }
  }
  addEventListeners(events, callback, ...options) {
    events.forEach((event) => {
      this.addEventListener(event, callback, ...options);
    });
  }
  hidePluginTasks() {
    // hide userscript functions plugin tasks
    waitForElementByXpath(
      "//div[@id='tasks-panel']//h3[text()='Userscript Functions']/ancestor::div[contains(@class, 'setting-group')]",
      (elementId, el) => {
        const tasks = el.querySelectorAll(".setting");
        for (const task of tasks) {
          const taskName = task.querySelector("h3").innerText;
          task.classList.add(
            this.visiblePluginTasks.indexOf(taskName) === -1
              ? "d-none"
              : "d-flex"
          );
          this.dispatchEvent(
            new CustomEvent("stash:plugin:task", {
              detail: {
                taskName,
                task,
              },
            })
          );
        }
      }
    );
  }
  async updateConfigValueTask(sectionKey, propName, value) {
    return this.runPluginTask("userscript_functions", "Update Config Value", [
      {
        key: "section_key",
        value: {
          str: sectionKey,
        },
      },
      {
        key: "prop_name",
        value: {
          str: propName,
        },
      },
      {
        key: "value",
        value: {
          str: value,
        },
      },
    ]);
  }
  async getConfigValueTask(sectionKey, propName) {
    await this.runPluginTask("userscript_functions", "Get Config Value", [
      {
        key: "section_key",
        value: {
          str: sectionKey,
        },
      },
      {
        key: "prop_name",
        value: {
          str: propName,
        },
      },
    ]);

    // poll logs until plugin task output appears
    const prefix = `[Plugin / Userscript Functions] get_config_value: [${sectionKey}][${propName}] =`;
    return this.pollLogsForMessage(prefix);
  }
  async pollLogsForMessage(prefix) {
    const reqTime = Date.now();
    const reqData = {
      variables: {},
      query: `query Logs {
                        logs {
                            time
                            level
                            message
                        }
                    }`,
    };
    await new Promise((r) => setTimeout(r, 500));
    let retries = 0;
    while (true) {
      const delay = 2 ** retries * 100;
      await new Promise((r) => setTimeout(r, delay));
      retries++;

      const logs = await this.callGQL(reqData);
      for (const log of logs.data.logs) {
        const logTime = Date.parse(log.time);
        if (logTime > reqTime && log.message.startsWith(prefix)) {
          return log.message.replace(prefix, "").trim();
        }
      }

      if (retries >= 5) {
        throw `Poll logs failed for message: ${prefix}`;
      }
    }
  }
  processTagger() {
    waitForElementByXpath("//button[text()='Scrape All']", (xpath, el) => {
      this.dispatchEvent(
        new CustomEvent("tagger", {
          detail: el,
        })
      );

      const searchItemContainer =
        document.querySelector(".tagger-container").lastChild;

      const observer = new MutationObserver((mutations) => {
        mutations.forEach((mutation) => {
          mutation.addedNodes.forEach((node) => {
            if (
              node?.classList?.contains("entity-name") &&
              node.innerText.startsWith("Performer:")
            ) {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:remoteperformer", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (
              node?.classList?.contains("entity-name") &&
              node.innerText.startsWith("Studio:")
            ) {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:remotestudio", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (
              node.tagName === "SPAN" &&
              node.innerText.startsWith("Matched:")
            ) {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:local", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (node.tagName === "UL") {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:container", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (node?.classList?.contains("col-lg-6")) {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:subcontainer", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (node.tagName === "H5") {
              // scene date
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:date", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else if (
              node.tagName === "DIV" &&
              node?.classList?.contains("d-flex") &&
              node?.classList?.contains("flex-column")
            ) {
              // scene stashid, url, details
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:detailscontainer", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            } else {
              this.dispatchEvent(
                new CustomEvent("tagger:mutation:add:other", {
                  detail: {
                    node,
                    mutation,
                  },
                })
              );
            }
          });
        });
        this.dispatchEvent(
          new CustomEvent("tagger:mutations:searchitems", {
            detail: mutations,
          })
        );
      });
      observer.observe(searchItemContainer, {
        childList: true,
        subtree: true,
      });

      const taggerContainerHeader = document.querySelector(
        ".tagger-container-header"
      );
      const taggerContainerHeaderObserver = new MutationObserver(
        (mutations) => {
          this.dispatchEvent(
            new CustomEvent("tagger:mutations:header", {
              detail: mutations,
            })
          );
        }
      );
      taggerContainerHeaderObserver.observe(taggerContainerHeader, {
        childList: true,
        subtree: true,
      });

      for (const searchItem of document.querySelectorAll(".search-item")) {
        this.dispatchEvent(
          new CustomEvent("tagger:searchitem", {
            detail: searchItem,
          })
        );
      }

      if (!document.getElementById("progress-bar")) {
        const progressBar = createElementFromHTML(
          `<div id="progress-bar" class="progress"><div class="progress-bar" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100"></div></div>`
        );
        progressBar.classList.add("progress");
        progressBar.style.display = "none";
        taggerContainerHeader.appendChild(progressBar);
      }
    });
    waitForElementByXpath(
      "//div[@class='tagger-container-header']/div/div[@class='row']/h4[text()='Configuration']",
      (xpath, el) => {
        this.dispatchEvent(
          new CustomEvent("tagger:configuration", {
            detail: el,
          })
        );
      }
    );
  }
  setProgress(value) {
    const progressBar = document.getElementById("progress-bar");
    if (progressBar) {
      progressBar.firstChild.style.width = value + "%";
      progressBar.style.display = value <= 0 || value > 100 ? "none" : "flex";
    }
  }
  processRemoteScenes(data) {
    if (data.data?.scrapeMultiScenes) {
      for (const matchResults of data.data.scrapeMultiScenes) {
        for (const scene of matchResults) {
          this.remoteScenes[scene.remote_site_id] = scene;
        }
      }
    } else if (data.data?.scrapeSingleScene) {
      for (const scene of data.data.scrapeSingleScene) {
        this.remoteScenes[scene.remote_site_id] = scene;
      }
    }
  }
  processScene(data) {
    if (data.data.findScene) {
      this.scenes[data.data.findScene.id] = data.data.findScene;
    }
  }
  processScenes(data) {
    if (data.data.findScenes?.scenes) {
      for (const scene of data.data.findScenes.scenes) {
        this.scenes[scene.id] = scene;
      }
    }
  }
  processStudios(data) {
    if (data.data.findStudios?.studios) {
      for (const studio of data.data.findStudios.studios) {
        this.studios[studio.id] = studio;
      }
    }
  }
  processPerformers(data) {
    if (data.data.findPerformers?.performers) {
      for (const performer of data.data.findPerformers.performers) {
        this.performers[performer.id] = performer;
      }
    }
  }
  processApiKey(data) {
    if (data.data.generateAPIKey != null && this.pluginVersion) {
      this.updateConfigValueTask("STASH", "api_key", data.data.generateAPIKey);
    }
  }
  parseSearchItem(searchItem) {
    const urlNode = searchItem.querySelector("a.scene-link");
    const url = new URL(urlNode.href);
    const id = url.pathname.replace(baseURL + "scenes/", "");
    const data = this.scenes[id];
    const nameNode = searchItem.querySelector(
      "a.scene-link > div.TruncatedText"
    );
    const name = nameNode.innerText;
    const queryInput = searchItem.querySelector("input.text-input");
    const performerNodes = searchItem.querySelectorAll(
      ".performer-tag-container"
    );

    return {
      urlNode,
      url,
      id,
      data,
      nameNode,
      name,
      queryInput,
      performerNodes,
    };
  }
  parseSearchResultItem(searchResultItem) {
    const remoteUrlNode = searchResultItem.querySelector(
      ".scene-details .optional-field .optional-field-content a"
    );
    const remoteId = remoteUrlNode?.href.split("/").pop();
    const remoteUrl = remoteUrlNode?.href ? new URL(remoteUrlNode.href) : null;
    const remoteData = this.remoteScenes[remoteId];

    const sceneDetailNodes = searchResultItem.querySelectorAll(
      ".scene-details .optional-field .optional-field-content"
    );
    let urlNode = null;
    let detailsNode = null;
    for (const sceneDetailNode of sceneDetailNodes) {
      if (
        sceneDetailNode.innerText.startsWith("http") &&
        remoteUrlNode?.href !== sceneDetailNode.innerText
      ) {
        urlNode = sceneDetailNode;
      } else if (!sceneDetailNode.innerText.startsWith("http")) {
        detailsNode = sceneDetailNode;
      }
    }

    const imageNode = searchResultItem.querySelector(
      ".scene-image-container .optional-field .optional-field-content"
    );

    const metadataNode = searchResultItem.querySelector(".scene-metadata");
    const titleNode = metadataNode.querySelector(
      "h4 .optional-field .optional-field-content"
    );
    const codeAndDateNodes = metadataNode.querySelectorAll(
      "h5 .optional-field .optional-field-content"
    );
    let codeNode = null;
    let dateNode = null;
    for (const node of codeAndDateNodes) {
      if (node.textContent.includes("-")) {
        dateNode = node;
      } else {
        codeNode = node;
      }
    }

    const entityNodes = searchResultItem.querySelectorAll(".entity-name");
    let studioNode = null;
    const performerNodes = [];
    for (const entityNode of entityNodes) {
      if (entityNode.innerText.startsWith("Studio:")) {
        studioNode = entityNode;
      } else if (entityNode.innerText.startsWith("Performer:")) {
        performerNodes.push(entityNode);
      }
    }

    const matchNodes = searchResultItem.querySelectorAll(
      "div.col-lg-6 div.mt-2 div.row.no-gutters.my-2 span.ml-auto"
    );
    const matches = [];
    for (const matchNode of matchNodes) {
      let matchType = null;
      const entityNode = matchNode.parentElement.querySelector(".entity-name");

      const matchName = matchNode.querySelector(
        ".optional-field-content b"
      ).innerText;
      const remoteName = entityNode.querySelector("b").innerText;

      let data;
      if (entityNode.innerText.startsWith("Performer:")) {
        matchType = "performer";
        if (remoteData) {
          data = remoteData.performers.find(
            (performer) => performer.name === remoteName
          );
        }
      } else if (entityNode.innerText.startsWith("Studio:")) {
        matchType = "studio";
        if (remoteData) {
          data = remoteData.studio;
        }
      }

      matches.push({
        matchType,
        matchNode,
        entityNode,
        matchName,
        remoteName,
        data,
      });
    }

    return {
      remoteUrlNode,
      remoteId,
      remoteUrl,
      remoteData,
      urlNode,
      detailsNode,
      imageNode,
      titleNode,
      codeNode,
      dateNode,
      studioNode,
      performerNodes,
      matches,
    };
  }
}

window.stash = new Stash();

function waitForElementQuerySelector(query, callback, time) {
  time = typeof time !== "undefined" ? time : 100;
  window.setTimeout(() => {
    const element = document.querySelector(query);
    if (element) {
      callback(query, element);
    } else {
      waitForElementQuerySelector(query, callback, time);
    }
  }, time);
}

function waitForElementClass(elementId, callback, time) {
  time = typeof time !== "undefined" ? time : 100;
  window.setTimeout(() => {
    const element = document.getElementsByClassName(elementId);
    if (element.length > 0) {
      callback(elementId, element);
    } else {
      waitForElementClass(elementId, callback, time);
    }
  }, time);
}

function waitForElementId(elementId, callback, time) {
  time = typeof time !== "undefined" ? time : 100;
  window.setTimeout(() => {
    const element = document.getElementById(elementId);
    if (element != null) {
      callback(elementId, element);
    } else {
      waitForElementId(elementId, callback, time);
    }
  }, time);
}

function waitForElementByXpath(xpath, callback, time) {
  time = typeof time !== "undefined" ? time : 100;
  window.setTimeout(() => {
    const element = getElementByXpath(xpath);
    if (element) {
      callback(xpath, element);
    } else {
      waitForElementByXpath(xpath, callback, time);
    }
  }, time);
}

function getElementByXpath(xpath, contextNode) {
  return document.evaluate(
    xpath,
    contextNode || document,
    null,
    XPathResult.FIRST_ORDERED_NODE_TYPE,
    null
  ).singleNodeValue;
}

function createElementFromHTML(htmlString) {
  const div = document.createElement("div");
  div.innerHTML = htmlString.trim();

  // Change this to div.childNodes to support multiple top-level nodes.
  return div.firstChild;
}

function getElementByXpath(xpath, contextNode) {
  return document.evaluate(
    xpath,
    contextNode || document,
    null,
    XPathResult.FIRST_ORDERED_NODE_TYPE,
    null
  ).singleNodeValue;
}

function getElementsByXpath(xpath, contextNode) {
  return document.evaluate(
    xpath,
    contextNode || document,
    null,
    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
    null
  );
}

function getClosestAncestor(el, selector, stopSelector) {
  let retval = null;
  while (el) {
    if (el.matches(selector)) {
      retval = el;
      break;
    } else if (stopSelector && el.matches(stopSelector)) {
      break;
    }
    el = el.parentElement;
  }
  return retval;
}

function setNativeValue(element, value) {
  const valueSetter = Object.getOwnPropertyDescriptor(element, "value").set;
  const prototype = Object.getPrototypeOf(element);
  const prototypeValueSetter = Object.getOwnPropertyDescriptor(
    prototype,
    "value"
  ).set;

  if (valueSetter && valueSetter !== prototypeValueSetter) {
    prototypeValueSetter.call(element, value);
  } else {
    valueSetter.call(element, value);
  }
}

function updateTextInput(element, value) {
  setNativeValue(element, value);
  element.dispatchEvent(
    new Event("input", {
      bubbles: true,
    })
  );
}

function concatRegexp(reg, exp) {
  let flags = reg.flags + exp.flags;
  flags = Array.from(new Set(flags.split(""))).join();
  return new RegExp(reg.source + exp.source, flags);
}

function sortElementChildren(node) {
  const items = node.childNodes;
  const itemsArr = [];
  for (const i in items) {
    if (items[i].nodeType == Node.ELEMENT_NODE) {
      // get rid of the whitespace text nodes
      itemsArr.push(items[i]);
    }
  }

  itemsArr.sort((a, b) => {
    return a.innerHTML == b.innerHTML ? 0 : a.innerHTML > b.innerHTML ? 1 : -1;
  });

  for (let i = 0; i < itemsArr.length; i++) {
    node.appendChild(itemsArr[i]);
  }
}

function xPathResultToArray(result) {
  let node = null;
  const nodes = [];
  while ((node = result.iterateNext())) {
    nodes.push(node);
  }
  return nodes;
}

function createStatElement(container, title, heading) {
  const statEl = document.createElement("div");
  statEl.classList.add("stats-element");
  container.appendChild(statEl);

  const statTitle = document.createElement("p");
  statTitle.classList.add("title");
  statTitle.innerText = title;
  statEl.appendChild(statTitle);

  const statHeading = document.createElement("p");
  statHeading.classList.add("heading");
  statHeading.innerText = heading;
  statEl.appendChild(statHeading);
}

const reloadImg = (url) =>
  fetch(url, {
    cache: "reload",
    mode: "no-cors",
  }).then(() =>
    document.body
      .querySelectorAll(`img[src='${url}']`)
      .forEach((img) => (img.src = url))
  );