(function () {
    'use strict';

    if (window.HerContentSTTHandler) return;

    class ContentSTTHandler {
        constructor() {
            this.input = null;
            this.isRecording = false;
            this.sessionId = null;
            this.startPosition = 0;
            this.originalValue = '';
            this.prefixText = '';
            this.isFieldEmpty = false;
            this.currentText = ''; // 🚨 추가: 실시간 텍스트 추적
            
            // 🎤 카운트다운 시스템 (무음 감지 개선)
            this.countdownTimer = null;
            this.countdownSeconds = 0;
            this.silenceDetectionTimer = null; // 무음 감지 타이머
            this.autoSendTimerSetting = 2; // 기본값 2초 (스토리지에서 로드됨)
            this.isCountdownActive = false; // 카운트다운 활성 상태 플래그
            this.isUIBeingRestored = false; // UI 복원 중복 호출 방지 플래그
        }

        async start(input, onUpdate, onError) {
            if (this.isRecording) {
                this.stop();
                await new Promise(resolve => setTimeout(resolve, 200));
            }

            // 🎯 전역 상태 사전 체크 (안전장치 추가)
            if (window.HerGlobalState) {
                const globalState = window.HerGlobalState.getState();
                if (globalState.isRecording) {
                    this.showBlockingNotification(globalState.currentContext);
                    if (onError) onError('다른 곳에서 이미 녹음 중입니다.');
                    return false;
                }
            } else {
                // console.warn('[ContentSTT] ⚠️ HerGlobalState not loaded - skipping global state check');
            }

            this.input = input;
            this.sessionId = `content-${Date.now()}`;

            // 🚨 스토리지에서 자동 전송 타이머 설정 로드
            try {
                const storage = await chrome.storage.sync.get(['autoSendTimer']);
                this.autoSendTimerSetting = storage.autoSendTimer ?? 2; // undefined일 때만 기본값 2
                if (this.autoSendTimerSetting === 0) {
                    // console.log('[ContentSTT] ⏰ 자동 전송 비활성화 설정됨');
                } else {
                    // console.log(`[ContentSTT] ⏰ 자동 전송 타이머 설정 로드: ${this.autoSendTimerSetting}초`);
                }
            } catch (error) {
                // console.warn('[ContentSTT] ⚠️ 타이머 설정 로드 실패, 기본값 사용:', error);
                this.autoSendTimerSetting = 2;
            }

            // 기존 텍스트 보존 - 커서 위치에서 시작
            if (input.tagName === 'INPUT' || input.tagName === 'TEXTAREA') {
                this.startPosition = input.selectionStart || input.value.length;
                this.originalValue = input.value;
                this.prefixText = input.value.substring(0, this.startPosition);
                this.isFieldEmpty = !input.value.trim();
            } else {
                this.startPosition = this.getCursorPosition(input);
                this.originalValue = input.textContent || '';
                this.prefixText = this.getTextBeforeCursor(input);
                this.isFieldEmpty = !(input.textContent || '').trim();
            }


            if (!window.HerSTTEngine) {
                return false;
            }

            const sttEngine = window.HerSTTEngine.getInstance();

            const onUpdateCallback = (data) => {
                if (!this.isRecording || !this.input) return;
                const displayText = data.text || '';
                const hasNewText = displayText !== this.currentText;
                
                this.currentText = displayText;
                this.updateInputValue(displayText);
                
                // 🎤 텍스트 변화가 있으면 무음 타이머 업데이트
                if (hasNewText && displayText.trim()) {
                    // console.log('[ContentSTT] 🔄 텍스트 변화 감지:', displayText.substring(Math.max(0, displayText.length - 20)));
                    this.onTextUpdate();
                }
                
                // 🔥 디버깅: 텍스트가 있는데 변화가 없는 경우도 체크
                if (!hasNewText && displayText.trim() && this.isRecording && !this.isCountdownActive) {
                    /* console.log('[ContentSTT] 🔍 텍스트 변화 없음 - 카운트다운 조건 확인:', {
                        hasText: !!displayText.trim(),
                        isRecording: this.isRecording,
                        isCountdownActive: this.isCountdownActive,
                        autoSendTimer: this.autoSendTimerSetting
                    }); */
                }
                
                if (onUpdate) {
                    onUpdate({ text: displayText, final: !data.interimText });
                }
            };

            const onStateChangeCallback = (state, data) => {
                if (state === 'stop') {
                    this.isRecording = false;
                    const textToSave = data?.finalText || this.currentText || '';
                    if (textToSave.trim()) {
                        this.saveToVoiceMemos(textToSave.trim());
                    }
                } else if (state === 'error') {
                    this.handleRecordingError(data?.error, data);
                }
            };

            sttEngine.setCallbacks(onUpdateCallback, onStateChangeCallback);

            try {
                const sessionId = `content-${Date.now()}`;
                await sttEngine.start(sessionId, 'content', { preserveText: false });

                // 🎯 STT 시작 성공 후에만 상태 설정
                this.isRecording = true;
                
                // 🔥 즉시 UI 상태 업데이트 - VoiceInputManager와 동기화
                this.updateRecordingUI();
                
                // 🎤 STT 준비 완료
                
                return true;
            } catch (error) {
                if (error.type === 'concurrent_recording') {
                    this.showBlockingNotification(error.currentContext);
                    if (onError) onError(error.message);
                    return false;
                }
                throw error;
            }
        }

        updateInputValue(text) {
            if (!this.input) return;

            try {
                // �� 중요: 기존 텍스트 + 새 텍스트 (버그 수정)
                let finalText;

                if (this.isFieldEmpty) {
                    // 필드가 비어있었다면 새 텍스트만 사용
                    finalText = text;
                } else {
                    // 필드에 내용이 있었다면 기존 텍스트 + 새 텍스트
                    finalText = (this.prefixText || '') + text;
                }

                if (this.input.tagName === 'INPUT' || this.input.tagName === 'TEXTAREA') {
                    this.input.value = finalText;
                    const newPosition = finalText.length;
                    this.input.setSelectionRange(newPosition, newPosition);
                } else if (this.input.isContentEditable) {
                    // 🎯 Perplexity에만 특별 처리 적용
                    if (this.isPerplexityLexicalEditor(this.input)) {
                        // Perplexity는 실시간 입력하지 않고, 녹음 종료 시 처리
                        this.handleComplexEditor(text);
                    } else if (this.input.hasAttribute('data-lexical-editor')) {
                        this.updateLexicalEditorWithPrefix(text);
                    } else {
                        this.input.textContent = finalText;
                        this.setCursorToEnd(this.input);
                    }
                }

                this.input.dispatchEvent(new Event('input', { bubbles: true }));
            } catch (e) {
                console.error('[ContentSTTHandler] 업데이트 실패:', e);
            }
        }

        updateLexicalEditorIncremental(text) {
            // 현재 에디터의 텍스트 길이 확인
            const currentText = this.input.textContent || '';

            // 새로운 텍스트가 기존보다 길면 추가 부분만 입력
            if (text.length > currentText.length) {
                const newPart = text.substring(currentText.length);
                this.input.focus();

                // 커서를 끝으로 이동
                const selection = window.getSelection();
                const range = document.createRange();
                range.selectNodeContents(this.input);
                range.collapse(false);
                selection.removeAllRanges();
                selection.addRange(range);

                // 새로운 부분만 입력
                document.execCommand('insertText', false, newPart);
            } else if (text !== currentText) {
                // 전체 교체가 필요한 경우 (수정이나 완전히 다른 텍스트)
                this.input.focus();
                document.execCommand('selectAll', false, null);
                document.execCommand('insertText', false, text);
            }
        }

        updateLexicalEditorWithPrefix(newText) {
            // Lexical 에디터에서 기존 텍스트 보존 (버그 수정)
            let finalText;

            if (this.isFieldEmpty) {
                // 필드가 비어있었다면 새 텍스트만 사용
                finalText = newText;
            } else {
                // 필드에 내용이 있었다면 기존 텍스트 + 새 텍스트
                finalText = (this.prefixText || '') + newText;
            }

            this.input.focus();

            // 전체 선택 후 새 텍스트로 교체
            document.execCommand('selectAll', false, null);
            document.execCommand('insertText', false, finalText);

            // 커서를 끝으로 이동
            this.setCursorToEnd(this.input);
        }

        // 🎯 Perplexity Lexical 에디터 전용 처리
        // 🎯 Perplexity Lexical 에디터 감지
        isPerplexityLexicalEditor(element) {
            return element && (
                element.id === 'ask-input' ||
                (element.contentEditable === 'true' &&
                    element.querySelector('span[data-lexical-text="true"]')) ||
                (element.tagName === 'DIV' &&
                    element.contentEditable === 'true' &&
                    element.className.includes('outline-none') &&
                    element.className.includes('font-sans'))
            );
        }

        // 🎯 복잡한 에디터 감지 (Perplexity, Notion 등)
        isComplexEditor(element) {
            return element && (
                this.isPerplexityLexicalEditor(element) ||
                element.getAttribute('data-lexical-editor') === 'true' ||
                element.classList.contains('notion-editor') ||
                element.closest('.notion-editor') ||
                element.closest('[data-block-id]') // Notion 블록
            );
        }

        // 🎯 복잡한 에디터 처리 (Perplexity, Notion 등)
        handleComplexEditor(newText) {
            // 복잡한 에디터는 실시간 입력하지 않고, 텍스트만 저장
            this.currentText = newText;
        }



        // 🎯 Perplexity 필드에 execCommand로 텍스트 삽입
        async insertTextToPerplexityField(text) {
            try {
                const lexicalEditor = this.input;
                
                // 새로운 텍스트 구성
                let finalText;
                if (this.isFieldEmpty) {
                    finalText = text;
                } else {
                    finalText = (this.prefixText || '') + text;
                }

                // 1. 에디터에 포커스
                lexicalEditor.focus();

                // 2. execCommand로 텍스트 삽입
                const success = document.execCommand('insertText', false, finalText);
                
                if (!success) {
                    throw new Error('execCommand insertText 실패');
                }

            } catch (error) {
                console.error('❌ Perplexity execCommand 삽입 실패:', error);

                // 실패시 클립보드 붙여넣기로 폴백
                try {
                    await navigator.clipboard.writeText(finalText);
                    lexicalEditor.focus();

                    const isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0;
                    const keydownEvent = new KeyboardEvent('keydown', {
                        key: 'v',
                        code: 'KeyV',
                        metaKey: isMac,
                        ctrlKey: !isMac,
                        bubbles: true,
                        cancelable: true
                    });

                    lexicalEditor.dispatchEvent(keydownEvent);
                } catch (fallbackError) {
                    console.error('❌ 클립보드 붙여넣기 폴백도 실패:', fallbackError);
                }
            }
        }

        // 🎯 Perplexity 입력 완료 알림 표시
        showPerplexityInsertNotification() {
            // 기존 알림 제거
            const existingNotification = document.querySelector('.her-perplexity-insert-notification');
            if (existingNotification) {
                existingNotification.remove();
            }

            const notification = document.createElement('div');
            notification.className = 'her-perplexity-insert-notification';
            notification.style.cssText = `
                position: fixed;
                top: 20px;
                right: 20px;
                background: rgba(0, 0, 0, 0.8);
                color: white;
                padding: 12px 16px;
                border-radius: 8px;
                font-size: 13px;
                font-weight: 500;
                z-index: 2147483647;
                max-width: 250px;
                word-wrap: break-word;
                backdrop-filter: blur(8px);
                animation: fadeInOut 2s ease-in-out;
            `;

            notification.innerHTML = `
                <div style="display: flex; align-items: center; gap: 8px;">
                    <div style="font-size: 14px;">✅</div>
                    <div style="font-size: 12px;">텍스트 입력 완료</div>
                </div>
            `;

            // 애니메이션 스타일 추가
            if (!document.querySelector('#perplexity-insert-style')) {
                const style = document.createElement('style');
                style.id = 'perplexity-insert-style';
                style.textContent = `
                    @keyframes fadeInOut {
                        0% { opacity: 0; transform: translateY(-10px); }
                        20% { opacity: 1; transform: translateY(0); }
                        80% { opacity: 1; transform: translateY(0); }
                        100% { opacity: 0; transform: translateY(-10px); }
                    }
                `;
                document.head.appendChild(style);
            }

            document.body.appendChild(notification);

            // 2초 후 자동 제거
            setTimeout(() => {
                if (notification.parentNode) {
                    notification.parentNode.removeChild(notification);
                }
            }, 2000);
        }

        // 🎯 복잡한 에디터 완료 알림 표시 (간소화)
        showComplexEditorCompleteNotification() {
            // 기존 알림 제거
            const existingNotification = document.querySelector('.her-complex-editor-notification');
            if (existingNotification) {
                existingNotification.remove();
            }

            const notification = document.createElement('div');
            notification.className = 'her-complex-editor-notification';
            notification.style.cssText = `
                position: fixed;
                top: 20px;
                right: 20px;
                background: rgba(0, 0, 0, 0.8);
                color: white;
                padding: 12px 16px;
                border-radius: 8px;
                font-size: 13px;
                font-weight: 500;
                z-index: 2147483647;
                max-width: 250px;
                word-wrap: break-word;
                backdrop-filter: blur(8px);
                animation: fadeInOut 2s ease-in-out;
            `;

            notification.innerHTML = `
                <div style="display: flex; align-items: center; gap: 8px;">
                    <div style="font-size: 14px;">📋</div>
                    <div style="font-size: 12px;">클립보드에 복사됨</div>
                </div>
            `;

            // 애니메이션 스타일 추가
            if (!document.querySelector('#complex-editor-complete-style')) {
                const style = document.createElement('style');
                style.id = 'complex-editor-complete-style';
                style.textContent = `
                    @keyframes fadeInOut {
                        0% { opacity: 0; transform: translateY(-10px); }
                        20% { opacity: 1; transform: translateY(0); }
                        80% { opacity: 1; transform: translateY(0); }
                        100% { opacity: 0; transform: translateY(-10px); }
                    }
                `;
                document.head.appendChild(style);
            }

            document.body.appendChild(notification);

            // 2초 후 자동 제거
            setTimeout(() => {
                if (notification.parentNode) {
                    notification.parentNode.removeChild(notification);
                }
            }, 2000);
        }



        setCursorToEnd(element) {
            const range = document.createRange();
            const selection = window.getSelection();
            range.selectNodeContents(element);
            range.collapse(false);
            selection.removeAllRanges();
            selection.addRange(range);
        }

        getCursorPosition(element) {
            const selection = window.getSelection();
            if (selection.rangeCount > 0) {
                const range = selection.getRangeAt(0);
                const preCaretRange = range.cloneRange();
                preCaretRange.selectNodeContents(element);
                preCaretRange.setEnd(range.startContainer, range.startOffset);
                return preCaretRange.toString().length;
            }
            return 0;
        }

        getTextBeforeCursor(element) {
            const selection = window.getSelection();
            if (selection.rangeCount > 0) {
                const range = selection.getRangeAt(0);
                const preCaretRange = range.cloneRange();
                preCaretRange.selectNodeContents(element);
                preCaretRange.setEnd(range.startContainer, range.startOffset);
                return preCaretRange.toString();
            }
            return element.textContent || '';
        }

        async saveToVoiceMemos(text) {
            const trimmedText = text.trim();
            
            if (!trimmedText) {
                return;
            }

            // Voice Memos 창 감지 (window 객체로 판단)
            if (window.HerVoiceMemos) {
                return;
            }

            // 🚨 개선: 중복 체크 시간을 3초로 단축하고 조건 완화
            const now = Date.now();
            const recentRecords = await this.getRecentRecords(3000); // 5초 → 3초로 단축

            const isDuplicate = recentRecords.some(record => {
                const isSameText = record.text === trimmedText;
                const isSameDomain = record.domain === window.location.hostname;
                const isRecent = (now - new Date(record.timestamp).getTime()) < 3000;

                return isSameText && isSameDomain && isRecent;
            });

            // 🚨 중복이어도 강제 저장 옵션 추가 (프로덕션에서는 비활성화)
            const DEBUG_FORCE_SAVE = false; // 프로덕션에서는 false

            if (isDuplicate && !DEBUG_FORCE_SAVE) {
                return;
            }

            const record = {
                id: Date.now(),
                text: trimmedText,
                timestamp: new Date().toISOString(),
                domain: window.location.hostname,
                lang: navigator.language || 'ko-KR'
            };

            try {
                const result = await chrome.storage.local.get(['voiceRecords']);
                const voiceRecords = result.voiceRecords || [];
                voiceRecords.unshift(record);
                // 🎯 100개 제한 제거 - 사용자가 원하는 만큼 저장 가능
                // if (voiceRecords.length > 100) {
                //     voiceRecords.splice(100);
                // }
                await chrome.storage.local.set({ voiceRecords });

                // 🚨 강화: 보이스 메모 창 실시간 업데이트를 위한 다중 알림
                if (chrome.runtime && chrome.runtime.sendMessage) {
                    try {
                        // 1. 런타임 메시지 전송
                        chrome.runtime.sendMessage({
                            type: 'VOICE_MEMO_SAVED',
                            record: record
                        });
                    } catch (error) {
                        // 런타임 메시지 전송 실패는 정상적인 경우
                    }
                }

                // Amplitude 이벤트 추가
                if (window.amplitude) {
                    window.amplitude.incrementUserProperty('total_memos_saved');
                    window.amplitude.setUserProperties({
                        last_used_source: 'content'
                    });
                    window.amplitude.trackEvent('Memo Saved', {
                        source: 'content',
                        page_domain: window.location.hostname,
                        text_length: record.text.length,
                        recording_duration_sec: 0,
                        language: 'ko-KR'
                    });
                }

                window.dispatchEvent(new CustomEvent('her-voice-record-added', {
                    detail: { record, source: 'content' }
                }));
            } catch (error) {
                console.error('[ContentSTTHandler] Voice Memos 저장 실패:', error);
            }
        }

        async getRecentRecords(timeWindow) {
            try {
                const result = await chrome.storage.local.get(['voiceRecords']);
                const records = result.voiceRecords || [];
                const cutoff = Date.now() - timeWindow;
                return records.filter(record =>
                    new Date(record.timestamp).getTime() > cutoff
                );
            } catch (error) {
                return [];
            }
        }

        async stop() {
            // 🎤 카운트다운 정리
            this.stopCountdown();
            
            // 🎯 isRecording 상태를 미리 저장 (STT 엔진 stop 호출 전에)
            const wasRecording = this.isRecording;

            if (this.isRecording && window.HerSTTEngine) {
                await window.HerSTTEngine.getInstance().stop('explicit', this.sessionId);
            }

            // 🎯 Perplexity에서만 녹음 종료 시 직접 필드에 텍스트 입력 (전역 상태 초기화 전에 실행)
            const shouldInsertToField = wasRecording && this.input && this.isPerplexityLexicalEditor(this.input);
            const textToInsert = this.currentText || this.originalValue;

            if (shouldInsertToField && textToInsert && textToInsert.trim()) {
                try {
                    await this.insertTextToPerplexityField(textToInsert.trim());
                    this.showPerplexityInsertNotification();
                } catch (error) {
                    console.error('❌ Perplexity 입력 실패:', error);
                }
            }

            // 🚨 명시적 종료 시에만 Voice Memos 저장
            if (this.originalValue && this.originalValue.trim() && this.isRecording) {
                await this.saveToVoiceMemos(this.originalValue.trim());
            }

            // 🎯 전역 상태 초기화 (모든 처리 완료 후에 실행)
            window.HerGlobalState.reset();

            // 🎯 로컬 상태 초기화
            this.isRecording = false;
            this.input = null;
            this.sessionId = null;
            this.startPosition = 0;
            this.originalValue = '';
            this.prefixText = '';
            this.isFieldEmpty = false; // 🚨 추가된 플래그 초기화
            this.currentText = ''; // 🎯 복잡한 에디터 텍스트 초기화
            
            // 🎤 무음 감지 타이머 초기화 (재시작 문제 해결)
            if (this.silenceDetectionTimer) {
                clearTimeout(this.silenceDetectionTimer);
                this.silenceDetectionTimer = null;
            }
            
            // 🎤 카운트다운 상태 초기화 (재시작 문제 해결)
            this.isCountdownActive = false;
            
            
            // UI 상태를 Ready로 복원
            this.updateReadyUI();
        }

        // 🎤 텍스트 업데이트 시 호출
        onTextUpdate() {
            // console.log('[ContentSTT] 📝 텍스트 업데이트 감지');
            
            // 카운트다운 중이었다면 취소
            if (this.countdownTimer || this.isCountdownActive) {
                // console.log('[ContentSTT] 🚫 카운트다운 취소 (텍스트 업데이트)');
                this.stopCountdown();
                
                // 녹음 상태로 UI 복원
                this.updateRecordingUI();
            }
            
            // 🔥 기존 타이머가 있다면 제거
            if (this.silenceDetectionTimer) {
                clearTimeout(this.silenceDetectionTimer);
                this.silenceDetectionTimer = null;
            }
            
            
            // 🔥 텍스트 입력 후 무음 감지를 위한 타이머 설정
            /* console.log('[ContentSTT] 🔍 무음 감지 타이머 조건 체크:', {
                isRecording: this.isRecording,
                isCountdownActive: this.isCountdownActive,
                autoSendTimerSetting: this.autoSendTimerSetting
            }); */
            if (this.isRecording && !this.isCountdownActive && this.autoSendTimerSetting > 0) {
                // console.log('[ContentSTT] ⏰ 무음 감지 타이머 시작 (1초 후 카운트다운)');
                this.silenceDetectionTimer = setTimeout(() => {
                    if (this.isRecording && !this.isCountdownActive) {
                        // console.log('[ContentSTT] 🎯 무음 감지 완료 → 카운트다운 시작');
                        this.startCountdown();
                    }
                }, 1000); // 1초 무음 후 카운트다운 시작
            } else if (this.autoSendTimerSetting === 0) {
                // console.log('[ContentSTT] ⏰ 자동 전송 비활성화 상태 (타이머 설정: 0)');
            }
        }

        startCountdown() {
            // 이미 카운트다운이 실행 중이면 중복 실행 방지
            if (this.countdownTimer || this.isCountdownActive) {
                // console.log('[ContentSTT] ⚠️ 카운트다운 중복 실행 방지');
                return;
            }

            // 타이머가 0이면 카운트다운 시작하지 않음
            if (this.autoSendTimerSetting === 0) {
                // console.log('[ContentSTT] ⏰ 자동 전송 비활성화 (타이머: 0)');
                return;
            }

            // ✅ 카운트다운 시작 (무음 감지 제거)
            this.isCountdownActive = true; // 카운트다운 활성 상태 플래그
            
            this.countdownSeconds = this.autoSendTimerSetting;
            // console.log('[ContentSTT] 🎯 카운트다운 시작:', this.countdownSeconds, '초 (설정값)');
            
            this.updateCountdownUI(this.countdownSeconds);
            
            this.countdownTimer = setInterval(() => {
                this.countdownSeconds--;
                // console.log('[ContentSTT] ⏳ 카운트다운:', this.countdownSeconds);
                
                if (this.countdownSeconds > 0) {
                    this.updateCountdownUI(this.countdownSeconds);
                } else {
                    // console.log('[ContentSTT] 🚀 카운트다운 완료 → 자동 전송');
                    this.executeAutoSubmit();
                }
            }, 1000);
        }

        stopCountdown() {
            if (this.countdownTimer) {
                // console.log('[ContentSTT] 🛑 카운트다운 중지');
                clearInterval(this.countdownTimer);
                this.countdownTimer = null;
                this.countdownSeconds = 0;
                this.isCountdownActive = false; // 카운트다운 비활성화 플래그 해제
            }
            
            // 무음 감지 타이머도 정리
            if (this.silenceDetectionTimer) {
                clearTimeout(this.silenceDetectionTimer);
                this.silenceDetectionTimer = null;
            }
            
                
            // UI 복원 - 카운트다운이 아닌 상태에서만 복원
            // 카운트다운 중일 때는 UI 복원하지 않음 (카운트다운 텍스트 보존)
        }

        updateCountdownUI(seconds) {
            // VoiceInputManager의 버튼 상태 업데이트
            if (window.voiceInputManager && window.voiceInputManager.buttonManager) {
                const button = window.voiceInputManager.buttonManager;
                const message = `Sending in ${seconds}...`;
                
                try {
                    button.updateStatus('countdown', message);
                } catch (error) {
                    console.error('[ContentSTT] ❌ UI 업데이트 실패:', error);
                }
            }
        }

        updateRecordingUI() {
            // 녹음 중 상태로 UI 복원
            if (window.voiceInputManager && window.voiceInputManager.buttonManager) {
                const manager = window.voiceInputManager;
                const button = manager.buttonManager;
                try {
                    // 🔥 VoiceInputManager 상태도 동기화
                    manager.isRecording = true;
                    manager.isRecordingState = true;
                    
                    button.updateStatus('recording', 'Recording...');
                    // console.log('[ContentSTT] ✅ UI 상태를 Recording으로 업데이트');
                } catch (error) {
                    console.error('[ContentSTT] ❌ 녹음 UI 복원 실패:', error);
                }
            }
        }
        
        updateReadyUI() {
            // 중복 호출 방지
            if (this.isUIBeingRestored) {
                // console.log('[ContentSTT] ⚠️ UI 복원 중복 호출 방지');
                return;
            }
            
            this.isUIBeingRestored = true;
            
            // Ready 상태로 UI 복원
            if (window.voiceInputManager && window.voiceInputManager.buttonManager) {
                const manager = window.voiceInputManager;
                const button = manager.buttonManager;
                try {
                    // 🎯 VoiceInputManager 상태 초기화 (첫 클릭 문제 해결)
                    manager.isRecording = false;
                    manager.isRecordingState = false;
                    
                    button.updateStatus('ready', 'Ready');
                    // console.log('[ContentSTT] ✅ UI 상태를 Ready로 복원');
                } catch (error) {
                    console.error('[ContentSTT] ❌ Ready UI 복원 실패:', error);
                }
            }
            
            // 일정 시간 후 플래그 해제 (다음 세션을 위해)
            setTimeout(() => {
                this.isUIBeingRestored = false;
            }, 1000);
        }

        async executeAutoSubmit() {
            // 카운트다운 타이머 정리 (중복 방지)
            if (this.countdownTimer) {
                clearInterval(this.countdownTimer);
                this.countdownTimer = null;
                this.countdownSeconds = 0;
            }
            
            // input 요소 참조 보존 (stop() 호출 전에 저장)
            const inputElement = this.input;
            
            // STT 종료
            await this.stop();
            
            // 엔터키 이벤트로 자동 전송 (외부 셀렉터 제거)
            this.simulateEnterKeyPress(inputElement);
        }

        simulateEnterKeyPress(inputElement = null) {
            // 매개변수로 받은 input 요소 사용, 없으면 this.input 사용
            const targetInput = inputElement || this.input;
            
            if (!targetInput) {
                // console.warn('[ContentSTT] ⚠️ 입력 요소가 없어 엔터키 시뮬레이션 불가');
                return;
            }

            /* console.log('[ContentSTT] 🔍 엔터키 시뮬레이션 시작:', {
                tagName: targetInput.tagName,
                type: targetInput.type,
                id: targetInput.id,
                className: targetInput.className,
                value: targetInput.value?.substring(0, 50) + '...'
            }); */

            try {
                // 1. 입력 요소에 포커스 확실히 하기
                targetInput.focus();
                targetInput.click(); // 클릭으로 활성화 확인
                
                /* console.log('[ContentSTT] 🎯 포커스 상태:', {
                    activeElement: document.activeElement === targetInput,
                    hasFocus: targetInput === document.activeElement
                }); */

                // 2. 실제 사용자 타이핑을 모방한 순서로 이벤트 발생
                const keydownEvent = new KeyboardEvent('keydown', {
                    key: 'Enter',
                    keyCode: 13,
                    which: 13,
                    code: 'Enter',
                    charCode: 13,
                    bubbles: true,
                    cancelable: true,
                    composed: true,
                    isTrusted: false
                });

                const keypressEvent = new KeyboardEvent('keypress', {
                    key: 'Enter',
                    keyCode: 13,
                    which: 13,
                    code: 'Enter',
                    charCode: 13,
                    bubbles: true,
                    cancelable: true,
                    composed: true,
                    isTrusted: false
                });

                const keyupEvent = new KeyboardEvent('keyup', {
                    key: 'Enter',
                    keyCode: 13,
                    which: 13,
                    code: 'Enter',
                    charCode: 13,
                    bubbles: true,
                    cancelable: true,
                    composed: true,
                    isTrusted: false
                });

                // 순차적으로 이벤트 발생 (실제 키보드 입력 모방) - 한 번만!
                let keydownResult = targetInput.dispatchEvent(keydownEvent);
                // console.log(`[ContentSTT] 📤 keydown 결과:`, keydownResult);
                
                // keydown이 취소되지 않았을 때만 keypress 발생
                if (keydownResult) {
                    let keypressResult = targetInput.dispatchEvent(keypressEvent);
                    // console.log(`[ContentSTT] 📤 keypress 결과:`, keypressResult);
                }
                
                let keyupResult = targetInput.dispatchEvent(keyupEvent);
                // console.log(`[ContentSTT] 📤 keyup 결과:`, keyupResult);

                // 끝! 추가 이벤트나 대체 방법 없음 (물리 키보드 엔터 한 번만 시뮬레이션)
                
                // console.log('[ContentSTT] ✅ 엔터키 시뮬레이션 완료');
            } catch (error) {
                console.error('[ContentSTT] ❌ 엔터키 시뮬레이션 실패:', error);
            }
        }

        // ⚠️ 비활성화됨: 엔터키 한 번만으로 모든 사이트 호환성 확보
        // tryAlternativeSubmitMethods는 중복 전송을 일으켜 새로고침 문제 발생
        tryAlternativeSubmitMethods(targetInput) {
            // console.log('[ContentSTT] 🚫 대체 제출 방법 비활성화됨 - 엔터키 시뮬레이션만 사용');
            return;
        }


        handleRecordingError(error, data) {
            // 🚨 에러 발생 시에도 현재 텍스트 보존 (버그 수정)
            const preservedText = data?.preservedText || '';

            if (preservedText && preservedText.trim()) {
                // 🚨 버그 수정: 필드가 비어있었는데 이전 텍스트가 붙는 버그 방지
                let textToApply = preservedText;
                if (this.isFieldEmpty && preservedText.startsWith(this.prefixText || '')) {
                    // 이전 세션의 텍스트가 잘못 붙었을 경우 제거
                    textToApply = preservedText.substring((this.prefixText || '').length);
                }

                // 현재 입력 필드에 수정된 텍스트 적용
                if (this.input) {
                    this.updateInputValue(textToApply);
                }

                // Voice Memos에 백업 저장 (전체 텍스트)
                this.saveToVoiceMemos(preservedText.trim());
            }

            // 🚨 최대 재시도 초과 시에만 완전 중단
            if (data?.maxRetriesExceeded) {
                this.isRecording = false;
            }
            // else: isRecording 상태 유지하여 자동 복구 대기

            // Amplitude 이벤트 추가
            if (window.amplitude) {
                window.amplitude.trackEvent('Error Occurred', {
                    error_type: 'network',
                    error_message: error || 'unknown',
                    language: this.sttEngine?.language || 'ko-KR',
                    text_preserved: !!preservedText
                });
            }
        }

        isActive() {
            return this.isRecording;
        }

        // 🚨 새로운 메서드: 동시 녹음 차단 처리
        handleConcurrentRecordingBlocked(data) {
            const { blockingContext, requestingContext } = data;

            // 상태 초기화
            this.isRecording = false;

            // 🎯 컨텍스트별 알림 메시지
            let notificationKey = 'concurrentRecording';
            if (blockingContext === 'voice-memos') {
                notificationKey = 'concurrentRecordingVoiceMemos';
            } else if (blockingContext === 'content') {
                notificationKey = 'concurrentRecordingWebPage';
            }

            // 알림 표시
            try {
                this.showNotification(notificationKey);
            } catch (notificationError) {
                console.error(`[ContentSTTHandler] ❌ showNotification 실패:`, notificationError);

                // 폴백 알림 (브라우저 기본 alert)
                const fallbackMessage = window.herI18n ? window.herI18n.t(notificationKey) : '다른 곳에서 이미 녹음 중입니다.';
                setTimeout(() => alert(fallbackMessage), 100);
            }

            // 포커스 이동
            try {
                this.focusRecordingWindow(blockingContext);
            } catch (focusError) {
                console.error(`[ContentSTTHandler] ❌ 포커스 이동 실패:`, focusError);
            }
        }

        // 🚨 기존 에러 처리 메서드 (이중 보안)
        handleConcurrentRecordingError(error) {
            this.isRecording = false;
            this.showNotification('concurrentRecording');
            this.focusRecordingWindow(error.currentContext);
        }

        focusRecordingWindow(context) {
            try {
                if (context === 'voice-memos') {
                    // Voice Memos 팝업 창으로 포커스 시도
                    try {
                        // Chrome extension API를 통한 팝업 포커스 (가능한 경우)
                        if (chrome.windows && chrome.windows.getAll) {
                            chrome.windows.getAll({ populate: true }, (windows) => {
                                const voiceMemosWindow = windows.find(w =>
                                    w.tabs && w.tabs.some(t =>
                                        t.url && t.url.includes('voice-memos.html')
                                    )
                                );

                                if (voiceMemosWindow) {
                                    chrome.windows.update(voiceMemosWindow.id, { focused: true });
                                }
                            });
                        }
                    } catch (e) {
                        // Extension API 접근 불가 - 권한 제한
                    }

                } else if (context === 'content') {
                    // 현재 탭에서 녹음 중 - 현재 창에 포커스
                    window.focus();
                }

            } catch (e) {
                console.error('[ContentSTTHandler] 창 포커스 이동 실패:', e);
            }
        }

        showNotification(key) {
            // 🎯 개선된 알림 표시
            try {
                let message = key;
                if (window.herI18n && window.herI18n.t) {
                    message = window.herI18n.t(key);
                }

                // 🚨 더 눈에 띄는 토스트 메시지
                const toast = document.createElement('div');
                toast.style.cssText = `
                    position: fixed;
                    top: 20px;
                    right: 20px;
                    background: linear-gradient(135deg, #ff6b6b, #ff8e8e);
                    color: white;
                    padding: 16px 20px;
                    border-radius: 12px;
                    z-index: 2147483647;
                    font-size: 14px;
                    font-weight: 500;
                    max-width: 350px;
                    word-wrap: break-word;
                    box-shadow: 0 8px 32px rgba(255, 107, 107, 0.3);
                    border: 1px solid rgba(255, 255, 255, 0.2);
                    backdrop-filter: blur(10px);
                    animation: slideInFromRight 0.3s ease-out;
                `;

                // 애니메이션 추가
                const style = document.createElement('style');
                style.textContent = `
                    @keyframes slideInFromRight {
                        from {
                            transform: translateX(100%);
                            opacity: 0;
                        }
                        to {
                            transform: translateX(0);
                            opacity: 1;
                        }
                    }
                `;
                if (!document.querySelector('#content-stt-toast-style')) {
                    style.id = 'content-stt-toast-style';
                    document.head.appendChild(style);
                }

                toast.textContent = message;
                document.body.appendChild(toast);

                // 4초 후 자동 제거 (동시 녹음 알림은 더 오래 표시)
                const duration = key.includes('concurrent') ? 5000 : 3000;

                setTimeout(() => {
                    if (toast.parentNode) {
                        toast.style.animation = 'slideInFromRight 0.3s ease-out reverse';
                        setTimeout(() => {
                            if (toast.parentNode) {
                                toast.parentNode.removeChild(toast);
                            }
                        }, 300);
                    }
                }, duration);

            } catch (e) {
                console.error('[ContentSTTHandler] ❌ showNotification 실패:', e);

                // 에러 발생 시 폴백 알림
                try {
                    const fallbackMessage = window.herI18n ? window.herI18n.t(key) : key;

                    // 간단한 폴백 토스트
                    const fallbackToast = document.createElement('div');
                    fallbackToast.style.cssText = `
                        position: fixed;
                        top: 20px;
                        right: 20px;
                        background: #333;
                        color: white;
                        padding: 12px 16px;
                        border-radius: 8px;
                        z-index: 2147483647;
                        font-size: 14px;
                    `;
                    fallbackToast.textContent = fallbackMessage;
                    document.body.appendChild(fallbackToast);

                    setTimeout(() => {
                        if (fallbackToast.parentNode) {
                            fallbackToast.remove();
                        }
                    }, 3000);
                } catch (fallbackError) {
                    console.error(`[ContentSTTHandler] ❌ 폴백 알림도 실패:`, fallbackError);
                    // 최후 수단 - 브라우저 alert
                    setTimeout(() => alert(key), 100);
                }
            }
        }

        showBlockingNotification(blockingContext) {
            let message = '다른 곳에서 이미 녹음 중입니다.';

            if (blockingContext === 'voice-memos') {
                message = 'Voice Memos에서 이미 녹음 중입니다.';
            } else if (blockingContext === 'content') {
                message = '웹페이지에서 이미 녹음 중입니다.';
            }

            // 간단한 토스트만 표시
            const toast = document.createElement('div');
            toast.style.cssText = `
                position: fixed; top: 20px; right: 20px;
                background: #ff4444; color: white; padding: 12px 16px;
                border-radius: 8px; z-index: 2147483647; font-size: 14px;
            `;
            toast.textContent = message;
            document.body.appendChild(toast);

            setTimeout(() => toast.remove(), 3000);
        }
    }

    window.HerContentSTTHandler = new ContentSTTHandler();
})(); 