(function () {
  function normalizePrefix(prefix) {
    if (!prefix) {
      return "/";
    }

    var normalized = prefix;
    if (!normalized.startsWith("/")) {
      normalized = "/" + normalized;
    }
    if (!normalized.endsWith("/")) {
      normalized += "/";
    }
    return normalized.replace(/\/{2,}/g, "/");
  }

  function joinPath(prefix, suffix) {
    var cleanSuffix = (suffix || "").replace(/^\/+/, "");
    return normalizePrefix(prefix) + cleanSuffix;
  }

  function samePageTarget(currentPrefix, targetPrefix) {
    var currentPath = window.location.pathname;
    var normalizedCurrent = normalizePrefix(currentPrefix);
    var normalizedTarget = normalizePrefix(targetPrefix);

    if (currentPath.indexOf(normalizedCurrent) === 0) {
      return joinPath(normalizedTarget, currentPath.slice(normalizedCurrent.length));
    }

    return normalizedTarget;
  }

  function setStatus(node, message, isError) {
    if (!node) {
      return;
    }

    node.textContent = message;
    node.classList.toggle("is-error", Boolean(isError));
  }

  function setPdfLinks(node, entry) {
    if (!node) {
      return;
    }

    var pdfAssets = entry && entry.assets && Array.isArray(entry.assets.pdfs) ? entry.assets.pdfs : [];
    if (!pdfAssets.length) {
      node.hidden = true;
      node.innerHTML = "";
      return;
    }

    node.innerHTML = "";
    pdfAssets.forEach(function (item) {
      if (!item.url) {
        return;
      }

      var link = document.createElement("a");
      link.className = "doc-version-selector__download";
      link.href = item.url;
      link.textContent = item.label || "Download PDF";
      node.appendChild(link);
    });

    node.hidden = node.children.length === 0;
  }

  function updateActiveVersion(state, chosen) {
    state.activeEntry = chosen;
    setPdfLinks(state.pdfLinks, chosen);
  }

  function bindVersionSelect(state, versions) {
    state.select.addEventListener("change", function (event) {
      var chosen = versions.find(function (item) {
        return item.slug === event.target.value;
      });

      if (!chosen) {
        return;
      }

      var previousEntry = state.activeEntry || chosen;
      updateActiveVersion(state, chosen);
      var targetPath = samePageTarget(previousEntry.prefix, chosen.prefix);
      var nextUrl = targetPath + window.location.search + window.location.hash;
      window.location.assign(nextUrl);
    });
  }

  function setPdfLinksFromManifest(state, manifest, currentVersion) {
    var versions = Array.isArray(manifest.versions) ? manifest.versions : [];
    if (!versions.length) {
      throw new Error("No versions defined");
    }

    var activeVersion = manifest.current || currentVersion;
    var activeEntry = versions.find(function (item) {
      return item.slug === activeVersion;
    }) || versions.find(function (item) {
      return item.slug === currentVersion;
    }) || versions[0];

    state.select.innerHTML = "";

    versions.forEach(function (item) {
      var option = document.createElement("option");
      option.value = item.slug;
      option.textContent = item.label || item.slug;
      option.dataset.prefix = item.prefix || "/" + item.slug + "/";
      if (item.slug === activeEntry.slug) {
        option.selected = true;
      }
      state.select.appendChild(option);
    });

    state.activeEntry = activeEntry;
    setPdfLinks(state.pdfLinks, activeEntry);
    bindVersionSelect(state, versions);
  }

  document.addEventListener("DOMContentLoaded", function () {
    var container = document.querySelector(".doc-version-selector");
    if (!container) {
      return;
    }

    var select = container.querySelector(".js-version-select");
    var pdfLinks = container.querySelector(".js-version-pdfs");
    var status = container.querySelector(".js-version-status");
    var currentVersion = container.dataset.currentVersion || "latest";
    var versionsUrl = container.dataset.versionsUrl;

    if (!select || !versionsUrl) {
      return;
    }

    var state = {
      activeEntry: null,
      pdfLinks: pdfLinks,
      select: select,
    };

    fetch(versionsUrl, { credentials: "same-origin" })
      .then(function (response) {
        if (!response.ok) {
          throw new Error("Unable to load versions");
        }
        return response.json();
      })
      .then(function (manifest) {
        setPdfLinksFromManifest(state, manifest, currentVersion);
        setStatus(status, manifest.description || "Switch versions without leaving the current page.");
      })
      .catch(function () {
        setPdfLinks(pdfLinks, null);
        setStatus(status, "versions.json could not be loaded.", true);
      });
  });
})();