app.py

import os
import time
import base64
import io
import traceback
import threading
import atexit
import asyncio
from datetime import datetime
from typing import Optional, Tuple

import gradio as gr
import anthropic
from playwright.async_api import async_playwright
from playwright.sync_api import sync_playwright, Browser, Page
from PIL import Image
import requests
from dotenv import load_dotenv

# 환경변수 로드
load_dotenv()

# 전역 변수
browser = None
page = None
playwright_instance = None
browser_lock = threading.Lock()
is_browser_ready = False
browser_thread_id = None

# Claude API 클라이언트 초기화
def get_claude_client():
    api_key = os.getenv("ANTHROPIC_API_KEY")
    if not api_key:
        raise ValueError("ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
    
    try:
        # 더 안전한 클라이언트 초기화
        client = anthropic.Anthropic(
            api_key=api_key,
            max_retries=2,
            timeout=60.0
        )
        return client
    except Exception as e:
        print(f"Claude 클라이언트 초기화 오류: {e}")
        # 기본 초기화 방식으로 재시도
        return anthropic.Anthropic(api_key=api_key)

def install_browsers():
    """Playwright 브라우저 및 한글 폰트 설치"""
    try:
        print("Playwright 브라우저 설치 중...")
        os.system("playwright install chromium")
        
        print("한글 폰트 설치 중...")
        # 한글 폰트 설치
        os.system("apt-get update")
        os.system("apt-get install -y fonts-nanum fonts-nanum-coding fonts-nanum-extra")
        os.system("fc-cache -fv")
        
        print("Playwright 브라우저 및 폰트 설치 완료!")
        return True
    except Exception as e:
        print(f"브라우저/폰트 설치 실패: {e}")
        return False

def init_browser():
    """Playwright 브라우저를 초기화하고 Google Trends 페이지로 이동"""
    global browser, page, playwright_instance, is_browser_ready, browser_thread_id
    
    try:
        # 현재 스레드 ID 저장
        browser_thread_id = threading.current_thread().ident
        print(f"브라우저 초기화 스레드 ID: {browser_thread_id}")
        
        print("Playwright 브라우저 초기화 중...")
        
        # 브라우저 설치
        install_browsers()
        
        # Playwright 인스턴스 생성
        playwright_instance = sync_playwright().start()
        
        # 브라우저 실행 (Chromium 사용)
        browser = playwright_instance.chromium.launch(
            headless=True,
            args=[
                '--no-sandbox',
                '--disable-dev-shm-usage',
                '--disable-gpu',
                '--disable-extensions',
                '--disable-web-security',
                '--allow-running-insecure-content',
                '--disable-features=VizDisplayCompositor',
                '--disable-background-timer-throttling',
                '--disable-backgrounding-occluded-windows',
                '--disable-renderer-backgrounding',
                '--disable-features=TranslateUI',
                '--disable-ipc-flooding-protection',
                '--disable-plugins',
                '--disable-images',
                '--force-device-scale-factor=1',
                '--font-render-hinting=medium',
                '--disable-font-subpixel-positioning'
            ]
        )
        
        # 새 페이지 생성
        page = browser.new_page()
        
        # 뷰포트 설정
        page.set_viewport_size({"width": 1920, "height": 1080})
        
        # User-Agent 설정
        page.set_extra_http_headers({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
            "Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8"
        })
        
        # 한글 폰트 설정을 위한 CSS 추가
        page.add_style_tag(content="""
            * {
                font-family: 'Nanum Gothic', 'Malgun Gothic', '맑은 고딕', 'Noto Sans CJK KR', 'Apple SD Gothic Neo', sans-serif !important;
            }
        """)
        
        print("Google Trends 페이지로 이동 중...")
        page.goto("https://trends.google.com/trending?geo=KR", wait_until="networkidle", timeout=30000)
        
        # 추가 로딩 시간
        time.sleep(5)
        
        is_browser_ready = True
        print("브라우저 초기화 완료!")
        
    except Exception as e:
        print(f"브라우저 초기화 실패: {str(e)}")
        print(traceback.format_exc())
        is_browser_ready = False
        cleanup_browser()

def ensure_browser_ready():
    """브라우저가 준비되어 있는지 확인하고, 필요시 초기화"""
    global is_browser_ready, browser, page, browser_thread_id
    
    current_thread_id = threading.current_thread().ident
    
    # 브라우저가 준비되지 않았거나 다른 스레드에서 생성된 경우
    if not is_browser_ready or browser_thread_id != current_thread_id or not browser or not page:
        print(f"브라우저 재초기화 필요 (현재 스레드: {current_thread_id}, 브라우저 스레드: {browser_thread_id})")
        
        # 기존 브라우저 정리
        cleanup_browser()
        
        # 현재 스레드에서 새로 초기화
        init_browser()
        
    return is_browser_ready

def cleanup_browser():
    """브라우저 정리"""
    global browser, page, playwright_instance
    
    try:
        if page:
            page.close()
            page = None
        if browser:
            browser.close()
            browser = None
        if playwright_instance:
            playwright_instance.stop()
            playwright_instance = None
        print("브라우저 정리 완료")
    except Exception as e:
        print(f"브라우저 정리 중 오류: {e}")

def apply_filters(geo: str, time_range: str, category: str) -> bool:
    """Google Trends 필터 적용"""
    global page
    
    # 브라우저 준비 상태 확인
    if not ensure_browser_ready():
        print("브라우저 준비 실패")
        return False
        
    try:
        print(f"필터 적용: 지역={geo}")
        
        # 지역 설정을 위한 URL 구성
        geo_map = {
            "KR": "KR", "US": "US", "JP": "JP", 
            "GB": "GB", "DE": "DE", "FR": "FR"
        }
        
        base_url = "https://trends.google.com/trending"
        geo_param = geo_map.get(geo, "KR")
        url = f"{base_url}?geo={geo_param}"
        
        print(f"필터 적용된 URL로 이동: {url}")
        page.goto(url, wait_until="networkidle", timeout=30000)
        
        # 페이지 로딩 완료 대기
        time.sleep(3)
        
        # 실제 필터 요소들이 있다면 클릭으로 설정
        try:
            # 시간 범위 필터 시도
            if time_range != "24시간":
                time_selector = page.locator('[data-bucket="0"]').first
                if time_selector.is_visible():
                    time_selector.click()
                    time.sleep(1)
                    
                    # 시간 옵션들 중 선택
                    if time_range == "7일":
                        page.locator('text="Past 7 days"').first.click()
                    elif time_range == "30일":
                        page.locator('text="Past 30 days"').first.click()
                    time.sleep(2)
            
            # 카테고리 필터 시도 
            if category != "모든 카테고리":
                category_selector = page.locator('[data-bucket="2"]').first
                if category_selector.is_visible():
                    category_selector.click()
                    time.sleep(1)
                    
                    # 카테고리 매핑
                    category_map = {
                        "엔터테인먼트": "Entertainment",
                        "스포츠": "Sports", 
                        "비즈니스": "Business",
                        "과학기술": "Science & Tech",
                        "건강": "Health"
                    }
                    
                    if category in category_map:
                        page.locator(f'text="{category_map[category]}"').first.click()
                        time.sleep(2)
                        
        except Exception as filter_error:
            print(f"필터 요소 클릭 실패 (계속 진행): {filter_error}")
        
        print("필터 적용 완료")
        return True
                
    except Exception as e:
        print(f"필터 적용 실패: {str(e)}")
        print(traceback.format_exc())
        return False

def capture_screenshot() -> Optional[Image.Image]:
    """현재 페이지의 스크린샷 캡처 (트렌드 테이블 영역만)"""
    global page
    
    # 브라우저 준비 상태 확인
    if not ensure_browser_ready():
        print("브라우저 준비 실패")
        return None
        
    try:
        print("스크린샷 캡처 중...")
        
        # 페이지가 완전히 로드될 때까지 대기
        time.sleep(2)
        
        # 트렌드 테이블 영역 찾기
        try:
            # 여러 가능한 셀렉터 시도
            selectors = [
                '[data-module="TrendingSearches"]',  # 메인 트렌드 모듈
                '.trends-table',  # 트렌드 테이블
                '.trending-searches',  # 트렌드 검색어 영역
                '[role="main"]',  # 메인 콘텐츠 영역
                'main'  # 기본 메인 태그
            ]
            
            element = None
            for selector in selectors:
                try:
                    element = page.locator(selector).first
                    if element.is_visible():
                        print(f"캡처 영역 발견: {selector}")
                        break
                except:
                    continue
            
            if element and element.is_visible():
                # 특정 영역만 스크린샷
                screenshot_bytes = element.screenshot()
                print("트렌드 테이블 영역 캡처 완료")
            else:
                # 대안: 전체 페이지에서 상단 부분만 캡처
                print("특정 영역을 찾지 못해 페이지 상단 영역 캡처")
                screenshot_bytes = page.screenshot(clip={"x": 0, "y": 100, "width": 1920, "height": 800})
                
        except Exception as selector_error:
            print(f"영역 선택 실패, 전체 페이지 캡처: {selector_error}")
            screenshot_bytes = page.screenshot(full_page=True)
        
        screenshot = Image.open(io.BytesIO(screenshot_bytes))
        print("스크린샷 캡처 완료")
        return screenshot
            
    except Exception as e:
        print(f"스크린샷 캡처 실패: {str(e)}")
        print(traceback.format_exc())
        return None

def analyze_with_claude(image: Image.Image) -> str:
    """Claude API를 사용하여 이미지 분석"""
    try:
        client = get_claude_client()
        
        # 이미지를 base64로 인코딩
        buffer = io.BytesIO()
        image.save(buffer, format="PNG")
        image_base64 = base64.b64encode(buffer.getvalue()).decode()
        
        # Claude API 호출을 위한 프롬프트 구성
        prompt = """
        이 Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
        
        다음 내용을 포함해서 분석해주세요:
        1. 현재 가장 인기 있는 검색어들과 그 순위
        2. 각 검색어의 증가 추세나 특이사항
        3. 검색어들에서 발견되는 주요 트렌드나 패턴
        4. 시사적/문화적 맥락에서의 해석
        
        한국어로 상세하고 구체적으로 분석해주세요.
        """
        
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1500,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": prompt
                        },
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": image_base64
                            }
                        }
                    ]
                }
            ]
        )
        
        return response.content[0].text
        
    except Exception as e:
        error_msg = f"Claude API 분석 실패: {str(e)}"
        print(error_msg)
        return error_msg

def reinit_browser():
    """브라우저 재초기화"""
    global is_browser_ready
    
    print("브라우저 재초기화 시작...")
    
    # 기존 브라우저 정리
    cleanup_browser()
    is_browser_ready = False
    
    # 새로 초기화
    init_browser()
    
    if is_browser_ready:
        return "브라우저 재초기화 완료!"
    else:
        return "브라우저 재초기화 실패. 다시 시도해주세요."

def refresh_trends_page():
    """Google Trends 페이지 새로고침"""
    global page
    
    if not ensure_browser_ready():
        return "브라우저가 준비되지 않았습니다."
        
    try:
        page.reload(wait_until="networkidle", timeout=30000)
        time.sleep(3)
        return "페이지가 새로고침되었습니다."
    except Exception as e:
        return f"페이지 새로고침 실패: {str(e)}"

def main_process_screenshot(geo: str, time_range: str, category: str) -> Tuple[Optional[Image.Image], str]:
    """스크린샷 캡처만 수행하는 함수"""
    try:
        # 1. 브라우저 준비 확인
        if not ensure_browser_ready():
            return None, "브라우저가 준비되지 않았습니다. '브라우저 재초기화' 버튼을 클릭해주세요."
        
        # 2. 필터 적용
        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
        filter_success = apply_filters(geo, time_range, category)
        
        if not filter_success:
            return None, "필터 적용에 실패했습니다."
        
        # 3. 스크린샷 캡처
        print("스크린샷 캡처 중...")
        screenshot = capture_screenshot()
        
        if screenshot is None:
            return None, "스크린샷 캡처에 실패했습니다."
        
        return screenshot, "스크린샷 캡처 완료! Claude 분석을 진행합니다..."
        
    except Exception as e:
        error_msg = f"스크린샷 캡처 중 오류 발생: {str(e)}"
        print(error_msg)
        print(traceback.format_exc())
        return None, error_msg

def analyze_screenshot_with_claude(screenshot: Image.Image) -> str:
    """Claude API로 스크린샷 분석"""
    if screenshot is None:
        return "분석할 스크린샷이 없습니다."
    
    try:
        print("Claude API로 분석 중...")
        analysis_result = analyze_with_claude(screenshot)
        return analysis_result
        
    except Exception as e:
        error_msg = f"Claude 분석 중 오류 발생: {str(e)}"
        print(error_msg)
        return error_msg

def main_process(geo: str, time_range: str, category: str) -> Tuple[Optional[Image.Image], str]:
    """전체 프로세스 (호환성을 위해 유지)"""
    try:
        # 1. 브라우저 준비 확인
        if not ensure_browser_ready():
            return None, "브라우저가 준비되지 않았습니다. '브라우저 재초기화' 버튼을 클릭해주세요."
        
        # 2. 필터 적용
        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
        filter_success = apply_filters(geo, time_range, category)
        
        if not filter_success:
            return None, "필터 적용에 실패했습니다."
        
        # 3. 스크린샷 캡처
        print("스크린샷 캡처 중...")
        screenshot = capture_screenshot()
        
        if screenshot is None:
            return None, "스크린샷 캡처에 실패했습니다."
        
        # 4. Claude API로 분석
        print("Claude API로 분석 중...")
        analysis_result = analyze_with_claude(screenshot)
        
        return screenshot, analysis_result
        
    except Exception as e:
        error_msg = f"처리 중 오류 발생: {str(e)}"
        print(error_msg)
        print(traceback.format_exc())
        return None, error_msg

def check_browser_status():
    """브라우저 상태 확인"""
    global is_browser_ready, page, browser_thread_id
    
    current_thread_id = threading.current_thread().ident
    
    if not page:
        return "브라우저가 초기화되지 않았습니다."
    
    if not is_browser_ready:
        return "브라우저 초기화 중입니다..."
    
    try:
        current_url = page.url
        return f"브라우저 준비 완료 - 현재 URL: {current_url} (스레드: {current_thread_id}, 브라우저 스레드: {browser_thread_id})"
    except Exception as e:
        return f"브라우저 연결에 문제가 있습니다: {str(e)}"

# Gradio 인터페이스 생성
def create_interface():
    """Gradio 인터페이스 생성"""
    
    with gr.Blocks(title="Google Trends 실시간 분석기", theme=gr.themes.Soft()) as interface:
        gr.Markdown("# Google Trends 실시간 인기 검색어 분석기")
        gr.Markdown("Google Trends의 실시간 인기 검색어를 캡처하고 Claude AI로 분석합니다.")
        
        # 상태 저장을 위한 State 컴포넌트
        screenshot_state = gr.State(None)
        
        with gr.Row():
            with gr.Column(scale=1):
                geo_dropdown = gr.Dropdown(
                    choices=["KR", "US", "JP", "GB", "DE", "FR"],
                    value="KR",
                    label="지역 선택"
                )
                
                time_dropdown = gr.Dropdown(
                    choices=["24시간", "7일", "30일", "90일", "12개월"],
                    value="24시간", 
                    label="기간 선택"
                )
                
                category_dropdown = gr.Dropdown(
                    choices=["모든 카테고리", "엔터테인먼트", "스포츠", "비즈니스", "과학기술", "건강"],
                    value="모든 카테고리",
                    label="카테고리 선택"
                )
                
                with gr.Row():
                    capture_btn = gr.Button("🎯 스크린샷 캡처", variant="primary")
                    analyze_btn = gr.Button("🤖 Claude 분석", variant="secondary", interactive=False)
                
                with gr.Row():
                    refresh_btn = gr.Button("🔄 페이지 새로고침", variant="secondary")
                    reinit_btn = gr.Button("⚙️ 브라우저 초기화", variant="secondary")
                    status_btn = gr.Button("📊 브라우저 상태 확인", variant="secondary")
            
            with gr.Column(scale=2):
                screenshot_output = gr.Image(label="Google Trends 스크린샷")
                analysis_output = gr.Textbox(
                    label="Claude AI 분석 결과",
                    lines=10,
                    max_lines=20,
                    placeholder="스크린샷을 캡처한 후 'Claude 분석' 버튼을 클릭하세요."
                )
                status_output = gr.Textbox(label="상태 메시지")
        
        # 이벤트 핸들러
        
        # 스크린샷 캡처 버튼
        def on_capture_click(geo, time_range, category):
            screenshot, message = main_process_screenshot(geo, time_range, category)
            if screenshot is not None:
                # 분석 버튼 활성화
                return screenshot, screenshot, message, gr.update(interactive=True)
            else:
                return None, None, message, gr.update(interactive=False)
        
        capture_btn.click(
            fn=on_capture_click,
            inputs=[geo_dropdown, time_dropdown, category_dropdown],
            outputs=[screenshot_output, screenshot_state, status_output, analyze_btn]
        )
        
        # Claude 분석 버튼
        def on_analyze_click(screenshot):
            if screenshot is None:
                return "분석할 스크린샷이 없습니다. 먼저 '스크린샷 캡처' 버튼을 클릭하세요."
            
            analysis_result = analyze_screenshot_with_claude(screenshot)
            return analysis_result
        
        analyze_btn.click(
            fn=on_analyze_click,
            inputs=[screenshot_state],
            outputs=[analysis_output]
        )
        
        # 기타 버튼들
        refresh_btn.click(
            fn=refresh_trends_page,
            outputs=status_output
        )
        
        reinit_btn.click(
            fn=reinit_browser,
            outputs=status_output
        )
        
        status_btn.click(
            fn=check_browser_status,
            outputs=status_output
        )
    
    return interface

def main():
    """메인 함수"""
    print("=" * 50)
    print("Google Trends 실시간 분석기 시작!")
    print("=" * 50)
    
    # API 키 존재 여부만 확인 (실제 클라이언트 초기화는 나중에)
    api_key = os.getenv("ANTHROPIC_API_KEY")
    if not api_key:
        print("✗ ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
        return
    else:
        print("✓ Claude API 키 확인됨")
    
    print("✓ Gradio 웹 인터페이스 준비 중...")
    
    # 환경 확인
    if os.getenv("SPACE_ID"):
        print("✓ Hugging Face Space 환경에서 실행 중...")
    
    print("✓ 브라우저는 첫 번째 사용 시 자동으로 초기화됩니다.")
    
    # 종료 시 브라우저 정리
    atexit.register(cleanup_browser)
    
    # Gradio 인터페이스 생성 및 실행
    interface = create_interface()
    
    # Hugging Face Space에서는 share=False로 실행
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        show_error=True,
        quiet=False
    )

if __name__ == "__main__":
    main()