/**
 * 请求客户端核心实现
 * 
 * 这是请求库的核心，负责协调适配器和插件系统
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "RequestClient", {
    enumerable: true,
    get: function() {
        return RequestClient;
    }
});
const _types = require("../types");
const _RequestAdapter = require("../adapter/RequestAdapter");
const _RequestPlugin = require("../plugin/RequestPlugin");
const _RequestContext = require("../runtime/RequestContext");
const _RequestQueueManager = require("../utils/RequestQueueManager");
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _getRequireWildcardCache(nodeInterop) {
    if (typeof WeakMap !== "function") return null;
    var cacheBabelInterop = new WeakMap();
    var cacheNodeInterop = new WeakMap();
    return (_getRequireWildcardCache = function(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
    })(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
    if (!nodeInterop && obj && obj.__esModule) {
        return obj;
    }
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return {
            default: obj
        };
    }
    var cache = _getRequireWildcardCache(nodeInterop);
    if (cache && cache.has(obj)) {
        return cache.get(obj);
    }
    var newObj = {
        __proto__: null
    };
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
    for(var key in obj){
        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
            if (desc && (desc.get || desc.set)) {
                Object.defineProperty(newObj, key, desc);
            } else {
                newObj[key] = obj[key];
            }
        }
    }
    newObj.default = obj;
    if (cache) {
        cache.set(obj, newObj);
    }
    return newObj;
}
/**
 * 适配器环境要求映射
 * 
 * 注意：axios 可以在浏览器和 Node.js 环境中使用，因此不在此映射中限制
 */ const ADAPTER_ENVIRONMENT_MAP = {
    fetch: 'browser',
    ky: 'browser',
    undici: 'node'
};
/**
 * 检测当前运行环境
 * 
 * @returns 运行环境类型
 */ function detectEnvironment() {
    const isBrowser = typeof window !== 'undefined';
    const isNode = typeof process !== 'undefined' && process.versions?.node;
    if (isBrowser) {
        return 'browser';
    } else if (isNode) {
        return 'node';
    }
    return 'unknown';
}
/**
 * 获取适配器的推荐替代方案
 * 
 * @param currentEnv - 当前环境
 * @returns 推荐的适配器列表
 */ function getRecommendedAdapters(currentEnv) {
    if (currentEnv === 'browser') {
        return [
            'fetch',
            'ky',
            'axios'
        ];
    } else if (currentEnv === 'node') {
        return [
            'axios',
            'undici'
        ];
    }
    return [];
}
/**
 * 创建环境不匹配错误消息
 * 
 * @param adapterName - 适配器名称
 * @param adapterEnv - 适配器要求的环境
 * @param currentEnv - 当前环境
 * @returns 错误消息
 */ function createEnvironmentMismatchError(adapterName, adapterEnv, currentEnv) {
    const recommendedAdapters = getRecommendedAdapters(currentEnv);
    const recommendedList = recommendedAdapters.length > 0 ? recommendedAdapters.map((name)=>`"${name}"`).join(' 或 ') : '其他适配器';
    const adapterEnvName = adapterEnv === 'browser' ? '浏览器' : 'Node.js';
    const currentEnvName = currentEnv === 'browser' ? '浏览器' : currentEnv === 'node' ? 'Node.js' : '未知';
    const firstRecommended = recommendedAdapters[0] || 'fetch';
    const firstRecommendedFactory = firstRecommended === 'fetch' ? 'fetchAdapter' : firstRecommended === 'ky' ? 'kyAdapter' : firstRecommended === 'axios' ? 'axiosAdapter' : 'undiciAdapter';
    let message = `\n❌ 适配器环境不匹配\n\n`;
    message += `适配器 "${adapterName}" 要求运行在 ${adapterEnvName} 环境中，\n`;
    message += `但当前运行在 ${currentEnvName} 环境中。\n\n`;
    message += `💡 建议：请使用适合当前环境的适配器，如 ${recommendedList}。\n\n`;
    message += `📝 使用示例：\n\n`;
    message += `  // 方式 1：使用适配器名称字符串\n`;
    message += `  import { createRequestClient } from '@vlian/framework/request';\n\n`;
    message += `  const client = await createRequestClient({\n`;
    message += `    defaultAdapter: '${firstRecommended}',\n`;
    message += `  });\n\n`;
    message += `  // 方式 2：使用适配器工厂函数\n`;
    message += `  import { createRequestClient, ${firstRecommendedFactory} } from '@vlian/framework/request';\n\n`;
    message += `  const client = await createRequestClient({\n`;
    message += `    defaultAdapter: ${firstRecommendedFactory},\n`;
    message += `  });\n`;
    return message;
}
/**
 * 验证适配器环境是否匹配
 * 
 * @param adapterName - 适配器名称
 * @throws 如果环境不匹配，抛出包含友好提示的错误
 */ function validateAdapterEnvironment(adapterName) {
    const adapterEnv = ADAPTER_ENVIRONMENT_MAP[adapterName];
    if (!adapterEnv) {
        // 未知适配器，不进行环境检查
        return;
    }
    const currentEnv = detectEnvironment();
    if (currentEnv === 'unknown') {
        // 无法检测环境，跳过检查
        return;
    }
    if (adapterEnv !== currentEnv) {
        const errorMessage = createEnvironmentMismatchError(adapterName, adapterEnv, currentEnv);
        throw new Error(errorMessage);
    }
}
let RequestClient = class RequestClient {
    /**
   * 获取当前适配器名称
   */ getAdapterName() {
        return this.adapterName;
    }
    /**
   * 初始化客户端
   */ async initialize() {
        // 加载默认适配器
        await this.loadAdapter();
        // 执行插件初始化钩子
        const context = (0, _RequestContext.createRequestContext)({
            url: ''
        }, {});
        await this.pluginManager.executeHook(_RequestPlugin.PluginLifecycleStage.INIT, context);
    }
    /**
   * 加载适配器
   */ async loadAdapter() {
        if (this.adapter) {
            return;
        }
        const adapterConfig = this.config.defaultAdapter;
        if (typeof adapterConfig === 'string') {
            // 检查适配器环境是否匹配
            validateAdapterEnvironment(adapterConfig);
            // 从注册表加载
            this.adapter = await _RequestAdapter.adapterRegistry.get(adapterConfig);
            this.adapterName = adapterConfig;
            // 再次验证（适配器可能返回不同的名称）
            if (this.adapter.name !== adapterConfig) {
                validateAdapterEnvironment(this.adapter.name);
            }
        } else if (typeof adapterConfig === 'function') {
            // 使用工厂函数加载
            this.adapter = await adapterConfig();
            this.adapterName = this.adapter.name;
            // 验证适配器环境
            validateAdapterEnvironment(this.adapter.name);
        } else {
            // 自动检测环境（自动检测的适配器不需要验证，因为已经根据环境选择了）
            const detectedAdapter = await this.detectAdapter();
            this.adapter = detectedAdapter.adapter;
            this.adapterName = detectedAdapter.name;
        }
    }
    /**
   * 自动检测适配器
   */ async detectAdapter() {
        // 检测运行环境
        const isBrowser = typeof window !== 'undefined';
        const isNode = typeof process !== 'undefined' && process.versions?.node;
        if (isBrowser) {
            // 浏览器环境：尝试加载 ky 适配器
            try {
                const { kyAdapter } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../adapter/kyAdapter")));
                const adapter = await kyAdapter();
                return {
                    adapter,
                    name: 'ky'
                };
            } catch  {
                // 如果 ky 不可用，使用 fetch 适配器
                const { fetchAdapter } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../adapter/fetchAdapter")));
                const adapter = await fetchAdapter();
                return {
                    adapter,
                    name: 'fetch'
                };
            }
        } else if (isNode) {
            // Node.js 环境：尝试加载 axios 适配器
            try {
                const { axiosAdapter } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../adapter/axiosAdapter")));
                const adapter = await axiosAdapter();
                return {
                    adapter,
                    name: 'axios'
                };
            } catch  {
                // 如果 axios 不可用，使用 undici 适配器
                try {
                    const { undiciAdapter } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../adapter/undiciAdapter")));
                    const adapter = await undiciAdapter();
                    return {
                        adapter,
                        name: 'undici'
                    };
                } catch  {
                    throw new Error('无法找到可用的适配器，请手动指定适配器');
                }
            }
        }
        throw new Error('无法检测运行环境');
    }
    /**
   * 设置适配器
   * 
   * @param adapter - 适配器实例或名称
   */ async setAdapter(adapter) {
        if (typeof adapter === 'string') {
            // 检查适配器环境是否匹配
            validateAdapterEnvironment(adapter);
            this.adapter = await _RequestAdapter.adapterRegistry.get(adapter);
            this.adapterName = adapter;
            // 再次验证（适配器可能返回不同的名称）
            if (this.adapter.name !== adapter) {
                validateAdapterEnvironment(this.adapter.name);
            }
        } else {
            // 验证适配器环境
            validateAdapterEnvironment(adapter.name);
            this.adapter = adapter;
            this.adapterName = adapter.name;
        }
    }
    /**
   * 注册插件
   * 
   * @param plugin - 请求插件
   */ use(plugin) {
        this.pluginManager.register(plugin);
    }
    /**
   * 注销插件
   * 
   * @param name - 插件名称
   */ unuse(name) {
        this.pluginManager.unregister(name);
    }
    /**
   * 执行请求
   * 
   * @template TResponse - 响应数据类型
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async request(options) {
        // 确保适配器已加载
        if (!this.adapter) {
            await this.loadAdapter();
        }
        if (!this.adapter) {
            throw new Error('适配器未初始化');
        }
        // 合并配置
        const mergedOptions = this.mergeOptions(options);
        // 检查队列状态，如果队列已暂停，将请求放入队列
        const queueManager = (0, _RequestQueueManager.getRequestQueueManager)();
        if (queueManager.isPaused()) {
            return queueManager.enqueue(mergedOptions, ()=>this.executeRequest(mergedOptions));
        }
        // 正常执行请求
        return this.executeRequest(mergedOptions);
    }
    /**
   * 执行实际的请求逻辑
   * 
   * @template TResponse - 响应数据类型
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async executeRequest(options) {
        // 创建请求上下文
        const context = (0, _RequestContext.createRequestContext)(options, {});
        try {
            // 执行请求前钩子
            const beforeResult = await this.pluginManager.executeHook(_RequestPlugin.PluginLifecycleStage.BEFORE_REQUEST, context);
            // 如果插件返回了修改后的请求配置，使用它
            if (beforeResult && typeof beforeResult === 'object' && 'url' in beforeResult) {
                context.request = beforeResult;
            }
            // 检查是否已取消（可能是缓存命中）
            if (context.cancelled) {
                // 如果有缓存的响应，直接返回
                if (context.response) {
                    return context.response;
                }
                throw this.createError('请求已取消', _types.RequestErrorType.ABORT_ERROR, _types.RequestErrorCode.REQUEST_ABORTED, {
                    request: context.request
                });
            }
            // 执行请求
            let response;
            try {
                if (!this.adapter) {
                    throw new Error('适配器未初始化');
                }
                response = await this.adapter.request(context.request);
            } catch (error) {
                // 适配器错误转换为框架错误
                throw this.normalizeError(error, context.request);
            }
            // 更新上下文
            (0, _RequestContext.completeRequestContext)(context, response);
            // 执行请求后钩子
            const afterResult = await this.pluginManager.executeHook(_RequestPlugin.PluginLifecycleStage.AFTER_REQUEST, context);
            // 如果插件返回了修改后的响应，使用它
            if (afterResult && typeof afterResult === 'object' && 'data' in afterResult) {
                response = afterResult;
            }
            return response;
        } catch (error) {
            // 更新上下文
            const requestError = error instanceof _types.RequestError ? error : this.normalizeError(error, context.request);
            (0, _RequestContext.failRequestContext)(context, requestError);
            // 执行错误处理钩子
            const errorHandled = await this.pluginManager.executeHook(_RequestPlugin.PluginLifecycleStage.ON_ERROR, context);
            // 如果错误未被处理，继续抛出
            if (errorHandled !== true) {
                throw requestError;
            }
            // 如果错误已被处理，返回一个默认响应（由插件决定）
            if (context.response) {
                return context.response;
            }
            throw requestError;
        } finally{
            // 执行最终钩子
            await this.pluginManager.executeHook(_RequestPlugin.PluginLifecycleStage.FINALLY, context);
        }
    }
    /**
   * GET 请求
   * 
   * @template TResponse - 响应数据类型
   * @param url - 请求 URL
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async get(url, options) {
        return this.request({
            ...options,
            url,
            method: 'GET'
        });
    }
    /**
   * POST 请求
   * 
   * @template TResponse - 响应数据类型
   * @param url - 请求 URL
   * @param body - 请求体
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async post(url, body, options) {
        return this.request({
            ...options,
            url,
            method: 'POST',
            body
        });
    }
    /**
   * PUT 请求
   * 
   * @template TResponse - 响应数据类型
   * @param url - 请求 URL
   * @param body - 请求体
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async put(url, body, options) {
        return this.request({
            ...options,
            url,
            method: 'PUT',
            body
        });
    }
    /**
   * PATCH 请求
   * 
   * @template TResponse - 响应数据类型
   * @param url - 请求 URL
   * @param body - 请求体
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async patch(url, body, options) {
        return this.request({
            ...options,
            url,
            method: 'PATCH',
            body
        });
    }
    /**
   * DELETE 请求
   * 
   * @template TResponse - 响应数据类型
   * @param url - 请求 URL
   * @param options - 请求配置选项
   * @returns Promise 解析为响应对象
   */ async delete(url, options) {
        return this.request({
            ...options,
            url,
            method: 'DELETE'
        });
    }
    /**
   * 合并请求配置
   * 
   * @param options - 请求配置选项
   * @returns 合并后的配置
   */ mergeOptions(options) {
        const baseURL = this.config.baseURL || '';
        const url = baseURL ? `${baseURL}${options.url}` : options.url;
        return {
            ...options,
            url,
            headers: {
                ...this.config.defaultHeaders,
                ...options.headers
            },
            timeout: options.timeout ?? this.config.defaultTimeout
        };
    }
    /**
   * 创建请求错误
   */ createError(message, type, code, options) {
        return new _types.RequestError(message, type, code, options);
    }
    /**
   * 标准化错误
   */ normalizeError(error, request) {
        if (error instanceof _types.RequestError) {
            return error;
        }
        // 处理 AbortError
        if (error instanceof Error && error.name === 'AbortError') {
            return this.createError('请求已取消', _types.RequestErrorType.ABORT_ERROR, _types.RequestErrorCode.REQUEST_ABORTED, {
                cause: error,
                request
            });
        }
        // 处理超时错误
        if (error instanceof Error && (error.message.includes('timeout') || error.message.includes('Timeout'))) {
            return this.createError('请求超时', _types.RequestErrorType.TIMEOUT_ERROR, _types.RequestErrorCode.REQUEST_TIMEOUT, {
                cause: error,
                request
            });
        }
        // 处理网络错误
        if (error instanceof Error && (error.message.includes('network') || error.message.includes('Network'))) {
            return this.createError('网络连接失败', _types.RequestErrorType.NETWORK_ERROR, _types.RequestErrorCode.NETWORK_CONNECTION_FAILED, {
                cause: error,
                request
            });
        }
        // 处理 HTTP 错误（需要适配器提供）
        if (error && typeof error === 'object' && 'status' in error) {
            const status = error.status;
            const isServerError = status >= 500;
            return this.createError(`HTTP ${status} 错误`, _types.RequestErrorType.HTTP_ERROR, isServerError ? _types.RequestErrorCode.SERVER_ERROR : _types.RequestErrorCode.CLIENT_ERROR, {
                status,
                cause: error,
                request
            });
        }
        // 未知错误
        return this.createError(error instanceof Error ? error.message : '未知错误', _types.RequestErrorType.UNKNOWN_ERROR, _types.RequestErrorCode.NETWORK_CONNECTION_FAILED, {
            cause: error,
            request
        });
    }
    /**
   * 销毁客户端
   */ async destroy() {
        if (this.adapter?.destroy) {
            await this.adapter.destroy();
        }
        this.pluginManager.clear();
        this.adapter = null;
        this.adapterName = null;
    }
    constructor(config = {}){
        _define_property(this, "config", void 0);
        _define_property(this, "pluginManager", void 0);
        _define_property(this, "adapter", null);
        _define_property(this, "adapterName", null);
        this.config = config;
        this.pluginManager = new _RequestPlugin.PluginManager();
        // 注册插件
        if (config.plugins) {
            for (const plugin of config.plugins){
                this.pluginManager.register(plugin);
            }
        }
    }
};

//# sourceMappingURL=RequestClient.js.map