(function () {
    'use strict';
    try {
        if (window.HerCoreManager) {
            return;
        }

        // 전체 시스템의 단일 진입점 및 상태 관리 + 모듈/이벤트/세션 허브
        class HerCoreManager {
            constructor() {
                this.modules = {}; // {name: {module, deps, order}}
                this.moduleOrder = [];
                this.eventBus = document.createElement('div'); // CustomEvent 기반
                this.settings = {}; // 캐시
                this.sessionState = {};
                this.activeSessionId = null;
                this.sttEngine = null;
                this.syncManager = null;
                this._eventLog = [];
                this._isReady = false;
                this._readyCallbacks = [];
                this._sessionStartTime = null;
                this._sessionTimeoutTimer = null;
                // 세션 상태 복원
                chrome.storage.local.get(['activeSessionId'], (result) => {
                    if (result.activeSessionId) {
                        this.activeSessionId = result.activeSessionId;
                        this.emit('session:active:restored', { sessionId: this.activeSessionId });
                    }
                });
            }

            // 모듈 등록/해제/의존성/정리
            registerModule(name, module, deps = []) {
                if (this.modules[name]) {
                    console.warn(`[HerCoreManager] 모듈 '${name}' 이미 등록됨.`);
                    return false;
                }

                // 의존성 체크
                for (const dep of deps) {
                    if (!this.modules[dep]) {
                        throw new Error(`[HerCoreManager] '${name}' 등록 실패: 의존성 '${dep}' 누락.`);
                    }
                }

                this.modules[name] = { module, deps, order: this.moduleOrder.length };
                this.moduleOrder.push(name);

                if (typeof module.init === 'function') {
                    module.init();
                }

                // STT 엔진 자동 연결
                if (name === 'HerSTTEngine') {
                    this.sttEngine = module;
                }

                // Sync Manager 자동 연결
                if (name === 'HerSyncManager') {
                    this.syncManager = module;
                }

                // 핵심 모듈들이 모두 등록되었는지 확인
                this._checkReadyState();

                return true;
            }

            // 준비 상태 확인 및 알림
            _checkReadyState() {
                const requiredModules = [
                    'HerNotificationSystem',
                    'HerSTTEngine',
                    'HerSyncManager',
                    'HerLanguageManager'
                ];

                const loadedModules = Object.keys(this.modules);
                const allLoaded = requiredModules.every(mod => loadedModules.includes(mod));

                if (allLoaded && !this._isReady) {
                    this._isReady = true;

                    // 대기 중인 콜백들 실행
                    this._readyCallbacks.forEach(callback => {
                        try {
                            callback();
                        } catch (error) {
                            console.error('[HerCoreManager] 준비 콜백 실행 오류:', error);
                        }
                    });
                    this._readyCallbacks = [];

                    // 전역 이벤트 발생
                    window.dispatchEvent(new CustomEvent('her-core-ready'));
                }
            }

            // 준비 완료 대기 메서드
            onReady(callback) {
                if (this._isReady) {
                    callback();
                } else {
                    this._readyCallbacks.push(callback);
                }
            }

            isReady() {
                return this._isReady;
            }

            unregisterModule(name) {
                const mod = this.modules[name];
                if (mod && typeof mod.module.cleanup === 'function') {
                    try { mod.module.cleanup(); } catch (e) { console.error(e); }
                }
                delete this.modules[name];
                this.moduleOrder = this.moduleOrder.filter(n => n !== name);
            }

            // 이벤트 버스 (네임스페이스/once/로깅)
            on(event, handler, ns) {
                const evt = ns ? `${ns}:${event}` : event;
                this.eventBus.addEventListener(evt, handler);
            }
            off(event, handler, ns) {
                const evt = ns ? `${ns}:${event}` : event;
                this.eventBus.removeEventListener(evt, handler);
            }
            once(event, handler, ns) {
                const evt = ns ? `${ns}:${event}` : event;
                const wrapper = (e) => {
                    handler(e);
                    this.off(event, wrapper, ns);
                };
                this.on(event, wrapper, ns);
            }
            emit(event, detail = {}, ns) {
                const evt = ns ? `${ns}:${event}` : event;
                const payload = {
                    ...detail,
                    sessionId: this.activeSessionId || null,
                    timestamp: Date.now(),
                    source: ns || 'core',
                };
                // 데이터 무결성 검증 예시 (버전/해시 등)
                // payload.version = '1.0.0';
                // payload.hash = this._calculatePayloadHash(payload);
                this._eventLog.push({ evt, payload });
                if (this._eventLog.length > 1000) this._eventLog.shift();
                this.eventBus.dispatchEvent(new CustomEvent(evt, { detail: payload }));
                if (window.__HER_DEBUG__) console.debug(`[HerCoreManager][emit]`, evt, payload);
            }
            getEventLog() { return this._eventLog.slice(); }

            // 설정 관리 (캐싱/에러/변경시 알림)
            async getSetting(key, sync = false) {
                if (key in this.settings) return this.settings[key];
                try {
                    const storage = sync ? chrome.storage.sync : chrome.storage.local;
                    return await new Promise((resolve) => {
                        storage.get([key], (result) => {
                            this.settings[key] = result[key];
                            resolve(result[key]);
                        });
                    });
                } catch (e) {
                    console.error(`[HerCoreManager][getSetting]`, e);
                    return undefined;
                }
            }
            async setSetting(key, value, sync = false) {
                try {
                    const storage = sync ? chrome.storage.sync : chrome.storage.local;
                    await new Promise((resolve) => {
                        storage.set({ [key]: value }, () => {
                            this.settings[key] = value;
                            resolve();
                        });
                    });
                    this.emit('settings:changed', { key, value });
                } catch (e) {
                    console.error(`[HerCoreManager][setSetting]`, e);
                }
            }
            clearSettingCache(key) {
                if (key) delete this.settings[key];
                else this.settings = {};
            }

            // 세션 상태/활성 세션/충돌/복구/데이터 전달
            setSessionState(key, value) {
                this.sessionState[key] = value;
            }
            getSessionState(key) {
                return this.sessionState[key];
            }
            setActiveSession(sessionId) {
                if (this.activeSessionId && this.activeSessionId !== sessionId) {
                    this.emit('session:conflict:detected', { prev: this.activeSessionId, next: sessionId });
                }
                this.activeSessionId = sessionId;
                chrome.storage.local.set({ activeSessionId: sessionId });
                this._sessionStartTime = Date.now();
                if (this._sessionTimeoutTimer) clearTimeout(this._sessionTimeoutTimer);
                this._sessionTimeoutTimer = setTimeout(() => {
                    this.emit('session:timeout', { sessionId });
                    this.clearActiveSession();
                }, 600000); // 10분
                this.emit('session:active:changed', { sessionId });
            }
            clearActiveSession() {
                this.activeSessionId = null;
                chrome.storage.local.remove('activeSessionId');
                if (this._sessionTimeoutTimer) clearTimeout(this._sessionTimeoutTimer);
                this.emit('session:active:cleared', {});
            }
            transferSessionData(toModule, data) {
                if (this.modules[toModule] && typeof this.modules[toModule].module.onSessionData === 'function') {
                    this.modules[toModule].module.onSessionData(data);
                }
            }
            // 비정상 종료 복구 예시 (타임아웃 기반)
            checkAndRecoverSession(timeout = 30000) {
                if (!this.activeSessionId) return;
                const last = this.getSessionState('lastActiveTs');
                if (last && Date.now() - last > timeout) {
                    this.emit('session:recovery:triggered', { sessionId: this.activeSessionId });
                    this.clearActiveSession();
                }
            }

            // 세션 충돌 해결
            resolveSessionConflict(newSessionId, newSource) {
                const currentSession = this.activeSessionId;

                if (currentSession && this.sttEngine) {
                    // 기존 세션 강제 종료
                    this.sttEngine.stop(currentSession, true);

                    // 새 세션 시작 대기
                    setTimeout(() => {
                        this.setActiveSession(newSessionId);
                        this.emit('session:resolved', {
                            oldSessionId: currentSession,
                            newSessionId: newSessionId,
                            source: newSource
                        });
                    }, 200);

                    return true;
                }

                return false;
            }

            // 에러 복구 메커니즘 (예시)
            recoverFromError(sessionId, error) {
                console.warn('[HerCoreManager] 세션 에러 복구 시도:', sessionId, error);
                // 간단한 재시도 또는 세션 리셋 로직 구현
                if (this.sttEngine && typeof this.sttEngine._handleSessionError === 'function') {
                    this.sttEngine._handleSessionError(sessionId, error);
                } else {
                    this.clearActiveSession();
                }
            }

            // 데이터 무결성 검증용 해시 예시 (SHA-256 등)
            // _calculatePayloadHash(payload) {
            //     // 실제 구현 필요시 crypto.subtle 등 활용
            //     return 'dummy-hash';
            // }

            getModule(name) {
                return this.modules[name]?.module || null;
            }
            getSTTEngine() {
                const engine = this.getModule('HerSTTEngine');
                if (!engine) {
                    console.warn('[CoreManager] STT Engine 미로드 상태');
                    return null;
                }
                return engine;
            }
            isModuleReady(name) {
                return !!this.modules[name];
            }
        }

        // HerCoreManager 준비 시 content.js 초기화 트리거
        if (typeof window.attemptInitialization === 'function') {
            // 이미 준비된 경우 즉시 호출
            window.HerCoreManager.onReady(() => {
                if (!window.__herInitTriggered) {
                    window.__herInitTriggered = true;
                    window.attemptInitialization();
                }
            });
        } else {
            // content.js가 나중에 로드될 경우를 대비해 전역 플래그만 세팅
            window.__herInitTriggered = false;
        }

        window.HerCoreManager = new HerCoreManager();
    } catch (error) {
        console.error('[HerCoreManager] 오류:', error);
    }
})(); 