const fs = require("fs");
const path = require("path");
const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;

const entryFile = path.resolve(__dirname, "index.js");
const srcDir = path.resolve(__dirname, "src");

// Extensions de fichiers à analyser
const scriptExtensions = [".js", ".jsx", ".ts", ".tsx", ".web.js"];
const imageExtensions = [".png", ".jpg", ".jpeg", ".gif", ".svg"];

// Fonction pour obtenir tous les fichiers dans un dossier avec des extensions spécifiques
function getAllFiles(dir, extensions, fileList = []) {
  const files = fs.readdirSync(dir);
  files.forEach(function (file) {
    const filePath = path.join(dir, file);
    const stat = fs.statSync(filePath);
    if (stat.isDirectory()) {
      getAllFiles(filePath, extensions, fileList);
    } else if (extensions.includes(path.extname(file))) {
      fileList.push(filePath);
    }
  });
  return fileList;
}

// Vérifie si un chemin est un fichier valide
function isValidFile(filePath) {
  return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
}

// Résout le chemin de l'import en un fichier valide
function resolveImport(filePath, importPath) {
  let importedFile = path.resolve(path.dirname(filePath), importPath);

  // Liste des extensions à tester, y compris .web.js
  const allExtensions = scriptExtensions;

  // Si le chemin n'a pas d'extension, essayer avec différentes extensions
  if (!path.extname(importedFile)) {
    for (const ext of allExtensions) {
      if (isValidFile(importedFile + ext)) {
        return importedFile + ext;
      }
    }
  }

  // Si un fichier avec l'extension actuelle existe, le retourner
  if (isValidFile(importedFile)) {
    return importedFile;
  }

  // Si le chemin est un répertoire, chercher un index avec les extensions
  if (fs.existsSync(importedFile) && fs.statSync(importedFile).isDirectory()) {
    const indexFiles = allExtensions.map((ext) => "index" + ext);
    for (const indexFile of indexFiles) {
      const indexFilePath = path.join(importedFile, indexFile);
      if (isValidFile(indexFilePath)) {
        return indexFilePath;
      }
    }
  }

  // Aucun fichier valide trouvé
  return null;
}

// Analyse des fichiers pour trouver les imports
function getDependencies(
  filePath,
  visitedFiles = new Set(),
  usedDependencies = new Set(),
  usedFiles = new Set(),
  usedAssets = new Set()
) {
  if (visitedFiles.has(filePath))
    return { usedDependencies, usedFiles, usedAssets };
  visitedFiles.add(filePath);
  usedFiles.add(filePath);

  const content = fs.readFileSync(filePath, "utf-8");
  let ast;
  try {
    ast = parser.parse(content, {
      sourceType: "module",
      plugins: ["jsx", "typescript", "classProperties", "dynamicImport"],
    });
  } catch (error) {
    console.error(`Erreur lors de l'analyse du fichier ${filePath}:`, error);
    return { usedDependencies, usedFiles, usedAssets };
  }

  traverse(ast, {
    ImportDeclaration({ node }) {
      const importPath = node.source.value;
      handleImport(
        filePath,
        importPath,
        visitedFiles,
        usedDependencies,
        usedFiles,
        usedAssets
      );
    },
    CallExpression({ node }) {
      if (
        node.callee.type === "Import" ||
        (node.callee.name === "require" && node.arguments.length)
      ) {
        const importArg = node.arguments[0];
        if (importArg && importArg.type === "StringLiteral") {
          const importPath = importArg.value;
          handleImport(
            filePath,
            importPath,
            visitedFiles,
            usedDependencies,
            usedFiles,
            usedAssets
          );
        }
      }
    },
  });

  // Vérifier si un fichier .web.js correspondant existe
  if (filePath.endsWith(".js")) {
    const webFilePath = filePath.replace(/\.js$/, ".web.js");
    if (isValidFile(webFilePath)) {
      getDependencies(
        webFilePath,
        visitedFiles,
        usedDependencies,
        usedFiles,
        usedAssets
      );
    }
  }

  return { usedDependencies, usedFiles, usedAssets };
}

// Fonction pour gérer les imports
function handleImport(
  filePath,
  importPath,
  visitedFiles,
  usedDependencies,
  usedFiles,
  usedAssets
) {
  if (importPath.startsWith(".")) {
    // Chemin relatif
    const resolvedPath = resolveImport(filePath, importPath);
    if (resolvedPath) {
      const ext = path.extname(resolvedPath);
      if (scriptExtensions.includes(ext)) {
        getDependencies(
          resolvedPath,
          visitedFiles,
          usedDependencies,
          usedFiles,
          usedAssets
        );
      } else if (imageExtensions.includes(ext)) {
        usedAssets.add(resolvedPath);
      }
    }
  } else {
    // Dépendance de node_modules
    const dep = importPath.split("/")[0];
    usedDependencies.add(dep);
  }
}

(async () => {
  // Étape 1: Obtenir tous les fichiers utilisés
  const allScriptFiles = getAllFiles(srcDir, scriptExtensions);
  const allAssetFiles = getAllFiles(srcDir, imageExtensions);

  const { usedDependencies, usedFiles, usedAssets } =
    getDependencies(entryFile);

  // Étape 2: Supprimer les fichiers scripts inutilisés
  const unusedScriptFiles = allScriptFiles.filter(
    (file) => !usedFiles.has(file)
  );

  unusedScriptFiles.forEach((file) => {
    fs.unlinkSync(file);
    console.log(`Fichier script supprimé: ${file}`);
  });

  // Étape 3: Supprimer les images non utilisées
  const unusedAssetFiles = allAssetFiles.filter(
    (file) => !usedAssets.has(file)
  );

  unusedAssetFiles.forEach((file) => {
    fs.unlinkSync(file);
    console.log(`Fichier image supprimé: ${file}`);
  });

  // Étape 4: Optimiser les images utilisées sans perte de qualité
  async function optimizeImages(usedAssets) {
    // Import dynamique des modules ES
    const imagemin = (await import("imagemin")).default;
    const imageminOptipng = (await import("imagemin-optipng")).default;
    const imageminJpegtran = (await import("imagemin-jpegtran")).default;
    const imageminGifsicle = (await import("imagemin-gifsicle")).default;
    const imageminSvgo = (await import("imagemin-svgo")).default;

    for (const file of usedAssets) {
      const ext = path.extname(file).toLowerCase();
      const plugins = [];

      if (ext === ".png") {
        plugins.push(imageminOptipng({ optimizationLevel: 3 }));
      } else if (ext === ".jpg" || ext === ".jpeg") {
        plugins.push(imageminJpegtran({ progressive: true }));
      } else if (ext === ".gif") {
        plugins.push(imageminGifsicle({ optimizationLevel: 3 }));
      } else if (ext === ".svg") {
        plugins.push(imageminSvgo());
      } else {
        continue;
      }

      try {
        const optimized = await imagemin([file], {
          destination: path.dirname(file),
          plugins: plugins,
        });

        if (optimized && optimized.length > 0) {
          console.log(`Image optimisée: ${file}`);
        } else {
          console.log(`Image déjà optimisée ou non optimisable: ${file}`);
        }
      } catch (error) {
        console.error(
          `Erreur lors de l'optimisation de l'image ${file}:`,
          error
        );
      }
    }
  }

  await optimizeImages(usedAssets);
})();