import { getToken, getUserInfo } from '@/utils/tools';
class SSEClient {
    constructor() {
        this.source = null; // SSE 核心實例
        // 基礎(chǔ) URL（從環(huán)境變量讀取，適配不同環(huán)境）
        this.baseUrl = import.meta.env.VITE_API_BASE_URL;
        this.path = '/sse/talent/adminConnect'; // SSE 接口路徑
        this.url = `${this.baseUrl}${this.path}`;
        // 請求頭（攜帶 Token 做權(quán)限校驗，適配 HTTPS 鑒權(quán)）,目前這種方式并不支持自定義headers
        this.headers = {
            'satoken': getToken(),
        };
        this.reconnectInterval = 30000; // 自動重連間隔（30秒，可配置）
        this.isConnected = false; // 連接狀態(tài)標識
        this.isReconnecting = false; // 重連狀態(tài)標識（避免重復重連）
        this.eventHandlers = new Map(); // 事件處理器映射表（支持多事件）
        this.maxReconnectTimes = 10; //最大重連次數(shù)（避免無限重連）
        this.reconnectCount = 0; // 當前重連次數(shù)
    }
    /**
     * 動態(tài)拼接 URL
     * 避免重復拼接相同參數(shù)，異常時返回基礎(chǔ)URL
     */
    getUrlWithParams() {
        try {
            const userInfo = getUserInfo();
            // 無用戶信息時返回基礎(chǔ)URL
            if (!userInfo || !userInfo.userId) {
                return this.url;
            }
            const userId = userInfo.userId;
            // 拼接參數(shù)
            const params = new URLSearchParams();
            params.append('userId', userId);
            // 拼接完整URL，避免重復參數(shù)
            const fullUrl = `${this.url}?${params.toString()}`;
            return fullUrl;
        } catch (error) {
            console.warn('SSE 拼接參數(shù)失敗，使用基礎(chǔ)URL：', error);
            return this.url;
        }
    }
    /**
     * 初始化 SSE 連接
     * @param {Object} options - 配置項
     * @param {boolean} options.withCredentials - 是否攜帶跨域憑證
     * @param {number} options.reconnectInterval - 自定義重連間隔
     */
    connect(options = {}) {
        // 避免重復連接或重連中重復觸發(fā)
        if (this.isConnected || this.isReconnecting) {
            return;
        }
        // 合并配置項（支持自定義重連間隔）
        const withCredentials = options.withCredentials || false;
        this.reconnectInterval = options.reconnectInterval || this.reconnectInterval;
        // 先斷開已有連接（防止殘留連接）
        this.disconnect();
        // 更新最新URL（確保參數(shù)實時）
        this.url = this.getUrlWithParams();
        try {
            // SSE 初始化配置（適配 HTTPS 與跨域）
            const eventSourceInitDict = { withCredentials };
            this.source = new EventSource(this.url, eventSourceInitDict);
            // 監(jiān)聽連接成功事件
            this.source.onopen = () => {
                this.isConnected = true;
                this.isReconnecting = false;
                this.reconnectCount = 0; // 重置重連次數(shù)
                this.emit('open', { status: 'connected', url: this.url });
                console.log('SSE 連接成功：', this.url);
            };
            // 監(jiān)聽服務(wù)器推送的通用消息
            this.source.onmessage = (event) => {
                try {
                    // 嘗試解析 JSON 格式數(shù)據(jù)（兼容字符串與JSON）
                    const data = JSON.parse(event.data);
                    this.emit('message', data);
                } catch (e) {
                    // 非JSON格式直接返回原始數(shù)據(jù)
                    this.emit('message', event.data);
                }
            };
            // 監(jiān)聽連接錯誤（核心：錯誤處理與自動重連）
            this.source.onerror = (error) => {
                this.isConnected = false;
                const errorMsg = `SSE 連接錯誤（狀態(tài)碼：${this.source.readyState}）`;
                console.error(errorMsg, error);
                this.emit('error', { message: errorMsg, error, readyState: this.source.readyState });
                // 僅在連接關(guān)閉時觸發(fā)重連（排除臨時錯誤）
                if (this.source.readyState === EventSource.CLOSED && !this.isReconnecting) {
                    this.reconnectCount++;
                    // 超過最大重連次數(shù)停止重連
                    if (this.reconnectCount > this.maxReconnectTimes) {
                        this.isReconnecting = false;
                        this.emit('reconnect-failed', { maxTimes: this.maxReconnectTimes });
                        console.error(`SSE 重連失敗（已超過最大次數(shù) ${this.maxReconnectTimes}）`);
                        return;
                    }
                    this.isReconnecting = true;
                    console.log(`SSE 準備重連（第 ${this.reconnectCount}/${this.maxReconnectTimes} 次），間隔 ${this.reconnectInterval}ms`);
                    // 延遲重連（避免頻繁請求）
                    setTimeout(() => {
                        this.connect(options);
                    }, this.reconnectInterval);
                }
            };
            // 注冊已綁定的自定義事件（避免重連后事件丟失）
            this.eventHandlers.forEach((handler, eventName) => {
                this.bindCustomEvent(eventName, handler);
            });
        } catch (e) {
            this.isReconnecting = false;
            const errorMsg = '創(chuàng)建 SSE 連接失敗（初始化異常）';
            console.error(errorMsg, e);
            this.emit('error', { message: errorMsg, error: e });
        }
    }
    /**
     * 綁定自定義事件（抽離復用，適配重連場景）
     * @param {string} eventName - 自定義事件名
     * @param {Function} handler - 事件處理器
     */
    bindCustomEvent(eventName, handler) {
        // 排除系統(tǒng)內(nèi)置事件（open/message/error）
        const systemEvents = ['open', 'message', 'error'];
        if (systemEvents.includes(eventName)) return;
        // 移除已有監(jiān)聽（避免重復綁定）
        if (this.source) {
            this.source.removeEventListener(eventName, handler);
            // 綁定新監(jiān)聽
            this.source.addEventListener(eventName, (event) => {
                try {
                    const data = JSON.parse(event.data);
                    handler(data);
                } catch (e) {
                    handler(event.data);
                }
            });
        }
    }
    /**
     * 注冊事件監(jiān)聽（支持系統(tǒng)事件與自定義事件）
     * @param {string} eventName - 事件名
     * @param {Function} handler - 事件處理器
     */
    on(eventName, handler) {
        if (typeof handler !== 'function') {
            console.warn(`SSE 事件 ${eventName} 處理器必須是函數(shù)`);
            return;
        }
        // 存儲事件處理器
        this.eventHandlers.set(eventName, handler);
        // 已連接狀態(tài)下立即綁定事件
        if (this.source && this.isConnected) {
            this.bindCustomEvent(eventName, handler);
        }
    }
    /**
     * 觸發(fā)事件（供內(nèi)部調(diào)用，分發(fā)消息）
     * @param {string} eventName - 事件名
     * @param {any} data - 事件數(shù)據(jù)
     */
    emit(eventName, data) {
        const handler = this.eventHandlers.get(eventName);
        if (handler) {
            try {
                handler(data);
            } catch (e) {
                console.error(`SSE 觸發(fā)事件 ${eventName} 失?。篳, e);
            }
        }
    }
    /**
     * 移除事件監(jiān)聽
     * @param {string} eventName - 事件名
     */
    off(eventName) {
        this.eventHandlers.delete(eventName);
        if (this.source) {
            const handler = this.eventHandlers.get(eventName);
            if (handler) {
                this.source.removeEventListener(eventName, handler);
            }
        }
    }
    /**
     * 關(guān)閉 SSE 連接（重置狀態(tài)，避免內(nèi)存泄漏）
     * @param {boolean} isManual - 是否手動關(guān)閉（區(qū)別于異常斷開）
     */
    disconnect(isManual = false) {
        if (this.source) {
            this.source.close();
            this.source = null;
        }
        // 重置狀態(tài)
        this.isConnected = false;
        this.isReconnecting = false;
        if (isManual) {
            this.reconnectCount = 0; // 手動關(guān)閉重置重連次數(shù)
            this.emit('close', { isManual });
            console.log('SSE 手動關(guān)閉連接');
        }
    }
    /**
     * 強制重連（主動觸發(fā)重連，重置重連次數(shù)）
     * @param {Object} options - 配置項
     */
    forceReconnect(options = {}) {
        this.reconnectCount = 0;
        this.isReconnecting = false;
        this.connect(options);
    }
    /**
     * 更新連接參數(shù)（如Token過期后刷新URL）
     */
    updateParams() {
        this.url = this.getUrlWithParams();
        // 已連接狀態(tài)下重新連接（刷新參數(shù)）
        if (this.isConnected) {
            this.forceReconnect();
        }
    }
}
// 全局單例模式（確保全項目唯一 SSE 實例，避免多連接沖突）
export const sseClient = new SSEClient();

import { createApp } from 'vue';
import App from './App.vue';
import { sseClient } from '@/utils/sseClient';
const app = createApp(App);
// 全局掛載 SSE 實例
app.config.globalProperties.$sse = sseClient;
app.mount('#app');

<script setup>
import { onMounted, onUnmounted } from 'vue';
import { sseClient } from '@/utils/sseClient';
onMounted(() => {
    // 1. 注冊事件監(jiān)聽
    // 連接成功事件
    sseClient.on('open', (res) => {
        console.log('SSE 連接成功', res);
        // 可在這里處理連接成功后的邏輯（如更新UI狀態(tài)）
    });
    // 通用消息事件（服務(wù)器推送的所有消息）
    sseClient.on('message', (data) => {
        console.log('收到 SSE 消息', data);
        // 處理業(yè)務(wù)邏輯（如實時通知、數(shù)據(jù)更新）
    });
    // 自定義事件（后端指定事件名，如"notice"）
    sseClient.on('notice', (data) => {
        console.log('收到自定義通知', data);
        // 處理自定義消息（如系統(tǒng)通知、業(yè)務(wù)提醒）
    });
    // 錯誤事件
    sseClient.on('error', (err) => {
        console.error('SSE 異常', err);
        // 處理錯誤（如提示用戶、降級處理）
    });
    // 重連失敗事件
    sseClient.on('reconnect-failed', (res) => {
        console.error('SSE 重連失敗', res);
        // 提示用戶手動刷新頁面
    });
    // 2. 啟動 SSE 連接（配置跨域憑證）
    sseClient.connect({ withCredentials: true });
});
onUnmounted(() => {
    // 組件卸載時移除事件監(jiān)聽、關(guān)閉連接（避免內(nèi)存泄漏）
    sseClient.off('open');
    sseClient.off('message');
    sseClient.off('notice');
    sseClient.off('error');
    sseClient.off('reconnect-failed');
    sseClient.disconnect(true); // 手動關(guān)閉連接
});
</script>