// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
// ┃ This file is part of the Perspective library, distributed under the terms ┃
// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

const fs = require("fs");
const path = require("path");
const esbuild = require("esbuild");

/**
 * Esbuild plugin that compiles a `.worker.js` import into a
 * URL-yielding module. The shim `getWorkerURL()` returns a string
 * that's usable by both `new Worker(url, { type: "module" })` *and*
 * `await import(url)` — the in-process renderer path uses the latter
 * so the chart code lives in the worker bundle exactly once.
 *
 * Two output modes:
 *   - `inline: true` (default, prod). The subbuild's bytes are
 *     embedded as a JS string in the parent bundle. `getWorkerURL()`
 *     creates a Blob URL at runtime, cached so both consumers share
 *     the same URL (and the same module instance via dynamic-import
 *     dedup).
 *   - `inline: false` (debug). The subbuild's output is written to
 *     the parent's `outdir` next to the main bundle, with source
 *     maps. `getWorkerURL()` resolves `import.meta.url` to that file,
 *     so DevTools can show real source paths and breakpoints work.
 */
exports.WorkerPlugin = function WorkerPlugin(options = {}) {
    /**
     * Optional esbuild plugins to apply to the worker sub-build (e.g.
     * `GlslMinify`, `LightningCssMinify`). Use when the worker entry
     * imports the same custom-loader file types as the outer bundle.
     */
    const subbuildPlugins = options.plugins || [];

    /**
     * Optional `loader` map for the worker sub-build (e.g.
     * `{ ".glsl": "text", ".css": "text" }`).
     */
    const subbuildLoader = options.loader || {};

    /**
     * `false` to emit the worker bundle as a real file alongside the
     * parent bundle (debug builds — preserves source maps + real
     * paths in DevTools). Defaults to inline-Blob mode for prod.
     */
    const inline = options.inline !== false;

    const additionalOptions = options.additionalOptions || {};

    function setup(build) {
        build.initialOptions.metafile = true;

        build.onResolve({ filter: /\.worker(\.js)?$/ }, (args) => {
            if (args.namespace === "worker-stub") {
                const baseName = path
                    .basename(args.path)
                    .replace(".worker", "");

                const entryPoint = path.join(
                    args.pluginData.resolveDir,
                    args.path,
                );

                // `outdir` is set so that file-mode subbuilds produce
                // real, non-`<stdout>` paths in `outputFiles[].path`
                // — we use those paths to name the on-disk artifacts
                // when copying to the parent bundle's outdir. In
                // inline mode the path doesn't matter (we only read
                // the bytes), but setting `outdir` is harmless.
                const subbuild = esbuild.build({
                    target: ["es2021"],
                    entryPoints: [entryPoint],
                    define: {
                        global: "self",
                    },
                    outdir: ".",
                    entryNames: "[name]",
                    chunkNames: "[name]",
                    assetNames: "[name]",
                    minify: !process.env.PSP_DEBUG,
                    bundle: true,
                    sourcemap: !inline,
                    write: false,
                    plugins: subbuildPlugins,
                    loader: subbuildLoader,
                    format: "esm",
                    ...additionalOptions,
                });

                return {
                    path: args.path.replace(".worker", ""),
                    namespace: "worker",
                    pluginData: {
                        baseName,
                        subbuild,
                    },
                };
            }

            return {
                path: args.path,
                namespace: "worker-stub",
                pluginData: {
                    resolveDir: args.resolveDir,
                },
            };
        });

        build.onLoad(
            { filter: /.*/, namespace: "worker-stub" },
            async (args) => {
                if (inline) {
                    return {
                        pluginData: args.pluginData,

                        // Inline mode: the parent bundle imports the
                        // worker bytes as a text string and constructs
                        // a Blob URL on first call to `getWorkerURL`.
                        // The cached URL is reused for both
                        // `new Worker(url)` and `await import(url)` so
                        // module dedup keeps a single instance.
                        //
                        // `initialize()` adds a Worker-or-shim path:
                        // attempts `new Worker(blobUrl)` first; falls
                        // back to running the worker source text on the
                        // main thread via `new Function(...)` when
                        // Worker construction is unavailable (e.g.
                        // `file://` origins where module-Worker support
                        // is gated, or environments without the Worker
                        // constructor at all). The shim returned by
                        // \`make_host\` is MessagePort-shaped so
                        // downstream consumers can treat it like a real
                        // Worker.
                        contents: `
                            import workerSource from ${JSON.stringify(args.path)};
                            let cached = null;
                            export async function getWorkerURL() {
                                if (cached) return cached;
                                const blob = new Blob([workerSource], {
                                    type: "application/javascript",
                                });

                                cached = URL.createObjectURL(blob);
                                return cached;
                            }

                            function make_host(a, b) {
                                return {
                                    addEventListener(type, callback) {
                                        if (type === "message") {
                                            a.push(callback);
                                        }
                                    },
                                    removeEventListener(type, callback) {
                                        const idx = a.indexOf(callback);
                                        if (idx > -1) {
                                            a.splice(idx, 1);
                                        }
                                    },
                                    postMessage(msg, ports) {
                                        for (const listener of b) {
                                            listener({
                                                data: msg,
                                                ports: ports,
                                            });
                                        }
                                    },
                                    terminate() {},
                                    location: { href: "" },
                                };
                            }

                            function run_single_threaded() {
                                console.warn(
                                    "Running perspective in single-threaded mode"
                                );
                                const f = Function(
                                    "const self = arguments[0];" + workerSource
                                );
                                const workers = [];
                                const mains = [];
                                f(make_host(workers, mains));
                                return make_host(mains, workers);
                            }

                            export async function initialize(opts) {
                                const workerOpts = opts || {
                                    type: "module",
                                };
                                try {
                                    if (
                                        typeof window !== "undefined" &&
                                        window.location &&
                                        window.location.protocol &&
                                        window.location.protocol.startsWith(
                                            "file"
                                        )
                                    ) {
                                        console.warn(
                                            "file:// protocol does not reliably support Web Workers"
                                        );
                                        return run_single_threaded();
                                    }

                                    const url = await getWorkerURL();
                                    const worker = new Worker(url, workerOpts);
                                    return worker;
                                } catch (e) {
                                    console.error(
                                        "Error instantiating worker; falling back to single-threaded mode",
                                        e
                                    );
                                    return run_single_threaded();
                                }
                            }

                            export default getWorkerURL;
                        `,
                    };
                }

                // File mode: the subbuild writes its output to disk
                // next to the parent bundle, and `getWorkerURL`
                // resolves the worker file relative to the consuming
                // module's URL (so `<script type="module" src=...>`
                // and dynamic imports both work without a baked-in
                // absolute path). The basename comes from the
                // namespace import below.
                return {
                    pluginData: args.pluginData,
                    contents: `
                        import basename from ${JSON.stringify(args.path)};
                        const workerURL = new URL(
                            "./" + basename,
                            import.meta.url,
                        ).toString();
                        
                        export async function getWorkerURL() {
                            return workerURL;
                        }

                        export default getWorkerURL;
                    `,
                };
            },
        );

        build.onLoad({ filter: /.*/, namespace: "worker" }, async (args) => {
            const result = await args.pluginData.subbuild;

            const outpath =
                build.initialOptions.outdir ||
                path.dirname(build.initialOptions.outfile);

            if (!fs.existsSync(outpath)) {
                fs.mkdirSync(outpath, { recursive: true });
            }

            if (inline) {
                // Embed the bundle bytes as a `text` string in the
                // parent bundle; the stub above wraps them in a Blob
                // URL at runtime. The `.js.map` (when present) is
                // discarded — Blob URLs strip the source-map comment
                // anyway since DevTools can't follow it back to disk.
                const jsOut = result.outputFiles.find((o) =>
                    o.path.endsWith(".js"),
                );
                if (!jsOut) {
                    throw new Error("worker subbuild produced no .js output");
                }

                return { contents: jsOut.contents, loader: "text" };
            }

            // File mode: write the worker bundle (and source map)
            // alongside the parent bundle. Multiple output files are
            // emitted by esbuild when `sourcemap: true`. Use the
            // actual emitted .js basename for the URL so the stub
            // and the on-disk artifact agree (esbuild-emitted
            // basename includes `.worker` from the entry filename).
            let jsBaseName = null;
            for (const out of result.outputFiles) {
                const base = path.basename(out.path);
                const dst = path.join(outpath, base);
                await fs.promises.writeFile(dst, out.contents);
                if (base.endsWith(".js")) {
                    jsBaseName = base;
                }
            }

            if (!jsBaseName) {
                throw new Error("worker subbuild produced no .js output");
            }

            return {
                contents: `export default ${JSON.stringify(jsBaseName)};`,
                loader: "js",
            };
        });
    }

    return {
        name: "webworker",
        setup,
    };
};