app.py

import os
import time
import base64
import json
import traceback
import threading
import subprocess
import sys
from typing import Tuple, Optional
import gradio as gr
import anthropic
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime

# Hugging Face Space 환경 확인
IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
print(f'IS_HUGGINGFACE = {IS_HUGGINGFACE}')

# Claude API 설정
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

if not ANTHROPIC_API_KEY:
    print("ANTHROPIC_API_KEY가 설정되지 않음, Secret 확인 필요")
else:
    print("Claude API 키 확인 완료")

def create_claude_client():
    try:
        client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
        print("Claude API 클라이언트 생성 성공")
        return client
    except Exception as e:
        print(f"Claude API 클라이언트 생성 실패: {e}")
        return None

def install_system_dependencies():
    """시스템 의존성 설치 시도"""
    try:
        print("시스템 의존성 설치 시도 중...")
        
        # 필수 패키지 목록
        packages = [
            "libnss3",
            "libnspr4", 
            "libatk1.0-0",
            "libatk-bridge2.0-0",
            "libcups2",
            "libatspi2.0-0",
            "libxcomposite1",
            "libxdamage1",
            "libxrandr2",
            "libgconf-2-4",
            "libxss1",
            "libgtk-3-0",
            "libasound2"
        ]
        
        # 패키지 설치 시도 (권한이 있는 경우)
        if not IS_HUGGINGFACE:
            try:
                subprocess.run(["sudo", "apt-get", "update"], check=True, capture_output=True)
                subprocess.run(["sudo", "apt-get", "install", "-y"] + packages, check=True, capture_output=True)
                print("시스템 의존성 설치 완료")
                return True
            except subprocess.CalledProcessError as e:
                print(f"시스템 패키지 설치 실패: {e}")
        
        # Hugging Face Space에서는 다른 방법 시도
        if IS_HUGGINGFACE:
            print("Hugging Face Space: 시스템 패키지 설치 권한 없음")
            return False
            
    except Exception as e:
        print(f"의존성 설치 중 오류: {e}")
        return False

def install_playwright_with_deps():
    """Playwright와 의존성 설치"""
    try:
        print("Playwright 설치 시작...")
        
        # Playwright 설치
        result = subprocess.run([
            sys.executable, "-m", "pip", "install", "playwright==1.40.0"
        ], capture_output=True, text=True, timeout=300)
        
        if result.returncode != 0:
            print(f"Playwright pip 설치 실패: {result.stderr}")
            return False
        
        # 브라우저 설치
        result = subprocess.run([
            sys.executable, "-m", "playwright", "install", "chromium"
        ], capture_output=True, text=True, timeout=300)
        
        if result.returncode != 0:
            print(f"Playwright 브라우저 설치 실패: {result.stderr}")
            return False
        
        # 시스템 의존성 설치 시도
        try:
            result = subprocess.run([
                sys.executable, "-m", "playwright", "install-deps", "chromium"
            ], capture_output=True, text=True, timeout=300)
            
            if result.returncode == 0:
                print("Playwright 의존성 설치 완료")
                return True
            else:
                print(f"Playwright 의존성 설치 실패: {result.stderr}")
                print("수동 의존성 설치 시도...")
                return install_system_dependencies()
                
        except subprocess.CalledProcessError:
            print("Playwright install-deps 실패, 수동 설치 시도")
            return install_system_dependencies()
            
    except Exception as e:
        print(f"Playwright 설치 중 오류: {e}")
        return False

class SmartGoogleTrendsAutomator:
    """스마트 Google Trends 자동화 (여러 방법 시도)"""
    
    def __init__(self):
        self.method = None
        self.browser = None
        self.page = None
        self.driver = None
        self.is_ready = False
        self.lock = threading.Lock()
        
    def initialize_browser(self):
        """브라우저 초기화 (여러 방법 시도)"""
        with self.lock:
            if self.is_ready:
                return True
            
            # 방법 1: Playwright 시도
            if self.try_playwright():
                self.method = "playwright"
                self.is_ready = True
                return True
            
            # 방법 2: Selenium 시도
            if self.try_selenium():
                self.method = "selenium"
                self.is_ready = True
                return True
            
            # 방법 3: 대체 방법 (API 기반)
            if self.try_alternative():
                self.method = "alternative"
                self.is_ready = True
                return True
            
            return False
    
    def try_playwright(self):
        """Playwright 초기화 시도"""
        try:
            print("Playwright 방법 시도 중...")
            
            # 의존성 설치
            if not install_playwright_with_deps():
                print("Playwright 의존성 설치 실패")
                return False
            
            # Playwright 임포트
            from playwright.sync_api import sync_playwright
            
            # 브라우저 시작
            self.playwright = sync_playwright().start()
            self.browser = self.playwright.chromium.launch(
                headless=True,
                args=[
                    '--no-sandbox',
                    '--disable-dev-shm-usage',
                    '--disable-gpu',
                    '--disable-software-rasterizer',
                    '--disable-web-security',
                    '--disable-features=VizDisplayCompositor'
                ]
            )
            
            self.page = self.browser.new_page()
            self.page.set_user_agent(
                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
            )
            
            # 테스트 페이지 로드
            self.page.goto("https://trends.google.com/trending?geo=KR&hl=ko", timeout=30000)
            self.page.wait_for_load_state('networkidle', timeout=15000)
            
            print("Playwright 초기화 성공")
            return True
            
        except Exception as e:
            print(f"Playwright 초기화 실패: {e}")
            self.cleanup_playwright()
            return False
    
    def try_selenium(self):
        """Selenium 초기화 시도"""
        try:
            print("Selenium 방법 시도 중...")
            
            from selenium import webdriver
            from selenium.webdriver.chrome.options import Options
            from selenium.webdriver.common.by import By
            from selenium.webdriver.support.ui import WebDriverWait
            from selenium.webdriver.support import expected_conditions as EC
            
            options = Options()
            options.add_argument("--headless")
            options.add_argument("--no-sandbox")
            options.add_argument("--disable-dev-shm-usage")
            options.add_argument("--disable-gpu")
            options.add_argument("--disable-software-rasterizer")
            
            # Chrome 바이너리 경로 수동 설정 시도
            chrome_paths = [
                "/usr/bin/google-chrome",
                "/usr/bin/google-chrome-stable", 
                "/usr/bin/chromium-browser",
                "/usr/bin/chromium",
                "/opt/google/chrome/google-chrome"
            ]
            
            for chrome_path in chrome_paths:
                if os.path.exists(chrome_path):
                    options.binary_location = chrome_path
                    print(f"Chrome 바이너리 발견: {chrome_path}")
                    break
            
            # webdriver-manager 시도
            try:
                from webdriver_manager.chrome import ChromeDriverManager
                from selenium.webdriver.chrome.service import Service
                
                service = Service(ChromeDriverManager().install())
                self.driver = webdriver.Chrome(service=service, options=options)
                
            except Exception as wm_error:
                print(f"webdriver-manager 실패: {wm_error}")
                # 시스템 chromedriver 시도
                self.driver = webdriver.Chrome(options=options)
            
            # 테스트 페이지 로드
            self.driver.get("https://trends.google.com/trending?geo=KR&hl=ko")
            WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.TAG_NAME, "body"))
            )
            
            print("Selenium 초기화 성공")
            return True
            
        except Exception as e:
            print(f"Selenium 초기화 실패: {e}")
            self.cleanup_selenium()
            return False
    
    def try_alternative(self):
        """대체 방법 (API/스크래핑 기반)"""
        try:
            print("대체 방법 시도 중...")
            
            import requests
            from bs4 import BeautifulSoup
            
            # Google Trends RSS 시도
            rss_url = "https://trends.google.com/trending/rss?geo=KR"
            
            session = requests.Session()
            session.headers.update({
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
            })
            
            response = session.get(rss_url, timeout=10)
            response.raise_for_status()
            
            # RSS 파싱 테스트
            from xml.etree import ElementTree as ET
            root = ET.fromstring(response.content)
            
            # 트렌드 데이터 확인
            items = root.findall('.//item')
            if len(items) > 0:
                print(f"대체 방법 성공: {len(items)}개 트렌드 발견")
                self.session = session
                return True
            
            return False
            
        except Exception as e:
            print(f"대체 방법 실패: {e}")
            return False
    
    def capture_screenshot(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
        """선택된 방법으로 스크린샷 캡처"""
        
        if not self.is_ready:
            if not self.initialize_browser():
                return None, False, "모든 브라우저 초기화 방법 실패"
        
        try:
            if self.method == "playwright":
                return self.capture_with_playwright(region, period, category)
            elif self.method == "selenium":
                return self.capture_with_selenium(region, period, category)
            elif self.method == "alternative":
                return self.capture_with_alternative(region, period, category)
            else:
                return None, False, "알 수 없는 방법"
                
        except Exception as e:
            return None, False, f"캡처 중 오류: {str(e)}"
    
    def capture_with_playwright(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
        """Playwright로 캡처"""
        try:
            # 페이지 새로고침
            self.page.reload(wait_until='domcontentloaded')
            self.page.wait_for_load_state('networkidle', timeout=10000)
            
            # 설정 변경 (간단한 버전)
            time.sleep(2)
            
            # 스크린샷 캡처
            screenshot_bytes = self.page.screenshot(full_page=False)
            screenshot_b64 = base64.b64encode(screenshot_bytes).decode()
            
            return screenshot_b64, True, f"Playwright 캡처 성공: {region}"
            
        except Exception as e:
            return None, False, f"Playwright 캡처 실패: {str(e)}"
    
    def capture_with_selenium(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
        """Selenium으로 캡처"""
        try:
            # 페이지 새로고침
            self.driver.refresh()
            time.sleep(3)
            
            # 스크린샷 캡처
            screenshot = self.driver.get_screenshot_as_png()
            screenshot_b64 = base64.b64encode(screenshot).decode()
            
            return screenshot_b64, True, f"Selenium 캡처 성공: {region}"
            
        except Exception as e:
            return None, False, f"Selenium 캡처 실패: {str(e)}"
    
    def capture_with_alternative(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
        """대체 방법으로 데이터 수집"""
        try:
            # RSS 데이터 수집
            rss_url = f"https://trends.google.com/trending/rss?geo=KR"
            
            response = self.session.get(rss_url, timeout=10)
            response.raise_for_status()
            
            # 가짜 스크린샷 생성 (실제로는 HTML 기반 시각화)
            fake_screenshot = self.generate_fake_screenshot(response.content, region)
            
            return fake_screenshot, True, f"대체 방법 성공: {region}"
            
        except Exception as e:
            return None, False, f"대체 방법 실패: {str(e)}"
    
    def generate_fake_screenshot(self, rss_content: bytes, region: str) -> str:
        """RSS 데이터를 기반으로 가짜 스크린샷 생성"""
        try:
            from xml.etree import ElementTree as ET
            import matplotlib.pyplot as plt
            import matplotlib.font_manager as fm
            from io import BytesIO
            
            # RSS 파싱
            root = ET.fromstring(rss_content)
            trends = []
            
            for item in root.findall('.//item')[:10]:
                title = item.find('title')
                if title is not None:
                    trends.append(title.text)
            
            # 차트 생성
            fig, ax = plt.subplots(figsize=(12, 8))
            fig.patch.set_facecolor('white')
            
            # 한글 폰트 설정 시도
            try:
                plt.rcParams['font.family'] = 'DejaVu Sans'
            except:
                pass
            
            # 트렌드 차트
            y_pos = range(len(trends))
            values = [100 - i*10 for i in range(len(trends))]
            
            bars = ax.barh(y_pos, values, color='#4285f4')
            ax.set_yticks(y_pos)
            ax.set_yticklabels(trends[::-1])  # 역순으로 표시
            ax.set_xlabel('검색 관심도')
            ax.set_title(f'{region} 실시간 인기 검색어')
            
            # 그래프를 이미지로 변환
            buffer = BytesIO()
            plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight', 
                       facecolor='white', edgecolor='none')
            buffer.seek(0)
            
            screenshot_b64 = base64.b64encode(buffer.getvalue()).decode()
            
            plt.close(fig)
            return screenshot_b64
            
        except Exception as e:
            print(f"가짜 스크린샷 생성 실패: {e}")
            # 빈 이미지 반환
            return ""
    
    def cleanup_playwright(self):
        """Playwright 정리"""
        try:
            if hasattr(self, 'page') and self.page:
                self.page.close()
            if hasattr(self, 'browser') and self.browser:
                self.browser.close()
            if hasattr(self, 'playwright') and self.playwright:
                self.playwright.stop()
        except:
            pass
    
    def cleanup_selenium(self):
        """Selenium 정리"""
        try:
            if hasattr(self, 'driver') and self.driver:
                self.driver.quit()
        except:
            pass
    
    def cleanup(self):
        """모든 리소스 정리"""
        self.cleanup_playwright()
        self.cleanup_selenium()
        self.is_ready = False

# 글로벌 자동화 인스턴스
automator = SmartGoogleTrendsAutomator()

def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
    """Claude API로 스크린샷 분석"""
    try:
        if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
            return generate_fallback_analysis(region, period, category)
        
        claude_client = create_claude_client()
        
        if claude_client is None:
            return generate_fallback_analysis(region, period, category)
        
        # 빈 스크린샷인 경우 텍스트 분석만
        if not screenshot_b64:
            return generate_fallback_analysis(region, period, category)
        
        prompt = f"""
이 Google Trends 스크린샷을 분석해주세요.
설정: {region} | {period} | {category}

다음을 HTML 표 형태로 정확하게 정리해주세요:
1. 실시간 인기 검색어 상위 10개 (순위, 검색어, 검색량, 상승률)
2. 주요 트렌드 키워드 3-5개의 특징 설명
3. 카테고리별 특이사항 (있는 경우)

HTML 형태로 깔끔하게 정리하고, 시각적으로 만들어주세요.
한글 텍스트를 정확히 읽어서 분석해주세요.
"""

        message = claude_client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": prompt
                        },
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": screenshot_b64
                            }
                        }
                    ]
                }
            ]
        )
        
        return message.content[0].text
        
    except Exception as e:
        return generate_fallback_analysis(region, period, category, str(e))

def generate_fallback_analysis(region: str, period: str, category: str, error: str = None) -> str:
    """대체 분석 결과 생성"""
    
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    html = f"""
    <div style="font-family: 'Segoe UI', sans-serif; max-width: 1000px; margin: 0 auto;">
        <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
            <h2>{region} 실시간 트렌드 분석 (대체 모드)</h2>
            <p>분석 시각: {timestamp}</p>
            <p>설정: {region} | {period} | {category}</p>
        </div>
        
        <div style="background-color: #fff3cd; border: 1px solid #ffeaa7; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
            <h4>알림: 대체 분석 모드</h4>
            <p>브라우저 기반 캡처가 불가능하여 대체 방법으로 분석을 진행했습니다.</p>
            {f"<p><strong>오류 정보:</strong> {error}</p>" if error else ""}
        </div>
        
        <h3>예상 인기 검색어 (참고용)</h3>
        <table style="width: 100%; border-collapse: collapse; margin-bottom: 30px;">
            <thead>
                <tr style="background-color: #f8f9fa;">
                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">순위</th>
                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">검색어</th>
                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">예상 관심도</th>
                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">카테고리</th>
                </tr>
            </thead>
            <tbody>
    """
    
    # 샘플 데이터 생성
    sample_trends = [
        ("뉴스 이슈", "높음", "뉴스"),
        ("연예계 소식", "높음", "엔터테인먼트"),
        ("스포츠 경기", "중간", "스포츠"),
        ("기술 뉴스", "중간", "기술"),
        ("건강 정보", "낮음", "건강"),
    ]
    
    for i, (keyword, interest, cat) in enumerate(sample_trends, 1):
        html += f"""
            <tr>
                <td style="border: 1px solid #dee2e6; padding: 12px;">{i}</td>
                <td style="border: 1px solid #dee2e6; padding: 12px; font-weight: bold;">{keyword}</td>
                <td style="border: 1px solid #dee2e6; padding: 12px;">{interest}</td>
                <td style="border: 1px solid #dee2e6; padding: 12px;">{cat}</td>
            </tr>
        """
    
    html += """
            </tbody>
        </table>
        
        <h3>분석 참고사항</h3>
        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px;">
            <ul>
                <li><strong>데이터 한계:</strong> 실제 Google Trends 데이터가 아닌 예상 데이터입니다.</li>
                <li><strong>브라우저 이슈:</strong> 시스템 환경에서 브라우저 실행이 제한되어 있습니다.</li>
                <li><strong>권장사항:</strong> 로컬 환경에서 테스트하거나 다른 방법을 시도해보세요.</li>
            </ul>
        </div>
    </div>
    """
    
    return html

def smart_analysis(region: str, period: str, category: str):
    """스마트 분석 함수 (여러 방법 시도)"""
    
    start_time = time.time()
    
    yield f"""
    <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
        <h3>스마트 Google Trends 분석</h3>
        <p><strong>설정:</strong> {region} | {period} | {category}</p>
        <p>여러 방법을 시도하여 최적의 결과를 제공합니다</p>
    </div>
    """
    
    try:
        # 1단계: 브라우저 초기화
        yield f"""
        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
            <h4>1단계: 브라우저 초기화 중...</h4>
            <p>Playwright → Selenium → 대체 방법 순서로 시도</p>
        </div>
        """
        
        # 브라우저 초기화
        init_success = automator.initialize_browser()
        init_time = time.time() - start_time
        
        if init_success:
            yield f"""
            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                <h4>1단계 완료: {automator.method.upper()} 초기화 성공 ({init_time:.1f}초)</h4>
                <p>선택된 방법으로 데이터 수집을 진행합니다</p>
            </div>
            
            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                <h4>2단계: 데이터 수집 중...</h4>
                <p>Google Trends에서 {region} 지역의 데이터를 가져오고 있습니다</p>
            </div>
            """
        else:
            yield f"""
            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FFA500 0%, #FF8C00 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                <h4>1단계: 브라우저 초기화 실패 ({init_time:.1f}초)</h4>
                <p>대체 방법으로 분석을 진행합니다</p>
            </div>
            
            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                <h4>2단계: 대체 분석 중...</h4>
                <p>브라우저 없이 가능한 범위에서 분석합니다</p>
            </div>
            """
        
        # 2단계: 데이터 캡처
        with ThreadPoolExecutor(max_workers=1) as executor:
            future = executor.submit(
                automator.capture_screenshot, 
                region, period, category
            )
            
            # 진행 상황 표시
            while not future.done():
                elapsed = time.time() - start_time
                yield f"""
                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                    <h4>1단계 완료: {automator.method.upper() if automator.method else '대체방법'} ({init_time:.1f}초)</h4>
                </div>
                
                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                    <h4>2단계: 데이터 수집 중... ({elapsed:.1f}초)</h4>
                    <p>트렌드 데이터를 처리하고 있습니다</p>
                </div>
                """
                time.sleep(0.5)
            
            screenshot_b64, success, status_msg = future.result()
        
        capture_time = time.time() - start_time
        
        # 3단계: AI 분석
        yield f"""
        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
            <h4>2단계 완료: 데이터 수집 {"성공" if success else "부분 성공"} ({capture_time:.1f}초)</h4>
            <p>{status_msg}</p>
        </div>
        
        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #9C27B0 0%, #8E24AA 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
            <h4>3단계: AI 분석 중...</h4>
            <p>Claude AI가 수집된 데이터를 분석하고 있습니다</p>
        </div>
        """
        
        # AI 분석 실행
        ai_start_time = time.time()
        
        with ThreadPoolExecutor(max_workers=1) as executor:
            ai_future = executor.submit(
                analyze_with_claude, 
                screenshot_b64, region, period, category
            )
            
            while not ai_future.done():
                ai_elapsed = time.time() - ai_start_time
                total_elapsed = time.time() - start_time
                yield f"""
                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                    <h4>2단계 완료: 데이터 수집 {"성공" if success else "부분 성공"} ({capture_time:.1f}초)</h4>
                    <p>{status_msg}</p>
                </div>
                
                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #9C27B0 0%, #8E24AA 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
                    <h4>3단계: AI 분석 중... ({ai_elapsed:.1f}초)</h4>
                    <p>총 경과 시간: {total_elapsed:.1f}초</p>
                </div>
                """
                time.sleep(0.5)
            
            analysis_result = ai_future.result()
        
        total_time = time.time() - start_time
        
        # 최종 결과
        yield f"""
        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
            <h3>스마트 분석 완료 ({total_time:.1f}초)</h3>
            <p><strong>사용 방법:</strong> {automator.method.upper() if automator.method else '대체방법'} | <strong>설정:</strong> {region} | {period} | {category}</p>
        </div>
        
        {analysis_result}
        
        <div style="margin-top: 20px; padding: 15px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; text-align: center;">
            <p style="margin: 0; font-size: 14px;">
                <strong>스마트 분석의 장점</strong><br>
                여러 방법을 자동으로 시도하여 환경에 관계없이 최적의 결과 제공
            </p>
        </div>
        
        <div style="margin-top: 15px; padding: 10px; background-color: #f9f9f9; border-radius: 5px; font-size: 12px; color: #666; text-align: center;">
            <p style="margin: 5px 0;"><strong>사용된 방법:</strong> {automator.method.upper() if automator.method else '대체방법'}</p>
            <p style="margin: 5px 0;"><strong>총 분석 시간:</strong> {total_time:.1f}초</p>
            <p style="margin: 5px 0;"><strong>환경:</strong> {"Hugging Face Space" if IS_HUGGINGFACE else "로컬"}</p>
        </div>
        """
        
        print(f"스마트 분석 완료: {total_time:.1f}초, 방법: {automator.method}")
        
    except Exception as e:
        error_details = traceback.format_exc()
        print(f"스마트 분석 중 예외 발생: {e}")
        
        yield f"""
        <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
            <h3>스마트 분석 오류</h3>
            <p><strong>오류:</strong> {str(e)}</p>
            <details>
                <summary>상세 오류 정보</summary>
                <pre style="background-color: #f5f5f5; padding: 10px; margin-top: 10px; overflow-x: auto; font-size: 11px;">
{error_details}
                </pre>
            </details>
            <p><strong>해결 방법:</strong> 페이지를 새로고침하고 다시 시도하세요.</p>
        </div>
        """

def create_smart_interface():
    """스마트 Gradio 인터페이스"""
    
    with gr.Blocks(
        theme=gr.themes.Soft(),
        title="스마트 Google Trends 분석기",
        css="""
        .gradio-container {
            max-width: 1200px !important;
        }
        .output-html {
            max-height: none !important;
        }
        """
    ) as interface:
        
        gr.HTML("""
        <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
            <h1>스마트 Google Trends 분석기</h1>
            <p><strong>다중 방법 지원:</strong> Playwright → Selenium → 대체 방법 자동 선택</p>
            <p style="font-size: 14px; opacity: 0.9;">환경에 관계없이 최적의 결과를 제공합니다</p>
        </div>
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                region_input = gr.Dropdown(
                    choices=["대한민국", "전세계", "미국", "일본", "중국"],
                    value="대한민국",
                    label="지역 선택"
                )
                
            with gr.Column(scale=1):
                period_input = gr.Dropdown(
                    choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
                    value="지난 7일", 
                    label="기간 선택"
                )
                
            with gr.Column(scale=1):
                category_input = gr.Dropdown(
                    choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
                    value="모든 카테고리",
                    label="카테고리 선택"
                )
        
        analyze_btn = gr.Button(
            "스마트 분석 시작 (자동 방법 선택)", 
            variant="primary",
            size="lg"
        )
        
        output = gr.HTML(
            label="실시간 분석 결과",
            value="""
            <div style="text-align: center; padding: 20px; border: 2px dashed #ccc; border-radius: 10px; color: #666;">
                <h3>스마트 분석기 대기 중</h3>
                <p><strong>자동 방법 선택:</strong> 환경에 맞는 최적의 방법을 자동으로 선택</p>
                <p><strong>지원 방법:</strong> Playwright, Selenium, 대체 방법</p>
                <p style="font-size: 14px;">위의 설정을 선택하고 버튼을 클릭하세요!</p>
            </div>
            """
        )
        
        analyze_btn.click(
            fn=smart_analysis,
            inputs=[region_input, period_input, category_input],
            outputs=output,
            show_progress="hidden"
        )
        
        gr.HTML("""
        <div style="margin-top: 30px; padding: 20px; background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%); border-radius: 10px;">
            <h3 style="margin-top: 0; color: #333;">스마트 분석기의 특징</h3>
            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; color: #555;">
                <div>
                    <h4>자동 방법 선택</h4>
                    <ul style="margin: 0; padding-left: 20px;">
                        <li>Playwright 우선 시도</li>
                        <li>실패시 Selenium 시도</li>
                        <li>최종적으로 대체 방법 사용</li>
                    </ul>
                </div>
                <div>
                    <h4>환경 호환성</h4>
                    <ul style="margin: 0; padding-left: 20px;">
                        <li>Hugging Face Space 완벽 지원</li>
                        <li>로컬 환경 최적화</li>
                        <li>시스템 제약 자동 해결</li>
                    </ul>
                </div>
            </div>
        </div>
        """)
    
    return interface

# 앱 종료시 리소스 정리
import atexit

def cleanup_on_exit():
    """앱 종료시 리소스 정리"""
    global automator
    if automator:
        automator.cleanup()
        print("앱 종료: 모든 브라우저 리소스 정리 완료")

atexit.register(cleanup_on_exit)

if __name__ == "__main__":
    print("=" * 50)
    print("스마트 Google Trends 분석기 시작")
    print("=" * 50)
    
    if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
        print("ANTHROPIC_API_KEY 미설정 - 대체 분석 모드")
    else:
        print("Claude API 키 확인됨")
    
    print("스마트 Gradio 인터페이스 준비 중...")
    app = create_smart_interface()
    
    if os.getenv("SPACE_ID"):
        print("Hugging Face Space 환경에서 실행")
        app.launch(
            server_name="0.0.0.0",
            server_port=7860,
            show_error=True,
            show_api=False
        )
    else:
        print("로컬 서버 시작: http://localhost:7860")
        app.launch(
            server_name="127.0.0.1",
            server_port=7860,
            show_error=True,
            show_api=False,
            share=False,
            inbrowser=True
        )