/**
 * HTTP客户端
 * 用于与后端API进行通信
 */
/**
 * HTTP错误类型
 */
export class HttpError extends Error {
    /**
     * 构造函数
     * @param message 错误信息
     * @param status 状态码
     * @param statusText 状态文本
     * @param data 错误数据
     */
    constructor(message, status, statusText, data) {
        super(message);
        this.name = 'HttpError';
        this.status = status;
        this.statusText = statusText;
        this.data = data;
    }
}
/**
 * HTTP客户端类
 */
export class HttpClient {
    /**
     * 构造函数
     * @param logout
     * @param tokenGetter Token获取函数
     */
    constructor(tokenGetter) {
        this.tokenGetter = tokenGetter;
    }
    /**
     * 设置Token获取函数
     * @param tokenGetter Token获取函数
     */
    setTokenGetter(tokenGetter) {
        this.tokenGetter = tokenGetter;
    }
    /**
     * 设置租户ID
     * @param tenantId 租户ID
     */
    setTenantId(tenantId) {
        this.tenantId = tenantId;
    }
    /**
     * 发送HTTP请求
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async request(options) {
        const { method, url, headers = {}, body, needAuth = true } = options;
        // 构建请求头
        const requestHeaders = {
            'Content-Type': 'application/json',
            ...headers
        };
        // 添加认证头
        const addAuthHeader = () => {
            if (needAuth && this.tokenGetter) {
                const token = this.tokenGetter();
                if (token) {
                    requestHeaders.Authorization = `${token}`;
                }
            }
        };
        // 添加租户ID头
        if (this.tenantId) {
            requestHeaders['tenant-id'] = this.tenantId;
        }
        addAuthHeader();
        // 构建请求配置
        const fetchOptions = {
            method,
            headers: requestHeaders,
            credentials: 'include' // 包含cookie
        };
        // 添加请求体
        if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
            fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
        }
        try {
            // 发送请求
            const response = await fetch(url, fetchOptions);
            const responseData = await this.parseResponse(response);
            // 检查响应状态
            if (!response.ok) {
                // 如果是401错误，尝试刷新Token并重试
                if (response.status === 401) {
                    return {
                        status: response.status,
                        statusText: response.statusText,
                        data: '',
                        headers: this.parseHeaders(response.headers)
                    };
                }
                // 其他错误，直接抛出
                const errorMsg = this.getErrorMessage(responseData);
                throw new HttpError(errorMsg, response.status, response.statusText, responseData);
            }
            // 处理成功响应的业务逻辑
            return this.handleResponse(response, responseData);
        }
        catch (error) {
            if (error instanceof HttpError) {
                throw error;
            }
            // 网络错误或其他错误
            throw new HttpError(error instanceof Error ? error.message : 'Network Error', 0, 'Network Error', null);
        }
    }
    /**
     * 处理响应数据
     * @param response 响应对象
     * @param responseData 响应数据
     * @returns HttpResponse<T> 处理后的响应
     */
    handleResponse(response, responseData) {
        // 检查是否为业务响应结构
        if (this.isBusinessResponse(responseData)) {
            // 业务响应结构：{ code, msg, data }
            const { code, msg, data } = responseData;
            // 检查业务状态码
            if (code !== 0 && code !== 200 && code !== '0' && code !== '200') {
                // 业务错误，抛出HttpError
                throw new HttpError(msg || `Business Error: ${code}`, response.status, response.statusText, responseData);
            }
            // 业务成功，返回data字段作为实际数据
            return {
                status: response.status,
                statusText: response.statusText,
                data: data,
                headers: this.parseHeaders(response.headers)
            };
        }
        // 非业务响应结构，直接返回原始数据
        return {
            status: response.status,
            statusText: response.statusText,
            data: responseData,
            headers: this.parseHeaders(response.headers)
        };
    }
    /**
     * 检查是否为业务响应结构
     * @param responseData 响应数据
     * @returns boolean 是否为业务响应结构
     */
    isBusinessResponse(responseData) {
        return typeof responseData === 'object' &&
            responseData !== null &&
            ('code' in responseData) &&
            ('msg' in responseData) &&
            ('data' in responseData);
    }
    /**
     * 获取错误信息
     * @param responseData 响应数据
     * @returns string 错误信息
     */
    getErrorMessage(responseData) {
        // 如果是业务响应结构
        if (this.isBusinessResponse(responseData)) {
            return responseData.msg || `Business Error: ${responseData.code}`;
        }
        // 其他错误结构
        return responseData.message || responseData.error || `HTTP Error`;
    }
    /**
     * GET请求
     * @param url 请求URL
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async get(url, options) {
        return this.request({
            method: 'GET',
            url,
            ...options
        });
    }
    /**
     * POST请求
     * @param url 请求URL
     * @param body 请求体
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async post(url, body, options) {
        return this.request({
            method: 'POST',
            url,
            body,
            ...options
        });
    }
    /**
     * PUT请求
     * @param url 请求URL
     * @param body 请求体
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async put(url, body, options) {
        return this.request({
            method: 'PUT',
            url,
            body,
            ...options
        });
    }
    /**
     * DELETE请求
     * @param url 请求URL
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async delete(url, options) {
        return this.request({
            method: 'DELETE',
            url,
            ...options
        });
    }
    /**
     * PATCH请求
     * @param url 请求URL
     * @param body 请求体
     * @param options 请求选项
     * @returns Promise<HttpResponse<T>> 响应结果
     */
    async patch(url, body, options) {
        return this.request({
            method: 'PATCH',
            url,
            body,
            ...options
        });
    }
    /**
     * 解析响应体
     * @param response 响应对象
     * @returns Promise<any> 解析后的响应体
     */
    async parseResponse(response) {
        const contentType = response.headers.get('content-type') || '';
        if (contentType.includes('application/json')) {
            return response.json();
        }
        else if (contentType.includes('text/')) {
            return response.text();
        }
        else {
            return response.blob();
        }
    }
    /**
     * 解析响应头
     * @param headers 响应头对象
     * @returns Record<string, string> 解析后的响应头
     */
    parseHeaders(headers) {
        const result = {};
        headers.forEach((value, key) => {
            result[key] = value;
        });
        return result;
    }
}
//# sourceMappingURL=http.js.map