import fs, {promises as afs} from "fs";
import path from "path";

export async function sleep(ms: number): Promise<void> {
    return await new Promise(resolve => {
        setTimeout(() => resolve(), ms);
    });
}

export abstract class WrappingError extends Error {
    public readonly cause?: Error;

    protected constructor(message: string, cause?: Error) {
        super(message);
        this.cause = cause;

        if (cause !== undefined) {
            this.stack = (this.stack || '') + `\n> Caused by: ${cause.stack}`;
        }
    }

    public get name(): string {
        return this.constructor.name;
    }
}

export type Type<T> = { new(...args: never[]): T };

export function bufferToUuid(buffer: Buffer): string {
    const chars = buffer.toString('hex');
    let out = '';
    let i = 0;
    for (const l of [8, 4, 4, 4, 12]) {
        if (i > 0) out += '-';
        out += chars.substr(i, l);
        i += l;
    }
    return out;
}

export function getMethods<T extends { [p: string]: unknown }>(obj: T): string[] {
    const properties = new Set<string>();
    let currentObj: T | unknown = obj;
    do {
        Object.getOwnPropertyNames(currentObj).map(item => properties.add(item));
        currentObj = Object.getPrototypeOf(currentObj);
    } while (currentObj);
    return [...properties.keys()].filter(item => typeof obj[item] === 'function');
}

export async function listFilesRecursively(dir: string): Promise<string[]> {
    const localFiles = await afs.readdir(dir);
    const files: string[] = [];
    for (const file of localFiles.map(file => path.join(dir, file))) {
        const stat = await afs.stat(file);

        if (stat.isDirectory()) {
            files.push(...await listFilesRecursively(file));
        } else {
            files.push(file);
        }
    }
    return files;
}


export async function doesFileExist(file: string): Promise<boolean> {
    return await new Promise<boolean>((resolve, reject) => {
        fs.stat(file, err => {
            if (err) {
                if (err.code === 'ENOENT') {
                    return resolve(false);
                } else {
                    return reject(err);
                }
            } else {
                return resolve(true);
            }
        });
    });
}