import { Mutex, type MutexInterface } from "async-mutex";

export async function wrapAsyncInCatch(a: PromiseLike<any>) {
    try {
        await a;
    } catch (e) {
        console.log("Error in async process: " + e);
    }
}

export function withTimeout<T>(promise: Promise<T>, timeoutMs: number, reason = "timed out"): Promise<T> {
    let timer: ReturnType<typeof setTimeout>;
    return Promise.race([
        promise,
        new Promise<T>((_, rej) =>
            timer = setTimeout(rej, timeoutMs, reason))
    ]).finally(() => clearTimeout(timer));
}

export type DID = `did:${string}:${string}`;

export class NamedMutex {
    private muMap = new Map<string, Mutex>();

    private getOrCreate(key: string): Mutex {
        let v = this.muMap.get(key);
        if (!v) {
            v = new Mutex();
            this.muMap.set(key, v);
        }
        return v;
    }

    async acquire(key: string, priority?: number): Promise<MutexInterface.Releaser> {
        const releaser = await this.getOrCreate(key).acquire(priority);
        this.muMap.delete(key);
        return releaser;
    };
    async runExclusive<T>(key: string, callback: MutexInterface.Worker<T>, priority?: number): Promise<T> {
        const result = await this.getOrCreate(key).runExclusive(callback, priority);
        this.muMap.delete(key);
        return result;
    };
    isLocked(key: string): boolean {
        let v = this.muMap.get(key);
        if (!v) {
            return false;
        }
        return v.isLocked();
    };
    async waitForUnlock(key: string, priority?: number): Promise<void> {
        let v = this.muMap.get(key);
        if (!v) {
            return;
        }
        return await v.waitForUnlock(priority);
    };
    release(key: string): void {
        return this.getOrCreate(key).release();
    };
    cancel(key: string): void {
        return this.getOrCreate(key).cancel();
    };
}