"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createNodeRedisClient = createNodeRedisClient;
const tslib_1 = require("tslib");
const crypto_1 = require("crypto");
const events_1 = require("events");
const stream_1 = require("stream");
const connection_closed_error_1 = require("./errors/connection-closed-error");
function normalizeScriptArgs(args) {
    return args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
}
function isConnectionClosedError(err) {
    return ((err === null || err === void 0 ? void 0 : err.message) === 'Disconnects client' ||
        (err === null || err === void 0 ? void 0 : err.message) === 'The client is closed' ||
        (err === null || err === void 0 ? void 0 : err.message) === 'Connection is closed.');
}
function createNodeRedisClient(client) {
    return new NodeRedisAdapter(client);
}
/**
 * Full wrapper (not augmentation) because node-redis's API is structurally
 * different from ioredis and cannot be patched in-place.
 */
class NodeRedisAdapter extends events_1.EventEmitter {
    /**
     * Expose connection status using the vocabulary that
     * {@link RedisConnection.waitUntilReady} expects:
     *   'wait'  → not yet connected, call connect()
     *   'ready' → usable
     *   'end'   → permanently closed
     */
    get status() {
        if (this.statusOverride) {
            return this.statusOverride;
        }
        if (this.raw.isReady) {
            return 'ready';
        }
        if (this.raw.isOpen) {
            return 'connect';
        }
        // Distinguish "never connected" from "disconnected after use"
        return this.hasConnected ? 'end' : 'wait';
    }
    set status(val) {
        // Allow RedisConnection to forcibly set 'end'
        if (val === 'end') {
            this.destroying = true;
            if (this.raw.isOpen) {
                try {
                    this.raw.quit().catch(() => { });
                }
                catch (_a) {
                    // already closed
                }
            }
        }
        this.statusOverride = val;
    }
    get options() {
        var _a;
        return (_a = this.raw.options) !== null && _a !== void 0 ? _a : {};
    }
    set options(val) {
        // no-op – callers sometimes assign
    }
    constructor(raw) {
        super();
        this.raw = raw;
        this.scripts = new Map();
        this.hasConnected = false;
        this.destroying = false;
        this.isCluster = false; // TODO: cluster support
        // Track first connection so status can distinguish 'wait' vs 'end'.
        // When a connectionName is set (via duplicate()), delay the 'ready'
        // event until CLIENT SETNAME completes so that callers waiting for
        // 'ready' (e.g. RedisConnection.waitUntilReady) see the name already
        // applied.
        raw.on('ready', () => {
            this.hasConnected = true;
            if (this.connectionName) {
                this.raw.clientSetName(this.connectionName).then(() => this.emit('ready'), () => this.emit('ready'));
            }
            else {
                this.emit('ready');
            }
        });
        raw.on('error', (err) => {
            // Suppress the expected DisconnectsClientError that node-redis emits
            // when destroy() is called intentionally (e.g. during close/disconnect).
            if (this.destroying && isConnectionClosedError(err)) {
                return;
            }
            this.emit('error', err);
        });
        raw.on('end', () => this.emit('close'));
        raw.on('reconnecting', () => this.emit('reconnecting'));
        // Auto-connect eagerly, like ioredis does in its constructor.
        // This ensures commands can be issued immediately without an
        // explicit connect() call. The promise is stored so that
        // connect() is idempotent and callers can still await it.
        if (!raw.isOpen) {
            this.connectPromise = raw.connect().then(() => {
                this.connectPromise = undefined;
            }, (err) => {
                this.connectPromise = undefined;
                // Don't throw — errors surface via the 'error' event.
            });
        }
    }
    // ---------------------------------------------------------------
    // Connection lifecycle
    // ---------------------------------------------------------------
    async connect() {
        if (this.connectPromise) {
            return this.connectPromise;
        }
        if (!this.raw.isOpen) {
            this.connectPromise = this.raw.connect().then(() => {
                this.connectPromise = undefined;
            }, (err) => {
                this.connectPromise = undefined;
                throw err;
            });
            return this.connectPromise;
        }
        if (!this.raw.isReady) {
            await new Promise((resolve, reject) => {
                const onReady = () => {
                    cleanup();
                    resolve();
                };
                const onError = (err) => {
                    cleanup();
                    reject(err);
                };
                const onEnd = () => {
                    cleanup();
                    reject(new Error('Connection ended before ready event'));
                };
                const cleanup = () => {
                    this.off('ready', onReady);
                    this.off('error', onError);
                    this.off('end', onEnd);
                };
                this.once('ready', onReady);
                this.once('error', onError);
                this.once('end', onEnd);
            });
        }
    }
    disconnect(reconnect = false) {
        this.destroying = true;
        if (!reconnect) {
            this.statusOverride = 'end';
        }
        try {
            if (this.raw.isOpen) {
                // Use destroy() for immediate teardown. This interrupts any pending
                // blocking commands (e.g. BZPOPMIN) without waiting for them to
                // complete. The resulting "Disconnects client" rejections are handled
                // by BullMQ's isNotConnectionError() checks.
                this.raw.destroy();
            }
        }
        catch (_a) {
            // Swallow errors from already-closed connections
        }
        this.emit('close');
        if (reconnect) {
            this.statusOverride = undefined;
            this.emit('reconnecting');
            this.connect()
                .catch(err => {
                if (!isConnectionClosedError(err)) {
                    this.emit('error', err);
                }
            })
                .finally(() => {
                this.destroying = false;
            });
        }
        else {
            // Emit both 'close' and 'end' so that all listeners are unblocked.
            // RedisConnection.close() listens for 'close', RedisConnection.disconnect() listens for 'end'.
            this.emit('end');
        }
    }
    async quit() {
        if (this.destroying || this.statusOverride === 'end') {
            setImmediate(() => {
                this.emit('end');
                this.emit('close');
            });
            return 'OK';
        }
        this.destroying = true;
        try {
            if (this.raw.isOpen) {
                try {
                    await this.raw.quit();
                }
                catch (_a) {
                    // Swallow errors from already-closing connections
                }
            }
        }
        catch (_b) {
            // Swallow errors from already-closing connections
        }
        this.statusOverride = 'end';
        // Emit on next tick so callers can register listeners after await quit()
        setImmediate(() => {
            this.emit('end');
            this.emit('close');
        });
        return 'OK';
    }
    duplicate(...args) {
        const dup = this.raw.duplicate();
        const adapter = new NodeRedisAdapter(dup);
        // Copy registered scripts to the duplicate
        for (const [name, script] of this.scripts) {
            adapter.scripts.set(name, script);
            adapter[name] = (...args) => adapter.runCommand(name, args);
        }
        // Handle connectionName option (ioredis calls CLIENT SETNAME automatically).
        // Setting connectionName BEFORE auto-connect resolves ensures the
        // constructor's 'ready' handler applies CLIENT SETNAME before emitting
        // 'ready', so callers (like RedisConnection.waitUntilReady) see the name
        // already set when the connection is reported as ready.
        const opts = args[0];
        if (opts && typeof opts === 'object' && opts.connectionName) {
            adapter.connectionName = opts.connectionName;
        }
        return adapter;
    }
    // ---------------------------------------------------------------
    // Lua script engine
    // ---------------------------------------------------------------
    defineCommand(name, definition) {
        const sha = (0, crypto_1.createHash)('sha1').update(definition.lua).digest('hex');
        this.scripts.set(name, {
            sha,
            lua: definition.lua,
            numberOfKeys: definition.numberOfKeys,
        });
        // Mimic ioredis behavior: add a callable property on the instance
        // so that `(client as any)[name]` is defined (used by ScriptLoader cache check)
        this[name] = (...args) => this.runCommand(name, args);
        // Pre-load the script into Redis so that EVALSHA in transactions works
        // immediately. This mirrors what ioredis does under the hood.
        this.raw.scriptLoad(definition.lua).catch(() => {
            // Ignore errors here – runCommand has NOSCRIPT fallback for non-tx path
        });
    }
    async runCommand(name, args) {
        var _a, _b;
        const script = this.scripts.get(name);
        if (!script) {
            throw new Error(`BullMQ: unknown command "${name}"`);
        }
        const commandArgs = normalizeScriptArgs(args);
        const { sha, lua, numberOfKeys } = script;
        const keys = commandArgs.slice(0, numberOfKeys).map(String);
        // Preserve Buffer arguments (e.g. msgpack data) – only stringify non-Buffers.
        // Convert undefined/null to '' to match ioredis behavior (keeps arg positions).
        const argv = commandArgs.slice(numberOfKeys).map((a) => {
            if (Buffer.isBuffer(a)) {
                return a;
            }
            if (a === undefined || a === null) {
                return '';
            }
            return String(a);
        });
        try {
            return await this.raw.evalSha(sha, { keys, arguments: argv });
        }
        catch (err) {
            if (this.destroying && isConnectionClosedError(err)) {
                return null;
            }
            if (isConnectionClosedError(err)) {
                throw new connection_closed_error_1.ConnectionClosedError(err.message, err);
            }
            // NOSCRIPT – fall back to EVAL which also caches the script
            if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, 'NOSCRIPT')) {
                try {
                    return await this.raw.eval(lua, { keys, arguments: argv });
                }
                catch (evalErr) {
                    if (this.destroying && isConnectionClosedError(evalErr)) {
                        return null;
                    }
                    if (isConnectionClosedError(evalErr)) {
                        throw new connection_closed_error_1.ConnectionClosedError(evalErr.message, evalErr);
                    }
                    throw evalErr;
                }
            }
            throw err;
        }
    }
    // ---------------------------------------------------------------
    // Pipeline / Transaction
    // ---------------------------------------------------------------
    multi() {
        return new NodeRedisTransaction(this.raw.multi(), this.scripts);
    }
    pipeline() {
        // node-redis doesn't have a separate pipeline concept;
        // use multi() which behaves similarly for batching.
        return this.multi();
    }
    // ---------------------------------------------------------------
    // Hash commands
    // ---------------------------------------------------------------
    async hgetall(key) {
        const result = await this.raw.hGetAll(key);
        return result !== null && result !== void 0 ? result : {};
    }
    async hget(key, field) {
        var _a;
        return (_a = (await this.raw.hGet(key, field))) !== null && _a !== void 0 ? _a : null;
    }
    async hmget(key, ...fields) {
        const result = await this.raw.hmGet(key, fields);
        return result.map((v) => v !== null && v !== void 0 ? v : null);
    }
    async hset(key, dataOrField, ...rest) {
        if (typeof dataOrField === 'object') {
            // Record-based call: hset(key, { field: value, ... })
            return await this.raw.hSet(key, dataOrField);
        }
        // Varargs call (ioredis compat): hset(key, field, value, field, value, ...)
        const record = {};
        record[dataOrField] = String(rest[0]);
        for (let i = 1; i < rest.length; i += 2) {
            record[String(rest[i])] = String(rest[i + 1]);
        }
        return await this.raw.hSet(key, record);
    }
    async hdel(key, ...fields) {
        return await this.raw.hDel(key, fields);
    }
    async hexists(key, field) {
        const exists = await this.raw.hExists(key, field);
        return exists ? 1 : 0;
    }
    // ---------------------------------------------------------------
    // String commands
    // ---------------------------------------------------------------
    async get(key) {
        var _a;
        return (_a = (await this.raw.get(key))) !== null && _a !== void 0 ? _a : null;
    }
    async set(key, value, options) {
        const opts = {};
        if ((options === null || options === void 0 ? void 0 : options.PX) != null) {
            opts.PX = options.PX;
        }
        else if ((options === null || options === void 0 ? void 0 : options.EX) != null) {
            opts.EX = options.EX;
        }
        return await this.raw.set(key, String(value), opts);
    }
    async del(...keys) {
        if (keys.length === 0) {
            return 0;
        }
        return await this.raw.del(keys);
    }
    // ---------------------------------------------------------------
    // Sorted set commands
    // ---------------------------------------------------------------
    async zrange(key, start, end, options) {
        if (options === null || options === void 0 ? void 0 : options.WITHSCORES) {
            // node-redis v5 uses a separate method for WITHSCORES
            const items = await this.raw.zRangeWithScores(key, start, end);
            // Flatten to [member, score, member, score, …] like ioredis
            const flat = [];
            for (const item of items) {
                flat.push(item.value, String(item.score));
            }
            return flat;
        }
        return await this.raw.zRange(key, start, end);
    }
    async zrevrange(key, start, end, options) {
        if (options === null || options === void 0 ? void 0 : options.WITHSCORES) {
            const items = await this.raw.zRangeWithScores(key, start, end, {
                REV: true,
            });
            const flat = [];
            for (const item of items) {
                flat.push(item.value, String(item.score));
            }
            return flat;
        }
        return await this.raw.zRange(key, start, end, { REV: true });
    }
    async zcard(key) {
        return await this.raw.zCard(key);
    }
    async zscore(key, member) {
        const score = await this.raw.zScore(key, member);
        return score != null ? String(score) : null;
    }
    // ---------------------------------------------------------------
    // List commands
    // ---------------------------------------------------------------
    async lrange(key, start, end) {
        return await this.raw.lRange(key, start, end);
    }
    async llen(key) {
        return await this.raw.lLen(key);
    }
    async ltrim(key, start, end) {
        await this.raw.lTrim(key, start, end);
        return 'OK';
    }
    async lpos(key, value) {
        var _a;
        return (_a = (await this.raw.lPos(key, value))) !== null && _a !== void 0 ? _a : null;
    }
    // ---------------------------------------------------------------
    // Set commands
    // ---------------------------------------------------------------
    async smembers(key) {
        return await this.raw.sMembers(key);
    }
    // ---------------------------------------------------------------
    // Stream commands
    // ---------------------------------------------------------------
    async xadd(key, id, fields, options) {
        const opts = {};
        if ((options === null || options === void 0 ? void 0 : options.MAXLEN) != null) {
            opts.TRIM = {
                strategy: 'MAXLEN',
                threshold: options.MAXLEN,
                strategyModifier: options.approximate === false ? undefined : '~',
            };
        }
        // node-redis xAdd rejects numeric field values — stringify all values
        const strFields = {};
        for (const [k, v] of Object.entries(fields)) {
            strFields[k] = String(v);
        }
        return await this.raw.xAdd(key, id, strFields, opts);
    }
    async xread(streams, options) {
        const opts = {};
        if ((options === null || options === void 0 ? void 0 : options.BLOCK) != null) {
            opts.BLOCK = options.BLOCK;
        }
        if ((options === null || options === void 0 ? void 0 : options.COUNT) != null) {
            opts.COUNT = options.COUNT;
        }
        const streamArgs = streams.map(s => ({ key: s.key, id: s.id }));
        let result;
        try {
            result = await this.raw.xRead(streamArgs, opts);
        }
        catch (err) {
            if (this.destroying && isConnectionClosedError(err)) {
                return null;
            }
            if (isConnectionClosedError(err)) {
                throw new connection_closed_error_1.ConnectionClosedError(err.message, err);
            }
            throw err;
        }
        if (!result) {
            return null;
        }
        // Normalize to ioredis format: [[streamName, [[id, [field, value, …]], …]], …]
        return result.map((stream) => [
            stream.name,
            stream.messages.map((msg) => [
                msg.id,
                Object.entries(msg.message).flat(),
            ]),
        ]);
    }
    async xtrim(key, strategy, threshold, options) {
        const strategyModifier = (options === null || options === void 0 ? void 0 : options.approximate) === false ? undefined : '~';
        return await this.raw.xTrim(key, strategy, threshold, {
            strategyModifier,
        });
    }
    // ---------------------------------------------------------------
    // Blocking commands
    // ---------------------------------------------------------------
    async bzpopmin(key, timeout) {
        let result;
        try {
            result = await this.raw.bzPopMin(key, timeout);
        }
        catch (err) {
            if (this.destroying && isConnectionClosedError(err)) {
                return null;
            }
            if (isConnectionClosedError(err)) {
                throw new connection_closed_error_1.ConnectionClosedError(err.message, err);
            }
            throw err;
        }
        if (!result) {
            return null;
        }
        return [result.key, result.value, String(result.score)];
    }
    // ---------------------------------------------------------------
    // Server / admin commands
    // ---------------------------------------------------------------
    async info() {
        return await this.raw.info();
    }
    async clientSetName(name) {
        return await this.raw.clientSetName(name);
    }
    async clientList() {
        return await this.raw.sendCommand(['CLIENT', 'LIST']);
    }
    // ---------------------------------------------------------------
    // Key scanning
    // ---------------------------------------------------------------
    async scan(cursor, options) {
        const opts = {};
        if (options === null || options === void 0 ? void 0 : options.MATCH) {
            opts.MATCH = options.MATCH;
        }
        if (options === null || options === void 0 ? void 0 : options.COUNT) {
            opts.COUNT = options.COUNT;
        }
        const result = await this.raw.scan(String(cursor), opts);
        return [String(result.cursor), result.keys];
    }
    scanStream(options) {
        const raw = this.raw;
        const connectPromise = this.connectPromise;
        const scanOpts = {};
        if (options.match) {
            scanOpts.MATCH = options.match;
        }
        if (options.count) {
            scanOpts.COUNT = options.count;
        }
        const readable = new stream_1.Readable({
            objectMode: true,
            async read() {
                var _a, e_1, _b, _c;
                try {
                    if (connectPromise) {
                        await connectPromise;
                    }
                    try {
                        for (var _d = true, _e = tslib_1.__asyncValues(raw.scanIterator(scanOpts)), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
                            _c = _f.value;
                            _d = false;
                            const keys = _c;
                            if (!readable.push(Array.isArray(keys) ? keys : [keys])) {
                                return; // backpressure
                            }
                        }
                    }
                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
                    finally {
                        try {
                            if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
                        }
                        finally { if (e_1) throw e_1.error; }
                    }
                    readable.push(null); // EOF
                }
                catch (err) {
                    readable.destroy(err);
                }
            },
        });
        return readable;
    }
    // ---------------------------------------------------------------
    // Extra Redis commands (not part of IRedisClient but used by tests
    // and occasionally by user code that accesses the raw client).
    // ---------------------------------------------------------------
    async keys(pattern) {
        return await this.raw.keys(pattern);
    }
    async exists(...keys) {
        if (keys.length === 0) {
            return 0;
        }
        return await this.raw.exists(keys);
    }
    async zadd(key, ...args) {
        // ioredis: zadd(key, score, member, score, member, ...)
        const members = [];
        for (let i = 0; i < args.length; i += 2) {
            members.push({ score: Number(args[i]), value: String(args[i + 1]) });
        }
        return await this.raw.zAdd(key, members);
    }
    async zrem(key, ...members) {
        return await this.raw.zRem(key, members);
    }
    async xlen(key) {
        return await this.raw.xLen(key);
    }
    async xrevrange(key, end, start, ...rest) {
        const opts = {};
        // ioredis: xrevrange(key, end, start, 'COUNT', n)
        if (rest[0] === 'COUNT') {
            opts.COUNT = Number(rest[1]);
        }
        const result = await this.raw.xRevRange(key, end, start, opts);
        // Normalize to ioredis format: [[id, [field, value, …]], …]
        return result.map((msg) => [
            msg.id,
            Object.entries(msg.message).flat(),
        ]);
    }
    async sadd(key, ...members) {
        return await this.raw.sAdd(key, members.map(String));
    }
    async scard(key) {
        return await this.raw.sCard(key);
    }
    async lpush(key, ...values) {
        return await this.raw.lPush(key, values);
    }
    async rpop(key) {
        return await this.raw.rPop(key);
    }
    async incr(key) {
        return await this.raw.incr(key);
    }
    async incrby(key, increment) {
        return await this.raw.incrBy(key, increment);
    }
    async flushall() {
        return await this.raw.flushAll();
    }
}
// ---------------------------------------------------------------------------
// Transaction / Pipeline wrapper
// ---------------------------------------------------------------------------
class NodeRedisTransaction {
    constructor(raw, scripts) {
        this.raw = raw;
        this.scripts = scripts;
        this.transformers = [];
    }
    addIdentityTransformer() {
        this.transformers.push((v) => v);
    }
    hgetall(key) {
        this.raw.hGetAll(key);
        this.addIdentityTransformer();
        return this;
    }
    hset(key, data) {
        this.raw.hSet(key, data);
        this.addIdentityTransformer();
        return this;
    }
    hscan(key, cursor, options) {
        const opts = {};
        if ((options === null || options === void 0 ? void 0 : options.COUNT) != null) {
            opts.COUNT = options.COUNT;
        }
        this.raw.hScan(key, String(cursor), opts);
        // Transform node-redis { cursor, entries: [{field, value}] }
        // to ioredis [cursor, [field, value, field, value, ...]]
        this.transformers.push((val) => {
            if (!val) {
                return ['0', []];
            }
            const flat = [];
            for (const entry of val.entries || []) {
                flat.push(entry.field, entry.value);
            }
            return [String(val.cursor), flat];
        });
        return this;
    }
    smembers(key) {
        this.raw.sMembers(key);
        this.addIdentityTransformer();
        return this;
    }
    sscan(key, cursor, options) {
        const opts = {};
        if ((options === null || options === void 0 ? void 0 : options.COUNT) != null) {
            opts.COUNT = options.COUNT;
        }
        this.raw.sScan(key, String(cursor), opts);
        // Transform node-redis { cursor, members: [...] }
        // to ioredis [cursor, [member, member, ...]]
        this.transformers.push((val) => {
            if (!val) {
                return ['0', []];
            }
            return [String(val.cursor), val.members || []];
        });
        return this;
    }
    zrange(key, start, end) {
        this.raw.zRange(key, start, end);
        this.addIdentityTransformer();
        return this;
    }
    lrange(key, start, end) {
        this.raw.lRange(key, start, end);
        this.addIdentityTransformer();
        return this;
    }
    llen(key) {
        this.raw.lLen(key);
        this.addIdentityTransformer();
        return this;
    }
    del(...keys) {
        if (keys.length > 0) {
            this.raw.del(keys);
            this.addIdentityTransformer();
        }
        return this;
    }
    runCommand(name, args) {
        const script = this.scripts.get(name);
        if (!script) {
            throw new Error(`BullMQ: unknown command "${name}" in transaction`);
        }
        const commandArgs = normalizeScriptArgs(args);
        const { sha, lua, numberOfKeys } = script;
        const cmdKeys = commandArgs.slice(0, numberOfKeys).map(String);
        const argv = commandArgs.slice(numberOfKeys).map((a) => {
            if (Buffer.isBuffer(a)) {
                return a;
            }
            if (a === undefined || a === null) {
                return '';
            }
            return String(a);
        });
        // Use evalSha in pipeline; NOSCRIPT handling happens at exec()-time
        // node-redis multi supports evalSha
        this.raw.evalSha(sha, { keys: cmdKeys, arguments: argv });
        this.addIdentityTransformer();
        return this;
    }
    async exec() {
        const results = await this.raw.exec();
        if (!results) {
            return null;
        }
        // node-redis multi.exec() returns values directly (or throws on error).
        // Normalize to ioredis format: [Error | null, value][]
        // Apply per-command transformers for format differences (hscan, sscan).
        return results.map((result, i) => {
            if (result instanceof Error) {
                return [result, null];
            }
            const transformer = this.transformers[i];
            const value = transformer ? transformer(result) : result;
            return [null, value];
        });
    }
}