randomize.ts

import { execSync } from "node:child_process";
import fs from "node:fs";
import path from "node:path";

const FilesMap: { [original: string]: string } = {};
const RouteMap: { [original: string]: string } = {};
const FaviconMap: { [original: string]: string } = {};

export function RandomizeNames(filePath: string): string {
  const extension = path.extname(filePath);
  return `${Math.random().toString(36).slice(2, 11)}${extension}`;
}

export function FindFiles(directory: string, pattern: RegExp): string[] {
  let MatchedFiles: string[] = [];
  const files = fs.readdirSync(directory);

  for (const file of files) {
    const FullPath = path.resolve(directory, file);
    const stats = fs.statSync(FullPath);

    if (stats.isDirectory()) {
      MatchedFiles = MatchedFiles.concat(FindFiles(FullPath, pattern));
    } else if (pattern.test(file)) {
      MatchedFiles.push(FullPath);
    }
  }

  return MatchedFiles;
}

export function RandomizeFavicons() {
  const FaviconDir = path.join(
    process.cwd(),
    "public",
    "assets",
    "media",
    "favicons",
  );

  if (!fs.existsSync(FaviconDir)) {
    return;
  }

  const Favicons = fs.readdirSync(FaviconDir);

  for (const file of Favicons) {
    const OriginalPath = path.join(FaviconDir, file);
    const RandomizedName = RandomizeNames(file);
    const NewPath = path.join(FaviconDir, RandomizedName);

    fs.renameSync(OriginalPath, NewPath);
    FaviconMap[file] = RandomizedName;
  }

  UpdateFaviconRoutes();
}

export function UpdateFaviconRoutes() {
  const FilesToUpdate = [
    ...FindFiles(path.join(process.cwd(), "src"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src"), /\.ts$/),
  ];

  for (const file of FilesToUpdate) {
    let content = fs.readFileSync(file, "utf-8");

    for (const [OldName, RandomizedName] of Object.entries(FaviconMap)) {
      const patterns = [
        `/assets/media/favicons/${OldName}`,
        `assets/media/favicons/${OldName}`,
        `'${OldName}'`,
        `"${OldName}"`,
      ];

      for (const pattern of patterns) {
        content = content.replace(
          new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
          pattern.startsWith("/")
            ? `/assets/media/favicons/${RandomizedName}`
            : pattern.startsWith("assets")
              ? `assets/media/favicons/${RandomizedName}`
              : pattern.startsWith("'")
                ? `'${RandomizedName}'`
                : `"${RandomizedName}"`,
        );
      }
    }

    fs.writeFileSync(file, content, "utf-8");
  }
}

export function Main() {
  RandomizeFavicons();

  const FilesToProcess = [
    ...FindFiles(path.join(process.cwd(), "src", "components"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src", "layouts"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src", "lib"), /\.ts$/),
    ...FindFiles(path.join(process.cwd(), "src", "pages"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src", "pages", "e"), /\.ts$/),
  ];

  for (const file of FilesToProcess) {
    if (path.basename(file) === "index.astro") {
      continue;
    }

    const RandomizedName = RandomizeNames(file);
    const OriginalPath = path.resolve(file);
    const NewPath = path.resolve(path.dirname(file), RandomizedName);

    FilesMap[OriginalPath] = NewPath;

    if (file.startsWith(path.join(process.cwd(), "src", "pages"))) {
      const OriginalRoute = OriginalPath.replace(
        path.join(process.cwd(), "src", "pages"),
        "",
      )
        .replace(/\\/g, "/")
        .replace(/\.astro$/, "");

      const NewRoute = NewPath.replace(path.join(process.cwd(), "src", "pages"), "")
        .replace(/\\/g, "/")
        .replace(/\.astro$/, "");

      RouteMap[OriginalRoute] = NewRoute;

      if (OriginalRoute.startsWith("/")) {
        RouteMap[OriginalRoute.substring(1)] = NewRoute.startsWith("/")
          ? NewRoute.substring(1)
          : NewRoute;
      } else {
        RouteMap[OriginalRoute] = NewRoute;
      }
    }
  }

  UpdateImports();
  UpdateRoutes();

  for (const [OriginalPath, NewPath] of Object.entries(FilesMap)) {
    fs.renameSync(OriginalPath, NewPath);
  }

  console.log("Routes updated:", RouteMap);
}

export function UpdateRoutes() {
  const FilesToUpdate = [
    ...FindFiles(path.join(process.cwd(), "src"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src"), /\.ts$/),
  ];

  for (const file of FilesToUpdate) {
    let content = fs.readFileSync(file, "utf-8");

    for (const [OriginalRoute, NewRoute] of Object.entries(RouteMap)) {
      const routePattern = new RegExp(`(['"\`])${OriginalRoute}(['"\`])`, "g");

      content = content.replace(routePattern, `$1${NewRoute}$2`);
    }

    fs.writeFileSync(file, content, "utf-8");
  }
}

export function UpdateImports() {
  const FilesToUpdate = [
    ...FindFiles(path.join(process.cwd(), "src"), /\.astro$/),
    ...FindFiles(path.join(process.cwd(), "src"), /\.ts$/),
  ];

  const root = process.cwd();

  for (const file of FilesToUpdate) {
    let content = fs.readFileSync(file, "utf-8");

    for (const [OriginalPath, NewPath] of Object.entries(FilesMap)) {
      const OriginalName = path.basename(OriginalPath);
      const RandomizedName = path.basename(NewPath);

      const OriginalPatterns = [
        `@/components/${OriginalName}`,
        `@/layouts/${OriginalName}`,
        `@/lib/${OriginalName}`,
        OriginalPath.replace(root, "").replace(/\\/g, "/"),
        OriginalName,
      ];

      const NewPatterns = [
        `@/components/${RandomizedName}`,
        `@/layouts/${RandomizedName}`,
        `@/lib/${RandomizedName}`,
        NewPath.replace(root, "").replace(/\\/g, "/"),
        RandomizedName,
      ];

      OriginalPatterns.forEach((pattern, index) => {
        content = content.replace(
          new RegExp(
            `['"]${pattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.")}['"]`,
            "g",
          ),
          `'${NewPatterns[index]}'`,
        );
      });
    }

    fs.writeFileSync(file, content, "utf-8");
  }
}

export async function Revert() {
  try {
    console.log("Reverting Changes.");
    execSync("git restore src/ public/", { cwd: process.cwd(), stdio: "inherit" });
    execSync("git clean -fdx src/ public/", {
      cwd: process.cwd(),
      stdio: "inherit",
    });
    await new Promise((resolve) => setTimeout(resolve, 1000));
    console.log("Revert completed.");
  } catch (error) {
    console.error(
      "Error while reverting:",
      error instanceof Error ? error.message : error,
    );
  }
}