app.py

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

import gradio as gr
import anthropic
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait, Select
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, WebDriverException
from webdriver_manager.chrome import ChromeDriverManager
from PIL import Image
import requests
from dotenv import load_dotenv

# 환경변수 로드
load_dotenv()

# 전역 변수
driver = None
driver_lock = threading.Lock()
is_browser_ready = False

# 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 init_browser():
    """브라우저를 초기화하고 Google Trends 페이지로 이동"""
    global driver, is_browser_ready
    
    try:
        print("Chrome 브라우저 초기화 중...")
        
        # Chrome 옵션 설정 (Hugging Face Space 최적화)
        chrome_options = Options()
        chrome_options.add_argument("--headless")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
        chrome_options.add_argument("--disable-gpu")
        chrome_options.add_argument("--disable-extensions")
        chrome_options.add_argument("--disable-web-security")
        chrome_options.add_argument("--allow-running-insecure-content")
        chrome_options.add_argument("--disable-blink-features=AutomationControlled")
        chrome_options.add_argument("--disable-features=VizDisplayCompositor")
        chrome_options.add_argument("--window-size=1920,1080")
        chrome_options.add_argument("--disable-background-timer-throttling")
        chrome_options.add_argument("--disable-backgrounding-occluded-windows")
        chrome_options.add_argument("--disable-renderer-backgrounding")
        chrome_options.add_argument("--disable-features=TranslateUI")
        chrome_options.add_argument("--disable-ipc-flooding-protection")
        chrome_options.add_argument("--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")
        
        # ChromeDriver 서비스 설정
        service = Service(ChromeDriverManager().install())
        
        # 브라우저 인스턴스 생성
        driver = webdriver.Chrome(service=service, options=chrome_options)
        driver.set_page_load_timeout(30)
        driver.implicitly_wait(10)
        
        print("Google Trends 페이지로 이동 중...")
        driver.get("https://trends.google.com/trending?geo=KR")
        
        # 페이지 로딩 대기
        WebDriverWait(driver, 20).until(
            EC.presence_of_element_located((By.TAG_NAME, "body"))
        )
        
        # 추가 로딩 시간
        time.sleep(5)
        
        is_browser_ready = True
        print("브라우저 초기화 완료!")
        
    except Exception as e:
        print(f"브라우저 초기화 실패: {str(e)}")
        print(traceback.format_exc())
        is_browser_ready = False
        if driver:
            try:
                driver.quit()
            except:
                pass
            driver = None

def cleanup_browser():
    """브라우저 정리"""
    global driver
    if driver:
        try:
            driver.quit()
            print("브라우저 정리 완료")
        except:
            pass
        driver = None

def apply_filters(geo: str, time_range: str, category: str) -> bool:
    """Google Trends 필터 적용"""
    global driver
    
    if not driver or not is_browser_ready:
        return False
        
    try:
        with driver_lock:
            # 필터 버튼들을 찾고 클릭
            try:
                # 지역 설정
                if geo != "KR":  # 기본값이 아닌 경우
                    geo_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{geo}')]")
                    if geo_elements:
                        driver.execute_script("arguments[0].click();", geo_elements[0])
                        time.sleep(1)
                
                # 시간 범위 설정
                if time_range != "24시간":
                    time_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{time_range}')]")
                    if time_elements:
                        driver.execute_script("arguments[0].click();", time_elements[0])
                        time.sleep(1)
                
                # 카테고리 설정  
                if category != "모든 카테고리":
                    category_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{category}')]")
                    if category_elements:
                        driver.execute_script("arguments[0].click();", category_elements[0])
                        time.sleep(1)
                
                # 필터 적용 후 로딩 대기
                time.sleep(3)
                return True
                
            except Exception as filter_error:
                print(f"필터 적용 중 오류: {filter_error}")
                return True  # 필터 적용 실패해도 스크린샷은 찍을 수 있음
                
    except Exception as e:
        print(f"필터 적용 실패: {str(e)}")
        return False

def capture_screenshot() -> Optional[Image.Image]:
    """현재 페이지의 스크린샷 캡처"""
    global driver
    
    if not driver or not is_browser_ready:
        return None
        
    try:
        with driver_lock:
            # 페이지가 완전히 로드될 때까지 대기
            time.sleep(2)
            
            # 스크린샷 캡처
            screenshot_data = driver.get_screenshot_as_png()
            screenshot = Image.open(io.BytesIO(screenshot_data))
            
            return screenshot
            
    except Exception as e:
        print(f"스크린샷 캡처 실패: {str(e)}")
        return None

def analyze_with_claude(image: Image.Image, user_prompt: str = "") -> 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 호출을 위한 프롬프트 구성
        default_prompt = """
        이 Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
        
        다음 내용을 포함해서 분석해주세요:
        1. 현재 가장 인기 있는 검색어들과 그 순위
        2. 각 검색어의 증가 추세나 특이사항
        3. 검색어들에서 발견되는 주요 트렌드나 패턴
        4. 시사적/문화적 맥락에서의 해석
        
        한국어로 상세하고 구체적으로 분석해주세요.
        """
        
        prompt = user_prompt if user_prompt.strip() else default_prompt
        
        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 driver, 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 driver
    
    if not driver or not is_browser_ready:
        return "브라우저가 준비되지 않았습니다."
        
    try:
        with driver_lock:
            driver.refresh()
            time.sleep(3)
            return "페이지가 새로고침되었습니다."
    except Exception as e:
        return f"페이지 새로고침 실패: {str(e)}"

def main_process(geo: str, time_range: str, category: str, user_prompt: str) -> Tuple[Optional[Image.Image], str]:
    """메인 처리 함수"""
    if not is_browser_ready:
        return None, "브라우저가 준비되지 않았습니다. 페이지를 새로고침해주세요."
    
    try:
        # 1. 필터 적용
        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
        filter_success = apply_filters(geo, time_range, category)
        
        if not filter_success:
            return None, "필터 적용에 실패했습니다."
        
        # 2. 스크린샷 캡처
        print("스크린샷 캡처 중...")
        screenshot = capture_screenshot()
        
        if screenshot is None:
            return None, "스크린샷 캡처에 실패했습니다."
        
        # 3. Claude API로 분석
        print("Claude API로 분석 중...")
        analysis_result = analyze_with_claude(screenshot, user_prompt)
        
        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, driver
    
    if not driver:
        return "브라우저가 초기화되지 않았습니다."
    
    if not is_browser_ready:
        return "브라우저 초기화 중입니다..."
    
    try:
        with driver_lock:
            current_url = driver.current_url
            return f"브라우저 준비 완료 - 현재 URL: {current_url}"
    except:
        return "브라우저 연결에 문제가 있습니다."

# 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로 분석합니다.")
        
        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="카테고리 선택"
                )
                
                user_prompt = gr.Textbox(
                    label="분석 요청사항 (선택사항)",
                    placeholder="특별히 분석하고 싶은 내용이 있다면 입력하세요...",
                    lines=3
                )
                
                analyze_btn = gr.Button("분석 시작", variant="primary")
                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
                )
                status_output = gr.Textbox(label="상태 메시지")
        
        # 이벤트 핸들러
        analyze_btn.click(
            fn=main_process,
            inputs=[geo_dropdown, time_dropdown, category_dropdown, user_prompt],
            outputs=[screenshot_output, 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 환경에서 실행 중...")
    
    # 브라우저 초기화 (백그라운드에서)
    init_thread = threading.Thread(target=init_browser, daemon=True)
    init_thread.start()
    
    # 종료 시 브라우저 정리
    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()