// Background Script 수정 (단일 창 관리)
(function () {
    'use strict';

    if (self.HerBackground) {
        return;
    }

    // Service Worker에서는 간단한 폴백 상태 관리자만 생성
    if (!self.HerGlobalState) {
        self.HerGlobalState = {
            state: { isRecording: false, currentSessionId: null, currentContext: null, currentTabId: null },
            getState() { return { ...this.state }; },
            setState(newState) { this.state = { ...this.state, ...newState }; },
            reset() { this.state = { isRecording: false, currentSessionId: null, currentContext: null, currentTabId: null }; }
        };
    }

    // Amplitude 매니저 클래스를 인라인으로 정의
    class AmplitudeManager {
        constructor() {
            this.API_KEY = '84d2fa4adcfc257c6874a3db2f80f9d0';
            this.ENDPOINT = 'https://api2.amplitude.com/2/httpapi';
            this.USER_ID_KEY = 'her_user_id';
        }

        async getOrCreateUserId() {
            const result = await chrome.storage.local.get([this.USER_ID_KEY]);
            if (result[this.USER_ID_KEY]) {
                return result[this.USER_ID_KEY];
            }
            const newUserId = crypto.randomUUID();
            await chrome.storage.local.set({ [this.USER_ID_KEY]: newUserId });
            return newUserId;
        }

        async trackEvent(eventType, eventProperties = {}) {
            try {
                const userId = await this.getOrCreateUserId();

                const event = {
                    user_id: userId,
                    event_type: eventType,
                    time: Date.now(),
                    platform: 'Chrome Extension',
                    app_version: chrome.runtime.getManifest().version,
                    language: navigator.language,
                    event_properties: eventProperties
                };

                this.sendRequest([event]);
            } catch (error) {
                console.error(`[Amplitude] Failed to track event: ${eventType}`, error);
            }
        }

        async setUserProperties(properties) {
            try {
                const userId = await this.getOrCreateUserId();
                const identifyEvent = {
                    user_id: userId,
                    event_type: '$identify',
                    user_properties: {
                        '$set': properties
                    }
                };
                this.sendRequest([identifyEvent]);
            } catch (error) {
                console.error('[Amplitude] Failed to set user properties', error);
            }
        }

        async incrementUserProperty(property, value = 1) {
            try {
                const userId = await this.getOrCreateUserId();
                const identifyEvent = {
                    user_id: userId,
                    event_type: '$identify',
                    user_properties: {
                        '$add': { [property]: value }
                    }
                };
                this.sendRequest([identifyEvent]);
            } catch (error) {
                console.error(`[Amplitude] Failed to increment property: ${property}`, error);
            }
        }

        async setUserPropertiesOnce(properties) {
            try {
                const userId = await this.getOrCreateUserId();
                const identifyEvent = {
                    user_id: userId,
                    event_type: '$identify',
                    user_properties: {
                        '$setOnce': properties
                    }
                };
                this.sendRequest([identifyEvent]);
            } catch (error) {
                console.error('[Amplitude] Failed to set user properties once', error);
            }
        }

        async sendRequest(events) {
            const payload = {
                api_key: this.API_KEY,
                events: events
            };

            fetch(this.ENDPOINT, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*'
                },
                body: JSON.stringify(payload)
            }).catch(error => {
                console.error('[Amplitude] Network request failed', error);
            });
        }
    }

    const amplitude = new AmplitudeManager();

    class HerBackground {
        constructor() {
            this.VOICE_MEMO_WINDOW_ID = 'her-voice-memo-window'; // 고정 창 ID
            this.voiceMemoWindowId = null; // 실제 브라우저 창 ID 추적
            this.init();
        }

        get contentScripts() {
            return [
                'core/global-state-manager.js',
                'core/logger.js',
                'core/amplitude-manager.js',
                'core/svg-icons.js',
                'core/i18n.js',
                'core/stt-engine.js',
                'core/domain-config.js',
                'core/ai-providers-loader.js',
                'core/content-stt-handler.js',
                'ui/components/voice-input-manager.js',
                'content.js'
            ];
        }

        get contentCSS() {
            return ['styles/components.css', 'styles/vibe-coding.css'];
        }

        init() {
            // 🚨 브라우저 시작 시 전역 상태 강제 초기화
            this.clearGlobalRecordingState();

            // 설치/업데이트 이벤트
            chrome.runtime.onInstalled.addListener(details => {
                this.onInstalled(details);
            });

            // 메시지 리스너 추가
            chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
                if (message.action === 'openVoiceMemos') {
                    this.openVoiceMemos().then(response => {
                        sendResponse(response);
                    });
                    return true; // 비동기 응답을 위해 true 반환
                }
            });

            // 탭 업데이트 이벤트
            chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
                if (
                    changeInfo.status === 'complete' &&
                    tab.url &&
                    (tab.url.startsWith('http://') || tab.url.startsWith('https://'))
                ) {
                    // 접근 불가능한 URL 패턴들을 미리 필터링
                    const restrictedPatterns = [
                        'chrome://',
                        'chrome-extension://',
                        'moz-extension://',
                        'about:',
                        'file://',
                        'chrome-search://',
                        'edge://',
                        'opera://',
                        'vivaldi://',
                        'brave://'
                    ];

                    const isRestricted = restrictedPatterns.some(pattern => tab.url.startsWith(pattern));
                    if (!isRestricted) {
                        this.injectScripts(tabId);
                    }
                }
            });

            // 컨텍스트 메뉴 클릭 이벤트
            chrome.contextMenus.onClicked.addListener((info, tab) => {
                this.handleContextMenuClick(info, tab);
            });

            // 윈도우 닫힘 이벤트 (음성 메모 창 추적)
            chrome.windows.onRemoved.addListener((windowId) => {
                if (windowId === this.voiceMemoWindowId) {
                    this.voiceMemoWindowId = null;
                }
            });

            // 🎯 전역 단축키 핸들러 추가
// console.log('[HerBackground] 🚀 단축키 리스너 등록 시작');
            chrome.commands.onCommand.addListener((command) => {
// console.log('[HerBackground] ⚡ 단축키 이벤트 수신:', command, new Date().toISOString());
                this.handleGlobalCommand(command);
            });
            
            // 단축키 설정 확인
            chrome.commands.getAll((commands) => {
// console.log('[HerBackground] 🔧 현재 등록된 단축키:', commands);
            });

            // Storage 이벤트 처리
            this.setupStorageHandlers();
        }

        clearGlobalRecordingState() {
            // console.log(`[HerBackground] 🧹 전역 STT 상태 강제 초기화`);
            if (self.HerGlobalState) {  // window -> self로 변경
                self.HerGlobalState.reset();
                // console.log(`[HerBackground] ✅ 전역 상태 초기화 완료`);
            }
        }

        setupStorageHandlers() {
            // Voice Memos와 Content가 직접 storage 사용하므로 중간 핸들러 불필요
            // 모든 console.log를 제거합니다. 오류/예외 상황(console.error 등)은 남깁니다.
            chrome.storage.onChanged.addListener((changes, namespace) => {
                if (changes.uiLanguageChanged) {
                    // 필요하다면 확장 프로그램 리로드 로직 추가 가능
                    // chrome.runtime.reload(); // 개발 중에만 사용 권장
                }
            });
        }

        async handleSaveRequest(recordData) {
            if (!recordData) return;

            try {
                const record = {
                    id: recordData.id || Date.now(),
                    text: recordData.text,
                    domain: recordData.domain || 'Voice Memos',
                    timestamp: recordData.timestamp || new Date().toISOString(),
                    lang: recordData.lang || 'ko-KR'
                };

                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 });
                await chrome.storage.local.set({ voiceRecordSaveResponse: { success: true, record } });

            } catch (error) {
                console.error('[Her] 저장 실패:', error);
                await chrome.storage.local.set({ voiceRecordSaveResponse: { success: false, error: error.message } });
            }
        }

        async handleDeleteRequest(requestData) {
            if (!requestData) return;

            try {
                const result = await chrome.storage.local.get(['voiceRecords']);
                const voiceRecords = result.voiceRecords || [];
                const filteredRecords = voiceRecords.filter(record => record.id !== requestData.recordId);

                await chrome.storage.local.set({ voiceRecords: filteredRecords });
                await chrome.storage.local.set({ voiceRecordDeleteResponse: { success: true } });

            } catch (error) {
                console.error('[Her] 삭제 실패:', error);
                await chrome.storage.local.set({ voiceRecordDeleteResponse: { success: false, error: error.message } });
            }
        }

        async handleClearRequest() {
            try {
                await chrome.storage.local.set({ voiceRecords: [] });
                await chrome.storage.local.set({ voiceRecordClearResponse: { success: true } });
            } catch (error) {
                console.error('[Her] 전체 삭제 실패:', error);
                await chrome.storage.local.set({ voiceRecordClearResponse: { success: false, error: error.message } });
            }
        }

        async injectScripts(tabId) {
            try {
                // 권한 체크 없이 바로 주입 시도
                await chrome.scripting.insertCSS({
                    target: { tabId: tabId },
                    files: this.contentCSS
                });

                for (const file of this.contentScripts) {
                    await chrome.scripting.executeScript({
                        target: { tabId: tabId },
                        files: [file]
                    });
                }

            } catch (err) {
                // 접근 불가능한 페이지는 무시 (더 포괄적인 에러 패턴 추가)
                const ignorableErrors = [
                    'Cannot access contents of the page',
                    'Extension manifest must request permission',
                    'Cannot access a chrome://',
                    'Cannot access chrome-extension://',
                    'No matching window',
                    'The tab was closed',
                    'The extensions gallery cannot be scripted',
                    'Cannot access a moz-extension://',
                    'Cannot access a about:',
                    'Cannot access a file://',
                    'Cannot access a chrome-search://',
                    'Cannot access a edge://',
                    'Cannot access a opera://',
                    'Cannot access a vivaldi://',
                    'Cannot access a brave://',
                    'Frame with ID 0 is showing error page',
                    'The page is not accessible',
                    'Cannot access chrome://newtab/',
                    'Cannot access chrome://settings/',
                    'Cannot access chrome://extensions/',
                    'The tab does not exist',
                    'Cannot script PDF viewer'
                ];

                const isIgnorable = ignorableErrors.some(error =>
                    err.message && err.message.includes(error)
                );

                if (!isIgnorable) {
                    console.error(`[Her] 스크립트 주입 실패 tab ${tabId}:`, err);
                }
            }
        }

        async onInstalled(details) {
            // 🚨 설치 또는 업데이트 시 전역 상태 강제 초기화
            this.clearGlobalRecordingState();

            // Amplitude 이벤트 추가
            if (details.reason === 'install') {
                amplitude.setUserPropertiesOnce({
                    first_seen_date: new Date().toISOString().slice(0, 10)
                });
                amplitude.trackEvent('App Installed', {
                    default_ui_language: 'ko',
                    default_stt_language: 'ko-KR'
                });
            } else if (details.reason === 'update') {
                amplitude.trackEvent('App Updated', {
                    previous_version: details.previousVersion,
                    new_version: chrome.runtime.getManifest().version
                });
            }

            // 컨텍스트 메뉴 생성
            this.createContextMenus();

            // 기존 탭에 스크립트 주입
            if (details.reason === 'install' || details.reason === 'update') {
                try {
                    const tabs = await chrome.tabs.query({ url: ["http://*/*", "https://*/*"] });
                    for (const tab of tabs) {
                        await this.injectScripts(tab.id);
                    }
                } catch (error) {
                    console.error('[Her] 기존 탭 스크립트 주입 실패:', error);
                }
            }

            // 초기 설정
            if (details.reason === 'install') {
                const systemLanguage = this.detectSystemLanguage();
                const defaultSettings = {
                    voiceIntelligenceEnabled: true,
                    selectedLanguage: systemLanguage,
                    uiLanguage: systemLanguage.startsWith('ko') ? 'ko' : 'en'
                };
                await chrome.storage.sync.set(defaultSettings);
            }
        }

        detectSystemLanguage() {
            const lang = chrome.i18n.getUILanguage().split('-')[0];
            return lang === 'ko' ? 'ko-KR' : 'en-US';
        }

        createContextMenus() {
            chrome.contextMenus.removeAll(() => {
                chrome.contextMenus.create({
                    id: "her-main",
                    title: "Her - AI Voice Assistant",
                    contexts: ["editable"]
                });
                chrome.contextMenus.create({
                    id: "toggle-voice-intelligence",
                    parentId: "her-main",
                    title: "음성 입력 토글",
                    contexts: ["editable"]
                });
                chrome.contextMenus.create({
                    id: "open-voice-memos",
                    parentId: "her-main",
                    title: "음성 메모 열기",
                    contexts: ["editable"]
                });
            });
        }

        async handleContextMenuClick(info, tab) {
            try {
                // Amplitude 이벤트 추가
                amplitude.trackEvent('Context Menu Clicked', {
                    menu_item_id: info.menuItemId,
                    page_domain: tab.url ? new URL(tab.url).hostname : 'unknown'
                });

                switch (info.menuItemId) {
                    case "toggle-voice-intelligence":
                        await this.toggleVoiceIntelligence();
                        break;
                    case "open-voice-memos":
                        await this.openVoiceMemos();
                        break;
                }
            } catch (error) {
                console.error('[Her] 컨텍스트 메뉴 처리 실패:', error);
            }
        }

        async toggleVoiceIntelligence() {
            try {
                const { voiceIntelligenceEnabled } = await chrome.storage.sync.get('voiceIntelligenceEnabled');
                const newState = !voiceIntelligenceEnabled;
                await chrome.storage.sync.set({ voiceIntelligenceEnabled: newState });
            } catch (error) {
                console.error('[Her] 토글 실패:', error);
            }
        }

        async openVoiceMemos() {

            try {
                // 🎯 기존 창이 있는지 확인 (고정 ID 사용)
                if (this.voiceMemoWindowId) {
                    try {
                        // 기존 창 존재 확인 및 포커스
                        await chrome.windows.update(this.voiceMemoWindowId, {
                            focused: true,
                            state: 'normal'
                        });
                        return { success: true, windowId: this.voiceMemoWindowId, action: 'focused' };
                    } catch (error) {
                        // 창이 없어졌으면 ID 초기화
                        this.voiceMemoWindowId = null;
                    }
                }

                // ✨ 새 창 생성 (고정 URL로)

                // Amplitude 이벤트
                amplitude.incrementUserProperty('total_sessions');
                amplitude.setUserProperties({
                    last_seen_date: new Date().toISOString().slice(0, 10)
                });
                amplitude.trackEvent('Session Started', {
                    session_source: 'background'
                });

                const newWindow = await chrome.windows.create({
                    url: chrome.runtime.getURL('ui/voice-memos/voice-memos.html'),
                    type: 'popup',
                    width: 400,
                    height: 800,
                    focused: true,
                    state: 'normal'
                });

                // 창 ID 저장
                this.voiceMemoWindowId = newWindow.id;

                return { success: true, windowId: newWindow.id, action: 'created' };

            } catch (error) {
                console.error('[Her] 음성 메모 창 열기 실패:', error);
                this.voiceMemoWindowId = null;
                return { success: false, error: error.message };
            }
        }

        // 🎯 전역 단축키 명령어 핸들러
        async handleGlobalCommand(command) {
            // console.log(`[HerBackground] 🎯 단축키 명령어 실행: ${command}`, {
            //     timestamp: new Date().toISOString(),
            //     command: command
            // });

            try {
                switch (command) {
                    case 'toggle-field-recording':
// console.log('[HerBackground] 🎤 텍스트 필드 녹음 토글');
                        await this.handleFieldRecordingToggle();
                        break;
                    case 'toggle-memo-recording':
// console.log('[HerBackground] 📝 음성 메모 녹음 토글');
                        await this.handleMemoRecordingToggle();
                        break;
                    default:
// console.log(`[HerBackground] ⚠️ 알 수 없는 명령어: ${command}`);
                }
            } catch (error) {
                console.error('[HerBackground] 전역 명령어 처리 실패:', error);
            }
        }

        // 🎯 텍스트 필드 녹음 토글 처리
        async handleFieldRecordingToggle() {
// console.log('[HerBackground] 🔍 텍스트 필드 녹음 토글 시작');

            try {
                // 현재 활성 탭 가져오기
                const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
// console.log('[HerBackground] 활성 탭:', activeTab?.url, activeTab?.id);
                
                if (!activeTab) {
// console.log('[HerBackground] ❌ 활성 탭을 찾을 수 없음');
                    return;
                }

                // Chrome 내부 페이지에서는 조용히 스킵
                if (activeTab.url && (activeTab.url.startsWith('chrome://') || 
                                     activeTab.url.startsWith('chrome-extension://') ||
                                     activeTab.url.startsWith('edge://') ||
                                     activeTab.url.startsWith('about:'))) {
// console.log('[HerBackground] 🔇 Chrome 내부 페이지 - 단축키 스킵');
                    return;
                }

                // 활성 탭에 텍스트 필드 녹음 토글 메시지 전송
                try {
                    await chrome.tabs.sendMessage(activeTab.id, {
                        action: 'toggleFieldRecording',
                        source: 'keyboard_shortcut'
                    });
                    
// console.log('[HerBackground] ✅ 메시지 전송 성공');

                    // Amplitude 이벤트
                    amplitude.trackEvent('Field Recording Toggled', {
                        source: 'keyboard_shortcut',
                        tab_url: activeTab.url
                    });
                } catch (messageError) {
// console.log('[HerBackground] 🔇 Content script 없음 - 단축키 스킵:', messageError.message);
                    // Content script가 없는 페이지에서는 조용히 무시
                }

            } catch (error) {
                console.error('[HerBackground] 텍스트 필드 녹음 토글 실패:', error);
            }
        }

        // 🎯 음성 메모 녹음 토글 처리
        async handleMemoRecordingToggle() {
// console.log('[HerBackground] 📝 음성 메모 녹음 토글 처리 시작');

            try {
                // 음성 메모 창이 열려있는지 확인
                if (this.voiceMemoWindowId) {
                    try {
                        const window = await chrome.windows.get(this.voiceMemoWindowId);
                        // 창이 존재하면 토글 메시지 전송
                        const tabs = await chrome.tabs.query({ windowId: this.voiceMemoWindowId });
                        if (tabs && tabs.length > 0) {
                            await chrome.tabs.sendMessage(tabs[0].id, {
                                action: 'toggleMemoRecording',
                                source: 'keyboard_shortcut'
                            });

                            // Amplitude 이벤트
                            amplitude.trackEvent('Memo Recording Toggled', {
                                source: 'keyboard_shortcut',
                                window_state: 'existing'
                            });
                        }
                    } catch (e) {
                        // 창이 없으면 새로 열고 녹음 시작
// console.log('[HerBackground] 💾 음성 메모 창 없음 - 새로 열고 녹음 시작');
                        await this.openVoiceMemosAndStartRecording();
                        
                        // Amplitude 이벤트
                        amplitude.trackEvent('Memo Recording Toggled', {
                            source: 'keyboard_shortcut',
                            window_state: 'new_with_auto_start'
                        });
                    }
                } else {
                    // 음성 메모 창 열고 즉시 녹음 시작
// console.log('[HerBackground] 🚀 음성 메모 창 열고 즉시 녹음 시작');
                    await this.openVoiceMemosAndStartRecording();
                    
                    // Amplitude 이벤트
                    amplitude.trackEvent('Memo Recording Toggled', {
                        source: 'keyboard_shortcut',
                        window_state: 'new_with_auto_start'
                    });
                }

            } catch (error) {
                console.error('[HerBackground] 음성 메모 녹음 토글 실패:', error);
            }
        }

        // 🎯 음성 메모 창 열고 즉시 녹음 시작
        async openVoiceMemosAndStartRecording() {
            try {
// console.log('[HerBackground] 🎬 음성 메모 창 열고 자동 녹음 시작');
                
                // 먼저 창을 열기
                const result = await this.openVoiceMemos();
                
                if (result.success && this.voiceMemoWindowId) {
                    // 창이 로드될 때까지 잠시 대기
                    await new Promise(resolve => setTimeout(resolve, 500));
                    
                    // 새로 열린 창에 즉시 녹음 시작 메시지 전송
                    try {
                        const tabs = await chrome.tabs.query({ windowId: this.voiceMemoWindowId });
                        if (tabs && tabs.length > 0) {
                            await chrome.tabs.sendMessage(tabs[0].id, {
                                action: 'startImmediateRecording',
                                source: 'keyboard_shortcut_auto'
                            });
// console.log('[HerBackground] ✅ 자동 녹음 시작 메시지 전송 완료');
                        }
                    } catch (messageError) {
// console.log('[HerBackground] ⚠️ 자동 녹음 시작 메시지 전송 실패 - 창이 아직 준비되지 않음:', messageError.message);
                        // 한 번 더 시도
                        setTimeout(async () => {
                            try {
                                const tabs = await chrome.tabs.query({ windowId: this.voiceMemoWindowId });
                                if (tabs && tabs.length > 0) {
                                    await chrome.tabs.sendMessage(tabs[0].id, {
                                        action: 'startImmediateRecording',
                                        source: 'keyboard_shortcut_auto_retry'
                                    });
// console.log('[HerBackground] ✅ 자동 녹음 시작 재시도 성공');
                                }
                            } catch (retryError) {
// console.log('[HerBackground] ❌ 자동 녹음 시작 재시도도 실패:', retryError.message);
                            }
                        }, 1000);
                    }
                }
                
                return result;
            } catch (error) {
                console.error('[HerBackground] 음성 메모 창 열고 자동 녹음 시작 실패:', error);
                return { success: false, error: error.message };
            }
        }

        // 🎯 전역 녹음 시작
        async startGlobalRecording(activeTab) {
            try {
                // 전역 상태에서 녹음 시작 시도
                const sessionId = `global-${Date.now()}`;
                const success = self.HerGlobalState.tryStartRecording(sessionId, 'global');

                if (!success) {
                    // console.log('[HerBackground] 다른 곳에서 이미 녹음 중');
                    // 사용자에게 알림
                    this.showGlobalNotification('다른 곳에서 이미 녹음 중입니다.');
                    return;
                }

                // 활성 탭에 녹음 시작 메시지 전송
                await chrome.tabs.sendMessage(activeTab.id, {
                    action: 'startGlobalRecording',
                    sessionId: sessionId
                });

                // Amplitude 이벤트
                amplitude.trackEvent('Global Recording Started', {
                    source: 'keyboard_shortcut',
                    tab_url: activeTab.url
                });

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

            } catch (error) {
                console.error('[HerBackground] 전역 녹음 시작 실패:', error);
                // 상태 복구
                self.HerGlobalState.reset();
            }
        }

        // 🎯 전역 녹음 중지
        async stopGlobalRecording(activeTab) {
            try {
                // 활성 탭에 녹음 중지 메시지 전송
                await chrome.tabs.sendMessage(activeTab.id, {
                    action: 'stopGlobalRecording'
                });

                // 전역 상태 초기화
                self.HerGlobalState.reset();

                // Amplitude 이벤트
                amplitude.trackEvent('Global Recording Stopped', {
                    source: 'keyboard_shortcut',
                    tab_url: activeTab.url
                });

                // console.log('[HerBackground] 전역 녹음 중지 완료');

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

        // 🎯 전역 알림 표시
        showGlobalNotification(message) {
            // 간단한 토스트 알림을 위한 임시 창 생성
            chrome.windows.create({
                url: `data:text/html,<html><body style="margin:0;padding:20px;background:#ff4444;color:white;font-family:Arial;font-size:14px;">${message}</body></html>`,
                type: 'popup',
                width: 300,
                height: 100,
                focused: false
            });

            // 3초 후 자동 닫기
            setTimeout(() => {
                chrome.windows.getAll({ windowTypes: ['popup'] }, (windows) => {
                    windows.forEach(window => {
                        if (window.tabs && window.tabs[0] && window.tabs[0].url.startsWith('data:text/html')) {
                            chrome.windows.remove(window.id);
                        }
                    });
                });
            }, 3000);
        }
    }

    // Service Worker 전역 객체에 등록
    self.HerBackground = HerBackground;

    // 인스턴스 생성
    new HerBackground();

})();