import { BASE_URL } from "../../constant/base";

/// 请求流式数据的API
const API = '/agent/assistant/chat';

/**
 * 获取AI聊天流式信息（仅微信小程序支持）
 * @param {Object} params 请求参数
 * @param {Function} onChunk 回调，每收到一段数据触发
 * @returns {Object} 包含Promise和requestTask的对象
 */
let requestTask = null;
let isAborted = false; // 添加终止状态标志
let currentPromiseReject = null; // 保存当前Promise的reject函数
let requestId = 0; // 请求ID，用于区分不同的请求

const stopAbortTask = () => {
	console.log('🛑 开始强制终止请求...');
	isAborted = true; // 立即设置终止标志
	
	// 立即拒绝当前Promise（最强制的终止）
	if (currentPromiseReject) {
		console.log('🛑 立即拒绝Promise');
		currentPromiseReject(new Error('请求已被用户终止'));
		currentPromiseReject = null;
	}

	if (requestTask) {
		// 先取消所有监听器（关键：必须在abort之前）
		try {
			if (requestTask.offChunkReceived) {
				requestTask.offChunkReceived();
				console.log('🛑 已取消 ChunkReceived 监听');
			}
		} catch (e) {
			console.log('🛑 取消 ChunkReceived 监听失败:', e);
		}
		
		try {
			if (requestTask.offHeadersReceived) {
				requestTask.offHeadersReceived();
				console.log('🛑 已取消 HeadersReceived 监听');
			}
		} catch (e) {
			console.log('🛑 取消 HeadersReceived 监听失败:', e);
		}

		// 然后终止网络请求
		try {
			if (requestTask.abort) {
				requestTask.abort();
				console.log('🛑 已终止网络请求');
			}
		} catch (e) {
			console.log('🛑 终止网络请求失败:', e);
		}

		requestTask = null;
	}
	
	// 递增请求ID，使旧请求的数据无效
	requestId++;
	console.log('🛑 请求强制终止完成，新请求ID:', requestId);
}

const agentChatStream = (params, onChunk) => {
    const promise = new Promise((resolve, reject) => {
        const token = uni.getStorageSync('token');
        let hasError = false;
        isAborted = false; // 重置终止状态
        
        // 保存当前Promise的reject函数，用于强制终止
        currentPromiseReject = reject;
        
        // 为当前请求分配ID
        const currentRequestId = ++requestId;
        console.log("🚀 发送请求内容: ", params, "请求ID:", currentRequestId)
        // #ifdef MP-WEIXIN
        requestTask = uni.request({
            url: BASE_URL + API, // 替换为你的接口地址
            method: 'POST',
            data: params,
            enableChunked: true,
            header: {
                Accept: 'text/event-stream',
                'Content-Type': 'application/json',
                Authorization: `Bearer ${token}`, // 如需token可加
            },
            responseType: 'arraybuffer',
            success(res) {
				if (!isAborted && requestId === currentRequestId) {
					console.log("✅ 请求成功，ID:", currentRequestId);
					resolve(res.data);
				} else {
					console.log("❌ 请求已过期或终止，忽略success回调，当前ID:", requestId, "请求ID:", currentRequestId);
				}
            },
            fail(err) {
				if (!isAborted && requestId === currentRequestId) {
					console.log("❌ 请求失败，ID:", currentRequestId, "错误:", JSON.stringify(err));
					reject(err);
				} else {
					console.log("❌ 请求已过期或终止，忽略fail回调，当前ID:", requestId, "请求ID:", currentRequestId);
				}
            },
            complete(res) {
				if (!isAborted && requestId === currentRequestId && res.statusCode !== 200) {
					console.log("❌ 请求完成但状态错误，ID:", currentRequestId, "状态:", res.statusCode);
					if (onChunk) {
						onChunk({ error: true, message: '服务器错误', detail: res });
					}
					reject(res);
				} else if (requestId !== currentRequestId) {
					console.log("❌ 请求已过期或终止，忽略complete回调，当前ID:", requestId, "请求ID:", currentRequestId);
				}
            }
        });

        requestTask.onHeadersReceived(res => {
            // 检查请求是否已终止或过期
            if (isAborted || requestId !== currentRequestId) {
                console.log('🚫 Headers已终止或过期，忽略，当前ID:', requestId, '请求ID:', currentRequestId);
                return;
            }

            console.log('📡 onHeadersReceived，ID:', currentRequestId, res);
            const status = res.statusCode || (res.header && res.header.statusCode);
            if (status && status !== 200) {
                hasError = true;
                if (onChunk && !isAborted && requestId === currentRequestId) {
                    onChunk({ error: true, message: `服务器错误(${status})`, detail: res });
                }
                if (requestTask && requestTask.abort) {
                    requestTask.abort();
                }
            }
        });

        requestTask.onChunkReceived(res => {
            // 第一道防线：立即检查请求ID和终止状态
            if (isAborted || hasError || requestTask === null || requestId !== currentRequestId) {
                console.log('🚫 数据块已终止或过期，忽略 - 第一道检查，当前ID:', requestId, '请求ID:', currentRequestId);
                return;
            }

            console.log("📦 onChunkReceived，ID:", currentRequestId, res)
            const base64 = uni.arrayBufferToBase64(res.data);
            let data = '';
            try {
                data = decodeURIComponent(escape(weAtob(base64)));
            } catch (e) {
                // 某些平台可能不支持 atob，可以直接用 base64
                data = base64;
            }
            
            // 第二道防线：解析前再次检查
            if (isAborted || hasError || requestTask === null || requestId !== currentRequestId) {
                console.log('🚫 数据块已终止或过期，忽略 - 第二道检查，当前ID:', requestId, '请求ID:', currentRequestId);
                return;
            }
            
            const messages = parseSSEChunk(data);
            messages.forEach(msg => {
                // 第三道防线：每个消息处理前都检查
                if (onChunk && !isAborted && !hasError && requestTask !== null && requestId === currentRequestId) {
                  console.log(`parseSSEChunk ${currentRequestId}:`, msg)
                  onChunk(msg);
                } else {
                    console.log('🚫 消息已终止或过期，忽略处理，当前ID:', requestId, '请求ID:', currentRequestId);
                }
            });
        });
        // #endif
    });

    return promise
}

// window.atob兼容性处理
const weAtob = (string) => {
  const b64re = /^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;
  const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  // 去除空白字符
  string = String(string).replace(/[\t\n\f\r ]+/g, '');
  // 验证 Base64 编码
  if (!b64re.test(string)) {
    throw new TypeError(
      // eslint-disable-next-line quotes
      "Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded."
    );
  }

  // 填充字符
  string += '=='.slice(2 - (string.length & 3));

  let bitmap,
    result = '',
    r1,
    r2,
    i = 0;

  for (; i < string.length;) {
    bitmap =
      (b64.indexOf(string.charAt(i++)) << 18) |
      (b64.indexOf(string.charAt(i++)) << 12) |
      ((r1 = b64.indexOf(string.charAt(i++))) << 6) |
      (r2 = b64.indexOf(string.charAt(i++)));

    if (r1 === 64) {
      result += String.fromCharCode((bitmap >> 16) & 255);
    } else if (r2 === 64) {
      result += String.fromCharCode(
        (bitmap >> 16) & 255,
        (bitmap >> 8) & 255
      );
    } else {
      result += String.fromCharCode(
        (bitmap >> 16) & 255,
        (bitmap >> 8) & 255,
        bitmap & 255
      );
    }
  }
  return result;
};


// 解析SSE分段数据
function parseSSEChunk(raw) {
    // 拆分为多段
    const lines = raw.split('\n\n');
    const results = [];
    lines.forEach(line => {
        // 只处理包含 data: 的行
        const dataMatch = line.match(/data:(\{.*\})/);
        if (dataMatch && dataMatch[1]) {
            try {
                const obj = JSON.parse(dataMatch[1]);
                results.push(obj);
            } catch (e) {
                // 解析失败忽略
            }
        }
    });
    return results;
}

export { agentChatStream, stopAbortTask }