import commonjs from "@rollup/plugin-commonjs";
import nodeResolve from "@rollup/plugin-node-resolve";
import { createHash } from "crypto";
import { readFile, readdir, writeFile } from "fs/promises";
import { argv } from "process";
import { rollup, watch } from "rollup";

import swc from "@swc/core";
import esbuild from "rollup-plugin-esbuild";

const args = argv.slice(2);
console.clear();

const inputPlugins = args.filter((x) => !x.startsWith("-"));
const flags = args.map((x) => x.toLowerCase()).filter((x) => x.startsWith("-"));

const isWatch = flags.includes("--watch") || flags.includes("-w");
const toBuild = inputPlugins.length ? inputPlugins : await readdir("./plugins");

console.log(`Building ${toBuild.length} plugin(s)...`);

let failed = 0;

for (const plugin of toBuild) {
  try {
    await buildPlugin(plugin);
  } catch (e) {
    console.error(e.stack || e);
    failed++;
  }
}

console.log(
  "\n" +
    (failed
      ? "\x1b[31m" + `Failed to build ${failed} plugin(s)` + "\x1b[0m"
      : "\x1b[32m" + "All plugin(s) built successfully!" + "\x1b[0m"),
);

isWatch && console.log("\nWatching for changes...");

async function buildPlugin(plugin) {
  if (plugin.endsWith(".ts")) return;

  const manifest = Object.assign(
    JSON.parse(await readFile("./base_manifest.json")),
    JSON.parse(await readFile(`./plugins/${plugin}/manifest.json`)),
  );

  const entry = "index.js";
  const outPath = `./dist/${plugin}/${entry}`;

  /** @type {import("rollup").RollupOptions} */
  const options = {
    input: `./plugins/${plugin}/${manifest.main}`,
    output: {
      file: outPath,
      globals(id) {
        if (id.startsWith("@vendetta"))
          return id.substring(1).replace(/\//g, ".");

        const map = {
          react: "window.React",
          "react-native": "vendetta.metro.common.ReactNative",
        };

        return map[id] || null;
      },
      format: "iife",
      compact: true,
      exports: "named",
      inlineDynamicImports: true,
    },
    onwarn: (warning) => {
      ![
        "UNRESOLVED_IMPORT",
        "MISSING_NAME_OPTION_FOR_IIFE_EXPORT",
        "CIRCULAR_DEPENDENCY",
      ].includes(warning.code) && console.warn(warning);
    },
    plugins: [
      nodeResolve({
        resolveOnly: (id) => !["react", "react-native"].includes(id),
      }),
      commonjs(),
      {
        name: "swc",
        transform(code, id) {
          return swc.transform(code, {
            filename: id,
            jsc: {
              parser: {
                syntax: "typescript",
                tsx: true,
              },
              externalHelpers: true,
            },
            env: {
              targets: "defaults",
              include: ["transform-classes", "transform-arrow-functions"],
            },
          });
        },
      },
      esbuild({ minify: true }),
    ],
  };

  const applyHash = async () =>
    Object.assign(manifest, {
      hash: createHash("sha256")
        .update(await readFile(outPath))
        .digest("hex"),
      main: entry,
    });

  if (!isWatch) {
    const bundle = await rollup(options);
    await bundle.write(options.output);
    await bundle.close();

    await applyHash();
    await writeFile(`./dist/${plugin}/manifest.json`, JSON.stringify(manifest));

    console.log(`${plugin}: ` + "\x1b[32m" + "Build succeed!" + "\x1b[0m");
    return;
  }

  const watcher = watch(options);

  return await new Promise((resolve, reject) => {
    watcher.on("event", async (event) => {
      switch (event.code) {
        case "BUNDLE_END": {
          event.result.close();

          await applyHash();
          await writeFile(
            `./dist/${plugin}/manifest.json`,
            JSON.stringify(manifest),
          );

          console.log(
            `${plugin}: ` +
              "\x1b[32m" +
              `Build succeed! (${event.duration}ms)` +
              "\x1b[0m",
          );
          resolve();
          break;
        }
        case "ERROR":
        case "FATAL":
          console.error(`${plugin}: ` + "\x1b[31m", "Failed! :(", "\x1b[0m");
          reject(event.error);
          break;
      }
    });
  });
}