/**
 * 请求队列插件
 * 
 * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，
 * 执行回调方法，等待回调完成后继续执行队列中的请求
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "createQueuePlugin", {
    enumerable: true,
    get: function() {
        return createQueuePlugin;
    }
});
const _RequestPlugin = require("./RequestPlugin");
const _RequestQueueManager = require("../utils/RequestQueueManager");
/**
 * 检查响应是否匹配触发条件
 */ function matchesTrigger(response, context, trigger) {
    // 检查自定义检查函数
    if (trigger.check) {
        return trigger.check(response, context);
    }
    // 检查响应数据中的 code 字段
    if (trigger.code !== undefined) {
        const responseData = response.data;
        if (responseData && typeof responseData === 'object' && 'code' in responseData) {
            const code = responseData.code;
            if (typeof trigger.code === 'function') {
                if (trigger.code(code)) {
                    return true;
                }
            } else if (code === trigger.code) {
                return true;
            }
        }
    }
    // 检查 HTTP 状态码
    if (trigger.status !== undefined) {
        const status = response.status;
        if (typeof trigger.status === 'function') {
            if (trigger.status(status)) {
                return true;
            }
        } else if (Array.isArray(trigger.status)) {
            if (trigger.status.includes(status)) {
                return true;
            }
        } else if (status === trigger.status) {
            return true;
        }
    }
    return false;
}
/**
 * 检查响应是否匹配任一触发条件
 */ function matchesAnyTrigger(response, context, triggers) {
    return triggers.some((trigger)=>matchesTrigger(response, context, trigger));
}
function createQueuePlugin(config = {}) {
    const { triggers = [], onTrigger, enabled = true, checkOnError = true, queueTimeout = 30000 } = config;
    if (triggers.length === 0) {
        // 如果没有配置触发条件，返回一个空插件
        return {
            name: 'queue',
            priority: _RequestPlugin.PluginPriority.HIGH,
            onBeforeRequest: undefined,
            onAfterRequest: undefined,
            onError: undefined
        };
    }
    const queueManager = (0, _RequestQueueManager.getRequestQueueManager)();
    return {
        name: 'queue',
        priority: _RequestPlugin.PluginPriority.HIGH,
        async onAfterRequest (context) {
            if (!enabled || !context.response) {
                return;
            }
            // 检查是否匹配触发条件
            const matched = matchesAnyTrigger(context.response, context, triggers);
            if (matched && onTrigger) {
                // 暂停队列（后续请求会被 RequestClient 自动放入队列）
                queueManager.pause();
                // 设置队列超时
                const timeoutId = setTimeout(()=>{
                    queueManager.clear('队列超时');
                }, queueTimeout);
                try {
                    // 执行回调并等待完成，然后恢复队列
                    await queueManager.processAndResume(async ()=>{
                        await onTrigger(context.response, context);
                    });
                } catch (error) {
                    // 回调执行失败，清空队列
                    queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
                // 不抛出错误，让请求正常返回（但队列已被清空）
                } finally{
                    clearTimeout(timeoutId);
                }
            }
        },
        async onError (context) {
            if (!enabled || !checkOnError || !context.error) {
                return;
            }
            // 如果有响应，检查是否匹配触发条件
            if (context.response) {
                const matched = matchesAnyTrigger(context.response, context, triggers);
                if (matched && onTrigger) {
                    // 暂停队列（后续请求会被 RequestClient 自动放入队列）
                    queueManager.pause();
                    // 设置队列超时
                    const timeoutId = setTimeout(()=>{
                        queueManager.clear('队列超时');
                    }, queueTimeout);
                    try {
                        // 执行回调并等待完成，然后恢复队列
                        await queueManager.processAndResume(async ()=>{
                            await onTrigger(context.response, context);
                        });
                        // 错误已被处理，返回 true 阻止错误传播
                        return true;
                    } catch (error) {
                        // 回调执行失败，清空队列
                        queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
                        // 不处理错误，继续传播
                        return false;
                    } finally{
                        clearTimeout(timeoutId);
                    }
                }
            }
            return false;
        }
    };
}

//# sourceMappingURL=queue.js.map