import * as fs from "fs";

import * as path from "path";

import * as util from "util";

import { isCli, buildDir } from "./constants";

// tslint:disable:no-any

const nativeFs = (<any>global).nativeFs as typeof fs || {};

const oldAccess = fs.access;

const existsWithinBinary = (path: fs.PathLike): Promise<boolean> => {

return new Promise<boolean>((resolve): void => {

if (typeof path === "number") {

if (path < 0) {

return resolve(true);

}

}

oldAccess(path, fs.constants.F_OK, (err) => {

const exists = !err;

const es = fs.existsSync(path);

const res = !exists && es;

resolve(res);

});

});

};

export const fillFs = (): void => {

/**

* Refer to https://github.com/nexe/nexe/blob/master/src/fs/patch.ts

* For impls

*/

if (!isCli) {

throw new Error("Should not fill FS when not in CLI");

}

interface FD {

readonly path: string;

position: number;

}

let lastFd = Number.MIN_SAFE_INTEGER;

const fds = new Map<number, FD>();

const replaceNative = <T extends keyof typeof fs>(propertyName: T, func: (callOld: () => void, ...args: any[]) => any, customPromisify?: (...args: any[]) => Promise<any>): void => {

const oldFunc = (<any>fs)[propertyName];

fs[propertyName] = (...args: any[]): any => {

try {

return func(() => {

return oldFunc(...args);

}, ...args);

} catch (ex) {

return oldFunc(...args);

}

};

if (customPromisify) {

(<any>fs[propertyName])[util.promisify.custom] = (...args: any[]): any => {

return customPromisify(...args).catch((ex) => {

throw ex;

});

};

}

};

replaceNative("access", (callNative, path, mode, callback) => {

existsWithinBinary(path).then((exists) => {

if (!exists) {

return callNative();

}

return callback();

});

});

replaceNative("exists", (callOld, path, callback) => {

existsWithinBinary(path).then((exists) => {

if (exists) {

return callback(true);

}

return callOld();

});

}, (path) => new Promise((res): void => fs.exists(path, res)));

replaceNative("open", (callOld, path: fs.PathLike, flags: string | Number, mode: any, callback: any) => {

existsWithinBinary(path).then((exists) => {

if (!exists) {

return callOld();

}

if (typeof mode === "function") {

callback = mode;

mode = undefined;

}

if (path === process.execPath) {

return callOld();

}

const fd = lastFd++;

fds.set(fd, {

path: path.toString(),

position: 0,

});

callback(undefined, fd);

});

});

replaceNative("close", (callOld, fd: number, callback) => {

if (!fds.has(fd)) {

return callOld();

}

fds.delete(fd);

callback();

});

replaceNative("read", (callOld, fd: number, buffer: Buffer, offset: number, length: number, position: number | null, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void) => {

if (!fds.has(fd)) {

return callOld();

}

const fileDesc = fds.get(fd)!;

return fs.readFile(fileDesc.path, (err, rb) => {

if (err) {

return callOld();

}

rb = rb.slice(position || fileDesc.position);

const sliced = rb.slice(0, length);

if (position === null) {

fileDesc.position += sliced.byteLength;

}

buffer.set(sliced, offset);

if (callback) {

callback(undefined!, sliced.byteLength, buffer);

}

});

}, (fd: number, buffer: Buffer, offset: number, length: number, position: number | null): Promise<{

bytesRead: number;

buffer: Buffer;

}> => {

return new Promise((res, rej): void => {

fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {

if (err) {

return rej(err);

}

res({

bytesRead,

buffer,

});

});

});

});

replaceNative("readdir", (callOld, directory: string, callback: (err: NodeJS.ErrnoException, paths: string[]) => void) => {

const relative = path.relative(directory, buildDir!);

if (relative.startsWith("..")) {

return callOld();

}

return nativeFs.readdir(directory, callback);

});

const fillNativeFunc = <T extends keyof typeof fs>(propertyName: T): void => {

replaceNative(propertyName, (callOld, newPath, ...args) => {

if (typeof newPath !== "string") {

return callOld();

}

const rel = path.relative(newPath, buildDir!);

if (rel.startsWith("..")) {

return callOld();

}

const func = nativeFs[propertyName] as any;

return func(newPath, ...args);

});

};

const properties: Array<keyof typeof fs> = [

"existsSync",

"readFile",

"readFileSync",

"createReadStream",

"readdir",

"readdirSync",

"statSync",

"stat",

"realpath",

"realpathSync",

];

properties.forEach((p) => fillNativeFunc(p));

};