// Content Script 완전 수정 - 마이크 버튼 문제 해결
(function () {
    'use strict';

    const CONTENT_VERSION = '1.0.8';

    // 중복 로드 방지
    if (window.herContentLoaded) {
        // 같은 버전이면 건너뛰기
        if (window.herContentVersion === CONTENT_VERSION) {
            return;
        }
    }
    window.herContentLoaded = true;
    window.herContentVersion = CONTENT_VERSION;

    let voiceInputManager = null;

    async function initializeContentScript() {
        try {
            // 🔥 Extension context 유효성 체크
            if (!isExtensionContextValid()) {
                // console.warn('[Content] Extension context 무효화됨 - 스크립트 종료');
                return;
            }

            // 의존성 대기
            await waitForDependencies();
            
            // 🔥 HerGlobalState 폴백 생성 - 항상 생성
            if (!window.HerGlobalState) {
                window.HerGlobalState = {
                    tryStartRecording: () => true,
                    reset: () => {},
                    isRecording: () => false,
                    getState: () => ({ isRecording: false, sessionId: null, currentContext: null })
                };
            }

            // HerVoiceInputManager 체크 및 폴백
            if (window.HerVoiceInputManager) {
                voiceInputManager = new window.HerVoiceInputManager();
                window.HerInputManager = voiceInputManager;
                // 전역 참조도 등록 (UI 업데이트용)
                window.voiceInputManager = voiceInputManager;
            } else {
                // console.warn('[Content] HerVoiceInputManager 로드 실패 - 폴백 사용');
                const fallback = new FallbackVoiceInput();
                window.HerInputManager = fallback;
                window.voiceInputManager = fallback; // 폴백도 전역 등록
            }

            // 🎯 전역 녹음 메시지 리스너 설정 (context 유효할 때만)
            if (isExtensionContextValid()) {
                setupGlobalRecordingListener();
            }
        } catch (error) {
            console.error('Content Script 초기화 실패:', error);
            window.HerInputManager = new FallbackVoiceInput();
        }
    }

    // 🔥 Extension context 유효성 체크 함수
    function isExtensionContextValid() {
        try {
            // chrome.runtime이 존재하고 접근 가능한지 체크
            return !!(chrome && chrome.runtime && chrome.runtime.id);
        } catch (error) {
            return false;
        }
    }

    // 🎯 전역 녹음 메시지 리스너 설정
    function setupGlobalRecordingListener() {
        try {
            // 🔥 Extension context 재확인
            if (!isExtensionContextValid()) {
                // console.warn('[Content] Extension context 무효 - 메시지 리스너 설정 건너뜀');
                return;
            }

            chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
                // 🔥 메시지 처리 시에도 context 체크
                if (!isExtensionContextValid()) {
                    // console.warn('[Content] Extension context 무효 - 메시지 무시');
                    sendResponse({ success: false, error: 'Extension context invalid' });
                    return;
                }

                try {
                    // console.log('[Content] 📨 메시지 수신:', message.action);
                    
                    switch (message.action) {
                        case 'toggleFieldRecording':
                            // console.log('[Content] 🎯 텍스트 필드 녹음 토글 메시지 처리');
                            handleFieldRecordingToggle();
                            break;
                        case 'startGlobalRecording':
                            handleGlobalRecordingStart(message.sessionId);
                            break;
                        case 'stopGlobalRecording':
                            handleGlobalRecordingStop();
                            break;
                        default:
                            // console.log('[Content] 알 수 없는 메시지 액션:', message.action);
                    }
                } catch (error) {
                    console.error('[Content] 전역 녹음 메시지 처리 실패:', error);
                    sendResponse({ success: false, error: error.message });
                    return;
                }

                // 응답
                sendResponse({ success: true });
            });
        } catch (error) {
            console.error('[Content] 메시지 리스너 설정 실패:', error);
        }
    }

    // 🎯 텍스트 필드 녹음 토글 처리
    async function handleFieldRecordingToggle() {
        // console.log('[Content] 🎤 텍스트 필드 녹음 토글 시작');
        
        try {
            // 현재 포커스된 요소 찾기
            const activeElement = document.activeElement;
            // console.log('[Content] 현재 포커스된 요소:', activeElement?.tagName, activeElement?.type, activeElement?.contentEditable);
            
            // 텍스트 입력 필드인지 확인
            const isTextInput = activeElement && (
                (activeElement.tagName === 'INPUT' && 
                 ['text', 'email', 'password', 'search', 'url', 'tel'].includes(activeElement.type)) ||
                activeElement.tagName === 'TEXTAREA' || 
                activeElement.contentEditable === 'true'
            );
            
            if (isTextInput) {
                // console.log('[Content] ✅ 텍스트 입력 필드 감지됨');
                
                // Voice Input Manager를 통해 토글
                if (window.HerVoiceInputManager) {
                    
                    // 부모 컨테이너에서 마이크 버튼 찾기
                    let micButton = activeElement.parentElement?.querySelector('.her-mic-button');
                    
                    // 상위 요소들에서 마이크 버튼 찾기 (더 넓은 범위)
                    if (!micButton) {
                        let parent = activeElement.parentElement;
                        let depth = 0;
                        while (parent && depth < 5) {
                            micButton = parent.querySelector('.her-mic-button');
                            if (micButton) break;
                            parent = parent.parentElement;
                            depth++;
                        }
                    }
                    
                    if (micButton) {
                        // console.log('[Content] 🎯 마이크 버튼 찾음, 클릭 실행');
                        micButton.click();
                    } else {
                        // console.log('[Content] 🔧 마이크 버튼 없음 - VoiceInputManager로 필드 초기화 시도');
                        
                        // VoiceInputManager가 해당 필드를 아직 처리하지 않았을 수 있음
                        // 강제로 필드를 처리하도록 트리거
                        try {
                            // 1. VoiceInputManager의 checkInitialFocus 메서드 직접 호출
                            /* console.log('[Content] 🔍 VoiceInputManager 상태 체크:', {
                                hasVoiceInputManager: !!window.HerVoiceInputManager,
                                hasGetInstance: !!(window.HerVoiceInputManager?.getInstance),
                                instanceType: typeof window.HerVoiceInputManager?.getInstance
                            }); */
                            
                            if (window.HerVoiceInputManager && window.HerVoiceInputManager.getInstance) {
                                const manager = window.HerVoiceInputManager.getInstance();
                                /* console.log('[Content] 📋 Manager 인스턴스:', {
                                    hasManager: !!manager,
                                    hasCheckInitialFocus: !!(manager?.checkInitialFocus),
                                    managerType: typeof manager,
                                    managerKeys: manager ? Object.keys(manager) : []
                                }); */
                                
                                if (manager && manager.checkInitialFocus) {
                                    // console.log('[Content] 🔧 VoiceInputManager.checkInitialFocus() 직접 호출');
                                    manager.checkInitialFocus();
                                } else {
                                    // console.log('[Content] ❌ checkInitialFocus 메서드를 찾을 수 없음');
                                }
                            }
                            
                            // 2. 필드에 포커스 이벤트 트리거 (VoiceInputManager가 감지하도록)
                            activeElement.dispatchEvent(new Event('focus', { bubbles: true }));
                            activeElement.dispatchEvent(new Event('input', { bubbles: true }));
                            activeElement.dispatchEvent(new Event('click', { bubbles: true }));
                            
                            // 3. VoiceInputManager가 처리할 시간을 주고 다시 시도
                            setTimeout(() => {
                                let retryMicButton = activeElement.parentElement?.querySelector('.her-mic-button');
                                
                                // 더 넓은 범위에서 다시 찾기
                                if (!retryMicButton) {
                                    let parent = activeElement.parentElement;
                                    let depth = 0;
                                    while (parent && depth < 5) {
                                        retryMicButton = parent.querySelector('.her-mic-button');
                                        if (retryMicButton) break;
                                        parent = parent.parentElement;
                                        depth++;
                                    }
                                }
                                
                                if (retryMicButton) {
                                    // console.log('[Content] 🔄 재시도 성공, 마이크 버튼 클릭');
                                    retryMicButton.click();
                                } else {
                                    // console.log('[Content] ❌ 재시도 후에도 마이크 버튼을 찾을 수 없음');
                                    /* console.log('[Content] 📍 디버그 정보:', {
                                        element: activeElement.tagName,
                                        type: activeElement.type,
                                        id: activeElement.id,
                                        class: activeElement.className,
                                        parentClass: activeElement.parentElement?.className,
                                        voiceInputManager: !!window.HerVoiceInputManager,
                                        getInstance: !!(window.HerVoiceInputManager?.getInstance),
                                        managerInstance: !!(window.HerVoiceInputManager?.getInstance?.())
                                    }); */
                                    
                                    // 4. 최후의 방법: ContentSTTHandler 직접 사용
                                    if (window.HerContentSTTHandler) {
                                        // console.log('[Content] 🚑 최후 수단: ContentSTTHandler 직접 사용');
                                        try {
                                            // HerContentSTTHandler는 싱글톤 인스턴스 - new 사용하지 않음
                                            const success = window.HerContentSTTHandler.start(activeElement, 
                                                (data) => { 
                                                    // console.log('[Content] STT 업데이트:', data); 
                                                },
                                                (error) => { 
                                                    console.error('[Content] STT 오류:', error); 
                                                }
                                            );
                                            // console.log('[Content] ✅ ContentSTTHandler 직접 시작:', success);
                                        } catch (sttError) {
                                            console.error('[Content] ContentSTTHandler 직접 사용 실패:', sttError);
                                        }
                                    } else {
                                        // console.log('[Content] ❌ HerContentSTTHandler를 찾을 수 없음');
                                    }
                                }
                            }, 300);
                        } catch (error) {
                            console.error('[Content] 필드 초기화 시도 중 오류:', error);
                        }
                    }
                } else {
                    // console.log('[Content] ⚠️ HerVoiceInputManager가 없음');
                }
            } else {
                // console.log('[Content] 🔇 텍스트 입력 필드가 포커스되지 않음 - 단축키 무시');
                // 포커스되지 않은 경우 조용히 무시 (알림 없음)
            }
        } catch (error) {
            console.error('[Content] 텍스트 필드 녹음 토글 실패:', error);
        }
    }

    // 🎯 전역 녹음 시작 처리
    async function handleGlobalRecordingStart(sessionId) {
        // console.log('[Content] 전역 녹음 시작:', sessionId);

        try {
            // 전역 상태에서 녹음 시작 시도
            const success = window.HerGlobalState.tryStartRecording(sessionId, 'global');
            
            if (!success) {
                // console.log('[Content] 다른 곳에서 이미 녹음 중');
                return;
            }

            // STT 엔진 시작
            if (window.HerSTTEngine) {
                const sttEngine = window.HerSTTEngine.getInstance();
                
                // 콜백 설정
                const onUpdateCallback = (sttData) => {
                    const text = sttData.text || '';
                    // console.log('[Content] 전역 녹음 텍스트 업데이트:', text.length, '글자');
                };

                const onStateChangeCallback = (state, data) => {
                    // console.log('[Content] 전역 녹음 상태 변경:', state);
                    if (state === 'stop') {
                        const resultText = data?.text || '';
                        handleGlobalRecordingComplete(resultText);
                    }
                };

                sttEngine.setCallbacks(onUpdateCallback, onStateChangeCallback);
                await sttEngine.start(sessionId, 'global', { preserveText: false });

                // console.log('[Content] 전역 녹음 시작 완료');
            }

        } catch (error) {
            console.error('[Content] 전역 녹음 시작 실패:', error);
            window.HerGlobalState.reset();
        }
    }

    // 🎯 전역 녹음 중지 처리
    async function handleGlobalRecordingStop() {
        // console.log('[Content] 전역 녹음 중지');

        try {
            if (window.HerSTTEngine) {
                const sttEngine = window.HerSTTEngine.getInstance();
                await sttEngine.stop();
            }

            window.HerGlobalState.reset();
            // console.log('[Content] 전역 녹음 중지 완료');

        } catch (error) {
            console.error('[Content] 전역 녹음 중지 실패:', error);
        }
    }

    // 🎯 전역 녹음 완료 처리
    async function handleGlobalRecordingComplete(text) {
        // console.log('[Content] 전역 녹음 완료:', text.length, '글자');

        try {
            if (text && text.trim()) {
                // 클립보드에 복사
                await navigator.clipboard.writeText(text.trim());
                // console.log('[Content] 클립보드 복사 완료');

                // 사용자에게 알림
                showGlobalRecordingNotification('녹음이 완료되었습니다. 클립보드에 복사되었습니다.');

                // Amplitude 이벤트
                if (window.amplitude) {
                    window.amplitude.trackEvent('Global Recording Completed', {
                        text_length: text.length,
                        source: 'keyboard_shortcut'
                    });
                }
            }

            window.HerGlobalState.reset();

        } catch (error) {
            console.error('[Content] 전역 녹음 완료 처리 실패:', error);
        }
    }

    // 🎯 전역 녹음 알림 표시
    function showGlobalRecordingNotification(message) {
        const notification = document.createElement('div');
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            background: linear-gradient(135deg, #4CAF50, #45a049);
            color: white;
            padding: 16px 20px;
            border-radius: 12px;
            font-size: 14px;
            font-weight: 500;
            z-index: 2147483647;
            max-width: 300px;
            word-wrap: break-word;
            box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3);
            border: 1px solid rgba(255, 255, 255, 0.2);
            backdrop-filter: blur(10px);
            animation: slideInFromTop 0.3s ease-out;
        `;

        // 애니메이션 스타일 추가
        if (!document.querySelector('#global-recording-notification-style')) {
            const style = document.createElement('style');
            style.id = 'global-recording-notification-style';
            style.textContent = `
                @keyframes slideInFromTop {
                    from {
                        transform: translateY(-100%);
                        opacity: 0;
                    }
                    to {
                        transform: translateY(0);
                        opacity: 1;
                    }
                }
            `;
            document.head.appendChild(style);
        }

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

        // 4초 후 자동 제거
        setTimeout(() => {
            if (notification.parentNode) {
                notification.style.animation = 'slideInFromTop 0.3s ease-out reverse';
                setTimeout(() => {
                    if (notification.parentNode) {
                        notification.parentNode.removeChild(notification);
                    }
                }, 300);
            }
        }, 4000);
    }

    function waitForDependencies() {
        return new Promise((resolve) => {
            let attempts = 0;
            const maxAttempts = 50; // 5초로 단축
            const essentialDeps = ['HerVoiceInputManager']; // 필수 의존성만
            const optionalDeps = [
                'herI18n',
                'herSVGIcons', 
                'HerSTTEngine',
                'HerContentSTTHandler'
            ];

            const check = () => {
                attempts++;
                
                // 🔥 Extension context 무효화되면 즉시 종료
                if (!isExtensionContextValid()) {
                    // console.warn('[Content] Extension context 무효화 - 의존성 대기 중단');
                    resolve();
                    return;
                }

                const missingEssential = essentialDeps.filter(dep => !window[dep]);
                const missingOptional = optionalDeps.filter(dep => !window[dep]);
                
                // 필수 의존성이 모두 로드되었거나 타임아웃 되면 진행
                if (missingEssential.length === 0) {
                    if (missingOptional.length > 0) {
                        // console.warn('[Content] ⚠️ 선택적 의존성 누락:', missingOptional);
                    }
                    resolve();
                } else if (attempts >= maxAttempts) {
                    console.error('[Content] ❌ 필수 의존성 로딩 타임아웃:', missingEssential);
                    // console.warn('[Content] 폴백 모드로 진행');
                    resolve(); // 타임아웃이어도 진행
                } else {
                    if (attempts % 10 === 1) { // 1초마다 한번씩 로그 출력
                        // console.info(`[Content] ⏳ 의존성 대기 중 (${attempts}/${maxAttempts}) - 필수:`, missingEssential);
                    }
                    setTimeout(check, 100);
                }
            };
            check();
        });
    }

    // 폴백 매니저 클래스 - 에러 방지를 위해 더 완전하게 구현
    class FallbackVoiceInput {
        constructor() {
            this.isRecording = false;
            this.buttonManager = {
                isVisible: false,
                container: null,
                hide: () => {},
                showAt: () => {},
                setRecording: () => {},
                updateStatus: () => {}
            };
        }
        
        toggleRecording() {
            if (this.isRecording) {
                // console.info('[Content] 폴백: 녹음 중지');
                this.isRecording = false;
            } else {
                // console.info('[Content] 폴백: 녹음 시작');
                this.isRecording = true;
            }
        }
        
        // HerVoiceInputManager와 호환성을 위한 메서드들
        showButtonForInput() {}
        hideButton() {}
        startRecording() {}
        stopRecording() {}
        getAllValidInputs() { return []; }
    }

    // 페이지 로드 상태에 따른 초기화
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initializeContentScript);
    } else {
        setTimeout(initializeContentScript, 100);
    }
})();