import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { loadBundledPluginPublicSurfaceModuleSync } from "./facade-loader.js";

export { movePathToTrash, type MovePathToTrashOptions } from "./browser-trash.js";

type CloseTrackedBrowserTabsParams = {

sessionKeys: Array<string | undefined>;

};

let cachedBrowserMaintenanceSurface: BrowserMaintenanceSurface | undefined;

const TRASH_DESTINATION_COLLISION_CODES = new Set(["EEXIST", "ENOTEMPTY", "ERR_FS_CP_EEXIST"]);

const TRASH_DESTINATION_RETRY_LIMIT = 4;

function hasRequestedSessionKeys(sessionKeys: Array<string | undefined>): boolean {

return sessionKeys.some((key) => Boolean(key?.trim()));

return cachedBrowserMaintenanceSurface;

}

function getFsErrorCode(error: unknown): string | undefined {

if (!error || typeof error !== "object" || !("code" in error)) {

return undefined;

}

const code = (error as NodeJS.ErrnoException).code;

return typeof code === "string" ? code : undefined;

}

function isTrashDestinationCollision(error: unknown): boolean {

const code = getFsErrorCode(error);

return Boolean(code && TRASH_DESTINATION_COLLISION_CODES.has(code));

}

function isSameOrChildPath(candidate: string, parent: string): boolean {

return candidate === parent || candidate.startsWith(`${parent}${path.sep}`);

}

function resolveAllowedTrashRoots(): string[] {

const roots = [os.homedir(), os.tmpdir()].map((root) => {

try {

return path.resolve(fs.realpathSync.native(root));

} catch {

return path.resolve(root);

}

});

return [...new Set(roots)];

}

function assertAllowedTrashTarget(targetPath: string): void {

let resolvedTargetPath = path.resolve(targetPath);

try {

resolvedTargetPath = path.resolve(fs.realpathSync.native(targetPath));

} catch {

// The subsequent move will surface missing or inaccessible targets.

}

const isAllowed = resolveAllowedTrashRoots().some(

(root) => resolvedTargetPath !== root && isSameOrChildPath(resolvedTargetPath, root),

);

if (!isAllowed) {

throw new Error(`Refusing to trash path outside allowed roots: ${targetPath}`);

}

}

function resolveTrashDir(): string {

const homeDir = os.homedir();

const trashDir = path.join(homeDir, ".Trash");

fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });

const trashDirStat = fs.lstatSync(trashDir);

if (!trashDirStat.isDirectory() || trashDirStat.isSymbolicLink()) {

throw new Error(`Refusing to use non-directory/symlink trash directory: ${trashDir}`);

}

const realHome = path.resolve(fs.realpathSync.native(homeDir));

const resolvedTrashDir = path.resolve(fs.realpathSync.native(trashDir));

if (resolvedTrashDir === realHome || !isSameOrChildPath(resolvedTrashDir, realHome)) {

throw new Error(`Trash directory escaped home directory: ${trashDir}`);

}

return resolvedTrashDir;

}

function trashBaseName(targetPath: string): string {

const resolvedTargetPath = path.resolve(targetPath);

if (resolvedTargetPath === path.parse(resolvedTargetPath).root) {

throw new Error(`Refusing to trash root path: ${targetPath}`);

}

const base = path.basename(resolvedTargetPath).replace(/[\\/]+/g, "");

if (!base) {

throw new Error(`Unable to derive safe trash basename for: ${targetPath}`);

}

return base;

}

function resolveContainedPath(root: string, leaf: string): string {

const resolvedRoot = path.resolve(root);

const resolvedPath = path.resolve(resolvedRoot, leaf);

if (!isSameOrChildPath(resolvedPath, resolvedRoot) || resolvedPath === resolvedRoot) {

throw new Error(`Trash destination escaped trash directory: ${resolvedPath}`);

}

return resolvedPath;

}

function reserveTrashDestination(trashDir: string, base: string, timestamp: number): string {

const containerPrefix = resolveContainedPath(trashDir, `${base}-${timestamp}-`);

const container = fs.mkdtempSync(containerPrefix);

const resolvedContainer = path.resolve(container);

const resolvedTrashDir = path.resolve(trashDir);

if (

resolvedContainer === resolvedTrashDir ||

!isSameOrChildPath(resolvedContainer, resolvedTrashDir)

) {

throw new Error(`Trash destination escaped trash directory: ${container}`);

}

return resolveContainedPath(container, base);

}

function movePathToDestination(targetPath: string, dest: string): boolean {

try {

fs.renameSync(targetPath, dest);

return true;

} catch (error) {

if (getFsErrorCode(error) !== "EXDEV") {

if (isTrashDestinationCollision(error)) {

return false;

}

throw error;

}

}

try {

fs.cpSync(targetPath, dest, { recursive: true, force: false, errorOnExist: true });

fs.rmSync(targetPath, { recursive: true, force: false });

return true;

} catch (error) {

if (isTrashDestinationCollision(error)) {

return false;

}

throw error;

}

}

export async function closeTrackedBrowserTabsForSessions(

params: CloseTrackedBrowserTabsParams,

): Promise<number> {

}

return await surface.closeTrackedBrowserTabsForSessions(params);

}

export async function movePathToTrash(targetPath: string): Promise<string> {

// Avoid resolving external trash helpers through the service PATH during cleanup.

const base = trashBaseName(targetPath);

assertAllowedTrashTarget(targetPath);

const trashDir = resolveTrashDir();

const timestamp = Date.now();

for (let attempt = 0; attempt < TRASH_DESTINATION_RETRY_LIMIT; attempt += 1) {

const dest = reserveTrashDestination(trashDir, base, timestamp);

if (movePathToDestination(targetPath, dest)) {

return dest;

}

}

throw new Error(`Unable to choose a unique trash destination for ${targetPath}`);

}