import { WatcherProxy, WebsocketPayload } from "../interfaces";
import { Observable, of, interval, Subject } from "rxjs";
import { map, takeUntil } from "rxjs/operators";
export class MockWatcherProxy implements WatcherProxy {

    private obsMap = new Map();

    watch(transactionId: string, address: string, network: string, nbConf: number, from?: string, amount?: number): Observable<WebsocketPayload> {
        const takeUntilObs = new Subject();
        const obs = interval(2000).pipe(
            map((count) => {
                return {
                    blockDate: new Date(),
                    addresses: [
                        {
                            address: address,
                            amount: amount,
                            onlyReqConf: false,
                            requiredConf: nbConf,
                        }
                    ],
                    blockNumber: String(count),
                    messageID: transactionId,
                    nbConf: count,
                    txHash: 'test',
                    timestamp: Date.now(),
                    network,
                    addressFrom: from!,
                } as WebsocketPayload
            }),
            takeUntil(takeUntilObs),
        )
        this.obsMap.set(`${transactionId}:${address}:${network}:${nbConf}`, takeUntilObs);
        return obs;
    }

    unwatch(transactionId: string, address: string, network: string, nbConf: number): Observable<void> {
        const takeUntilObs = this.obsMap.get(`${transactionId}:${address}:${network}:${nbConf}`)
        if (takeUntilObs) {
            takeUntilObs.next();
        }
        return of();
    }


}