/**
 * @description Array of selectors
 * @type {string[]}
 */

let classes = [];

/**
 * @description Shortcut to send messages to background script
 * @type {void}
 */

const dispatch = chrome.runtime.sendMessage;

/**
 * @description Array of instructions
 * @type {string[]}
 */

let fixes = [];

/**
 * @description Hostname
 */

const hostname = document.location.hostname;

/**
 * @description Is consent preview page?
 */

const isPreview =
  hostname.startsWith("consent.") || hostname.startsWith("myprivacy.");

/**
 * @description Options provided to observer
 */

const options = { childList: true, subtree: true };

/**
 * @description Selectors list
 * @type {string[]}
 */

let selectors = [];

/**
 * @description Target provided to observer
 */

const target = document.body || document.documentElement;

/**
 * @description Checks if node element is removable
 * @param {Element} node
 */

const check = (node) =>
  node instanceof HTMLElement &&
  node.parentElement &&
  !["BODY", "HTML"].includes(node.tagName) &&
  !(node.id && ["APP", "ROOT"].includes(node.id.toUpperCase?.()));

/**
 * @description Cleans DOM
 */

const clean = () => {
  if (selectors.length) {
    const nodes = Array.from(document.querySelectorAll(selectors));
    nodes.filter(check).forEach((node) => (node.outerHTML = ""));
  }
};

/**
 * @description Fixes scroll issues
 */

const fix = () => {
  const body = document.body;
  const html = document.documentElement;

  body?.classList.remove(...classes);
  body?.style.setProperty("position", "initial", "important");
  body?.style.setProperty("overflow-y", "initial", "important");
  html?.classList.remove(...classes);
  html?.style.setProperty("position", "initial", "important");
  html?.style.setProperty("overflow-y", "initial", "important");

  fixes.forEach((fix) => {
    const [match, selector, action, property] = fix.split("##");

    if (hostname.includes(match)) {
      switch (action) {
        case "click": {
          const node = document.querySelector(selector);
          node?.click();
        }
        case "remove": {
          const node = document.querySelector(selector);
          node?.style?.removeProperty(property);
        }
        case "reset": {
          const node = document.querySelector(selector);
          node?.style?.setProperty(property, "initial", "important");
        }
        case "resetAll": {
          const nodes = document.querySelectorAll(selector);
          // prettier-ignore
          nodes.forEach((node) => node?.style?.setProperty(property, "initial", "important"));
        }
        default:
          break;
      }
    }
  });
};

const observer = new MutationObserver((mutations, instance) => {
  instance.disconnect();
  fix();

  if (!isPreview) {
    for (const mutation of mutations) {
      for (const node of mutation.addedNodes) {
        const valid = check(node);

        if (valid && node.matches(selectors)) node.outerHTML = "";
      }
    }
  }

  instance.observe(target, options);
});

/**
 * @description Queries classes selectors
 * @returns {Promise<{ classes: string[] }>}
 */

const queryClasses = () =>
  new Promise((resolve) => {
    dispatch({ type: "GET_CLASSES" }, null, resolve);
  });

/**
 * @description Queries fixes instructions
 * @returns {Promise<{ fixes: string[] }>}
 */

const queryFixes = () =>
  new Promise((resolve) => {
    dispatch({ type: "GET_FIXES" }, null, resolve);
  });

/**
 * @description Queries elements selectors
 * @returns {Promise<{ selectors: string }>}
 */

const querySelectors = () =>
  new Promise((resolve) => {
    dispatch({ type: "GET_SELECTORS" }, null, resolve);
  });

/**
 * @description Cleans DOM again after all
 * @listens document#readystatechange
 */

document.addEventListener("readystatechange", () => {
  dispatch({ hostname, type: "GET_CACHE" }, null, async ({ enabled }) => {
    if (document.readyState === "complete" && enabled && !isPreview) {
      fix();
      clean();
      setTimeout(clean, 2000);
    }
  });
});

/**
 * @description Fix bfcache issues
 * @listens window#unload
 */

window.addEventListener("unload", () => {});

/**
 * @description Setups everything and starts to observe if enabled
 */

dispatch({ hostname, type: "GET_CACHE" }, null, async ({ enabled }) => {
  dispatch({ type: "ENABLE_POPUP" });

  if (enabled) {
    const promises = [queryClasses(), queryFixes(), querySelectors()];
    const results = await Promise.all(promises);

    classes = results[0]?.classes ?? [];
    fixes = results[1]?.fixes ?? [];
    selectors = results[2]?.selectors ?? [];
    observer.observe(target, options);
    dispatch({ type: "ENABLE_ICON" });
  }
});