import { ZipFS, getLibzipSync } from "@yarnpkg/libzip";
import { patchFs, PosixFS, NodeFS } from "@yarnpkg/fslib";
import { SnapshotZipFS } from "./SnapshotZipFS";
import * as assert from "assert";
import * as constants from "constants";
import { dirname, relative, sep } from "path";

export interface NexeHeader {
  blobPath: string;
  layout: {
    resourceStart: number;
    resourceSize: number;
    contentSize: number;
    contentStart: number;
  };
}

let originalFsMethods: any = null;
let lazyRestoreFs = () => {};
const patches = (process as any).nexe.patches || {};
const originalPatches = { ...patches };
delete (process as any).nexe;

function shimFs(binary: NexeHeader, fs: typeof import("fs") = require("fs")) {
  if (originalFsMethods !== null) {
    return;
  }

  originalFsMethods = Object.assign({}, fs);

  const realFs: typeof fs = { ...fs };
  const nodeFs = new NodeFS(realFs);

  const blob = Buffer.allocUnsafe(binary.layout.resourceSize);
  const blobFd = realFs.openSync(binary.blobPath, "r");
  const bytesRead = realFs.readSync(
    blobFd,
    blob,
    0,
    binary.layout.resourceSize,
    binary.layout.resourceStart
  );
  assert.equal(bytesRead, binary.layout.resourceSize);

  const zipFs = new ZipFS(blob, { readOnly: true });
  const snapshotZipFS = new SnapshotZipFS({
    libzip: getLibzipSync(),
    zipFs,
    baseFs: nodeFs,
    root: dirname(process.argv[0]), // executable directory = original project root
  });
  const posixSnapshotZipFs = new PosixFS(snapshotZipFS);
  patchFs(fs, posixSnapshotZipFs); // patches global fs

  // Capture the project root for path mapping
  const projectRoot = dirname(process.argv[0]);
  const drive = projectRoot.slice(0, 2); // e.g., "C:"

  // Enable logging with DEBUG=nexe:require
  let log = (_: string) => true;
  if ((process.env.DEBUG || "").toLowerCase().includes("nexe:require")) {
    process.stderr.write(
      `[nexe] - FILES ${JSON.stringify(
        // @ts-ignore - accessing private property for debugging
        Array.from(zipFs.entries.keys()),
        null,
        4
      )}\n`
    );
    process.stderr.write(
      `[nexe] - DIRECTORIES ${JSON.stringify(
        // @ts-ignore - accessing private property for debugging
        Array.from(zipFs.listings.keys()),
        null,
        4
      )}\n`
    );
    log = (text: string) => process.stderr.write(`[nexe] - ${text}\n`);
  }

  /**
   * Convert a Windows path to the snapshot POSIX path.
   * Handles:
   *   - Paths under the original project root (e.g., C:\Users\oxmc\Desktop\src\entry.js → /snapshot/src/entry.js)
   *   - Paths that have been converted to C:\snapshot\... (from _findPath returning /snapshot/...)
   *   - Already POSIX /snapshot/... paths (return as-is)
   */
  function toSnapshotPath(filePath: string): string {
    // Already a POSIX snapshot path
    if (filePath.startsWith("/snapshot/")) {
      return filePath;
    }
    // Handle Windows-style snapshot path: e.g., C:\snapshot\src\entry.js
    if (filePath.startsWith(drive + "\\snapshot\\")) {
      return "/snapshot/" + filePath.slice(drive.length + 9).replace(/\\/g, "/");
    }
    // Path under original project root
    if (filePath.startsWith(projectRoot)) {
      const rel = relative(projectRoot, filePath);
      return "/snapshot/" + rel.replace(/\\/g, "/");
    }
    // Not mappable – return unchanged (will likely fail)
    return filePath;
  }

  // --- Internal Module Patches (unconditionally assigned) ---

  function internalModuleReadFile(this: any, original: any, ...args: any[]) {
    // Strip Windows extended-length path prefix if present
    let filePath = typeof args[0] === "string" ? args[0] : "";
    if (filePath.startsWith("\\\\?\\")) {
      filePath = filePath.slice(4);
    }
    const mappedPath = toSnapshotPath(filePath);
    log(`internalModuleReadFile ${filePath} -> ${mappedPath}`);
    try {
      // Use the patched fs (which already sees the zip)
      return fs.readFileSync(mappedPath, "utf-8");
    } catch (e) {
      return "";
    }
  }

  patches.internalModuleReadFile = internalModuleReadFile;

  // internalModuleReadJSON should return a string (or undefined) in Node 22
  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
    const content = internalModuleReadFile.call(this, original, ...args);
    return content === "" ? undefined : content;
  };

  // Handle Node 22+ signature: first arg is context (non-string), second is path
  function internalModuleStat(this: any, original: any, ...args: any[]) {
    const target = args[0];
    let statPath: string;

    // Node 22+: args[0] is context (often a buffer), args[1] is the path string
    if (typeof target === "number") {
      // file descriptor case – unchanged
      try {
        originalFsMethods.fstatSync(target);
        return 0;
      } catch (e) {
        return -constants.ENOENT;
      }
    }

    if (typeof target === "string") {
      // Node <22 or when a string is passed directly
      statPath = target;
    } else {
      // Node 22+: path is the second argument
      statPath = args[1];
    }

    if (typeof statPath !== "string") {
      // Unexpected: fallback to original
      return original.call(this, ...args);
    }

    // Strip Windows extended-length prefix
    if (statPath.startsWith("\\\\?\\")) {
      statPath = statPath.slice(4);
    }

    const mappedPath = toSnapshotPath(statPath);
    log(`internalModuleStat ${statPath} -> ${mappedPath}`);

    try {
      const stat = fs.statSync(mappedPath);
      return stat.isDirectory() ? 1 : 0;
    } catch (e) {
      return -constants.ENOENT;
    }
  }

  patches.internalModuleStat = internalModuleStat;

  // --- Patch Module._findPath with a correct exports resolver ---

  // Helper to check if a path exists and is a file
  function isFile(p: string): boolean {
    try {
      const stat = fs.statSync(p);
      return stat.isFile();
    } catch {
      return false;
    }
  }

  // Recursive exports resolver following Node's conditional exports
  function resolvePackageExports(exports: any, conditions: string[]): string | null {
    if (typeof exports === "string") {
      return exports;
    }
    if (!exports || typeof exports !== "object") {
      return null;
    }
    // Handle "." subpath first (for bare module, we always start with ".")
    const subExports = exports["."] ?? exports;
    return resolveExportsObject(subExports, conditions);
  }

  function resolveExportsObject(obj: any, conditions: string[]): string | null {
    if (typeof obj === "string") {
      return obj;
    }
    if (!obj || typeof obj !== "object") {
      return null;
    }
    // Iterate over keys in order; if a key matches a condition, take that branch
    for (const key of Object.keys(obj)) {
      if (conditions.includes(key)) {
        const value = obj[key];
        if (typeof value === "string") {
          return value;
        }
        if (value && typeof value === "object") {
          const nested = resolveExportsObject(value, conditions);
          if (nested) return nested;
        }
      }
    }
    // If no matching condition, try "default" if not already tried
    if (!conditions.includes("default") && obj.default) {
      const def = obj.default;
      if (typeof def === "string") return def;
      if (def && typeof def === "object") {
        return resolveExportsObject(def, conditions);
      }
    }
    return null;
  }

  let _origFindPath: ((...args: any[]) => any) | null = null;
  try {
    const Module = require("module");
    const nodePath = require("path");
    const capturedOrigFindPath = (Module as any)._findPath;
    if (typeof capturedOrigFindPath === "function") {
      _origFindPath = capturedOrigFindPath;
      (Module as any)._findPath = function nexeFindPath(this: any, ...args: any[]) {
        // Try original first
        let result: any;
        try {
          result = capturedOrigFindPath.apply(this, args);
        } catch (_) {
          result = false;
        }
        if (result) return result;

        const request: string = args[0];
        // Only handle bare module specifiers
        if (!request || request[0] === "." || nodePath.isAbsolute(request)) {
          return result;
        }

        // Use snapshot node_modules as the base for all bare modules
        const basePath = "/snapshot/node_modules";
        const pkgJsonPath = nodePath.posix.join(basePath, request, "package.json");
        log(`_findPath trying snapshot package.json: ${pkgJsonPath}`);
        let pkg: any;
        try {
          pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8") as string);
        } catch (e) {
          return result; // not found in snapshot
        }

        // 1. Try exports field with appropriate conditions (CJS, Node)
        if (pkg.exports) {
          const conditions = ["require", "node", "default"];
          const exportTarget = resolvePackageExports(pkg.exports, conditions);
          if (exportTarget) {
            const candidate = nodePath.posix.join(basePath, request, exportTarget);
            log(`_findPath trying exports target: ${candidate}`);
            if (isFile(candidate)) return candidate;
            // Try with extensions if the export target doesn't have one
            for (const ext of [".js", ".json", ".node"]) {
              const withExt = candidate + ext;
              if (isFile(withExt)) return withExt;
            }
          }
        }

        // 2. Fallback to main field
        let main = "index.js";
        if (typeof pkg.main === "string") {
          main = pkg.main;
        }

        // Normalize main path
        if (main.startsWith("./")) main = main.slice(2);
        if (!main || main === ".") main = "index.js";
        if (main.endsWith("/")) main += "index.js";

        const mainPath = nodePath.posix.join(basePath, request, main);
        log(`_findPath trying main: ${mainPath}`);

        // Detailed check for main
        try {
          const st = fs.statSync(mainPath);
          if (st.isFile()) return mainPath;
          if (st.isDirectory()) {
            const idxPath = nodePath.posix.join(mainPath, "index.js");
            if (isFile(idxPath)) return idxPath;
          }
        } catch (e) {
          // mainPath may not exist; proceed to extension checks
        }

        // 3. Try with extensions
        for (const ext of [".js", ".json", ".node"]) {
          const withExt = mainPath + ext;
          if (isFile(withExt)) return withExt;
        }

        // 4. Common patterns: if main is missing, look for index.js in the package root
        const fallbackIndex = nodePath.posix.join(basePath, request, "index.js");
        if (isFile(fallbackIndex)) return fallbackIndex;

        // 5. If package uses a dist subdirectory (like axios), try dist/index.js or dist/<name>.js
        const distIndex = nodePath.posix.join(basePath, request, "dist", "index.js");
        if (isFile(distIndex)) return distIndex;
        const distMain = nodePath.posix.join(basePath, request, "dist", request + ".js");
        if (isFile(distMain)) return distMain;

        return result;
      };
    }
  } catch (_) {
    // Patching _findPath failed, ignore
  }

  lazyRestoreFs = () => {
    Object.assign(fs, originalFsMethods);
    Object.assign(patches, originalPatches);
    if (_origFindPath !== null) {
      try {
        const Module = require("module");
        (Module as any)._findPath = _origFindPath;
      } catch (_) {}
      _origFindPath = null;
    }
    lazyRestoreFs = () => {};
  };
}

function restoreFs() {
  lazyRestoreFs();
}

export { shimFs, restoreFs };