/* global window, document */
// Runs on the editor origin before VS Code loads. It waits for the forge page to hand over a ref-scoped
// session over postMessage, then boots the Code - OSS workbench with the gitfor-fs extension. The token
// only ever travels by postMessage between exact origins; there are no cookies on this origin.
(function boot() {
  "use strict";
  var config = JSON.parse(document.getElementById("gitfor-config").textContent);
  var session = null;
  var waiting = [];
  var load = window.crypto.randomUUID();

  function post(message) {
    window.parent.postMessage(message, config.forgeOrigin);
  }

  function sessionInfo() {
    return Object.assign({}, session, { forgeOrigin: config.forgeOrigin });
  }

  function refresh() {
    return new Promise(function (resolve) {
      waiting.push(resolve);
      post({ type: "gitfor-editor:refresh" });
    });
  }

  function loadScript(src) {
    return new Promise(function (resolve, reject) {
      var script = document.createElement("script");
      script.src = src;
      script.onload = resolve;
      script.onerror = function () {
        reject(new Error("Failed to load " + src));
      };
      document.body.appendChild(script);
    });
  }

  function start() {
    var base = config.assetBase;
    var link = document.createElement("link");
    link.rel = "stylesheet";
    link.href = base + "/out/vs/workbench/workbench.web.main.css";
    document.head.appendChild(link);
    window.product = {
      productConfiguration: {
        nameShort: "gitfor",
        nameLong: "gitfor editor",
        applicationName: "gitfor",
        dataFolderName: ".gitfor-editor",
        version: config.vscodeVersion,
        // Third-party extensions run with this session's access, so Open VSX is opt-in per deployment.
        extensionsGallery: config.gallery
          ? {
              serviceUrl: "https://open-vsx.org/vscode/gallery",
              itemUrl: "https://open-vsx.org/vscode/item",
              resourceUrlTemplate: "https://open-vsx.org/vscode/unpkg/{publisher}/{name}/{version}/{path}",
            }
          : undefined,
        // The built-in gitfor extension searches the virtual `gitfor:` workspace (VS Code has no other way to).
        extensionEnabledApiProposals: { "gitfor.gitfor-fs": ["fileSearchProvider", "textSearchProvider"] },
        webviewContentExternalBaseUrlTemplate: base + "/out/vs/workbench/contrib/webview/browser/pre/",
        linkProtectionTrustedDomains: [config.forgeOrigin, "https://open-vsx.org"],
      },
      folderUri: { scheme: "gitfor", authority: "", path: "/" + session.owner + "/" + session.repo },
      additionalBuiltinExtensions: [
        {
          scheme: window.location.protocol.slice(0, -1),
          authority: window.location.host,
          path: "/editor-ext/gitfor-fs",
        },
      ],
      configurationDefaults: {
        "files.autoSave": "afterDelay",
        "files.autoSaveDelay": 400,
        "workbench.startupEditor": "none",
        "security.workspace.trust.enabled": false,
        "git.enabled": false,
        "telemetry.telemetryLevel": "off",
        "workbench.colorTheme": "Default Dark Modern",
        "workbench.preferredDarkColorTheme": "Default Dark Modern",
        "window.autoDetectColorScheme": false,
      },
      windowIndicator: {
        label: "$(repo) " + session.owner + "/" + session.repo + " @ " + session.ref,
        tooltip: "gitfor",
      },
      commands: [
        { id: "gitfor.session", handler: sessionInfo },
        {
          id: "gitfor.refreshSession",
          handler: function () {
            return refresh().then(sessionInfo);
          },
        },
      ],
    };
    loadScript(base + "/out/vs/loader.js")
      .then(function () {
        return loadScript(base + "/out/vs/webPackagePaths.js");
      })
      .then(function () {
        Object.keys(window.webPackagePaths).forEach(function (key) {
          window.webPackagePaths[key] = base + "/node_modules/" + key + "/" + window.webPackagePaths[key];
        });
        window.require.config({
          baseUrl: base + "/out",
          paths: window.webPackagePaths,
          trustedTypesPolicy:
            window.trustedTypes &&
            window.trustedTypes.createPolicy("amdLoader", {
              createScriptURL: function (value) {
                if (value.indexOf(window.location.origin) === 0) return value;
                throw new Error("Invalid script url: " + value);
              },
            }),
        });
        return loadScript(base + "/out/vs/workbench/workbench.web.main.nls.js");
      })
      .then(function () {
        return loadScript(base + "/out/vs/workbench/workbench.web.main.js");
      })
      .then(function () {
        return loadScript(base + "/out/vs/code/browser/workbench/workbench.js");
      })
      .then(function () {
        post({ type: "gitfor-editor:booted" });
      })
      .catch(function (error) {
        post({ type: "gitfor-editor:error", message: String(error && error.message) });
      });
  }

  window.addEventListener("message", function (event) {
    if (event.source !== window.parent || event.origin !== config.forgeOrigin) return;
    var data = event.data || {};
    if (data.type !== "gitfor-editor:init" || !data.session || typeof data.session.token !== "string") return;
    var first = session === null;
    session = data.session;
    waiting.splice(0).forEach(function (resolve) {
      resolve(session);
    });
    if (first) start();
  });
  // The forge page may still be hydrating when this loads, so keep announcing until it answers.
  var MAX_ANNOUNCEMENTS = 120;
  var announcements = 0;
  var announcer = setInterval(function () {
    if (session !== null || ++announcements > MAX_ANNOUNCEMENTS) return clearInterval(announcer);
    post({ type: "gitfor-editor:ready", load: load });
  }, 500);
  post({ type: "gitfor-editor:ready", load: load });
})();