Update app.py

app.py

@@ -4,209 +4,310 @@ import os
 import sqlite3
 from datetime import datetime, timedelta
 import re
+import anthropic
 
 API_KEY = os.getenv("YOUTUBE_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+
 youtube = build("youtube", "v3", developerKey=API_KEY)
+claude_client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY) if ANTHROPIC_API_KEY else None
+
+# ============================================
+# 🎨 Comic Classic Theme CSS
+# ============================================
+css = """
+@import url('https://fonts.googleapis.com/css2?family=Bangers&family=Comic+Neue:wght@400;700&display=swap');
+
+.gradio-container {
+    background-color: #FEF9C3 !important;
+    background-image: radial-gradient(#1F2937 1px, transparent 1px) !important;
+    background-size: 20px 20px !important;
+    min-height: 100vh !important;
+    font-family: 'Comic Neue', cursive, sans-serif !important;
+}
+
+footer, .footer, .gradio-container footer, .built-with, [class*="footer"] {
+    display: none !important;
+}
+
+.header-text h1 {
+    font-family: 'Bangers', cursive !important;
+    color: #1F2937 !important;
+    font-size: 2.8rem !important;
+    text-align: center !important;
+    text-shadow: 4px 4px 0px #FACC15, 6px 6px 0px #1F2937 !important;
+    letter-spacing: 3px !important;
+    -webkit-text-stroke: 1px #1F2937 !important;
+}
+
+.gr-panel, .gr-box, .gr-form, .block, .gr-group {
+    background: #FFFFFF !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    box-shadow: 6px 6px 0px #1F2937 !important;
+}
+
+.gr-button-primary, button.primary {
+    background: #3B82F6 !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    color: #FFFFFF !important;
+    font-family: 'Bangers', cursive !important;
+    font-size: 1.2rem !important;
+    letter-spacing: 2px !important;
+    box-shadow: 5px 5px 0px #1F2937 !important;
+    text-shadow: 1px 1px 0px #1F2937 !important;
+}
+
+.gr-button-primary:hover { background: #2563EB !important; transform: translate(-2px, -2px) !important; }
+.gr-button-primary:active { transform: translate(3px, 3px) !important; box-shadow: 2px 2px 0px #1F2937 !important; }
+
+.gr-button-secondary, button.secondary {
+    background: #EF4444 !important;
+    border: 3px solid #1F2937 !important;
+    color: #FFFFFF !important;
+    font-family: 'Bangers', cursive !important;
+    box-shadow: 4px 4px 0px #1F2937 !important;
+}
+
+textarea, input[type="text"], input[type="number"] {
+    background: #FFFFFF !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    color: #1F2937 !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+}
+
+label, .gr-input-label, .gr-block-label {
+    color: #1F2937 !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+}
+
+.gr-accordion {
+    background: #FACC15 !important;
+    border: 3px solid #1F2937 !important;
+    box-shadow: 4px 4px 0px #1F2937 !important;
+}
+
+::-webkit-scrollbar { width: 12px; }
+::-webkit-scrollbar-track { background: #FEF9C3; border: 2px solid #1F2937; }
+::-webkit-scrollbar-thumb { background: #3B82F6; border: 2px solid #1F2937; }
+::-webkit-scrollbar-thumb:hover { background: #EF4444; }
+
+::selection { background: #FACC15; color: #1F2937; }
+"""
 
 # DB 초기화
 def init_db():
     conn = sqlite3.connect("youtube_data.db")
     c = conn.cursor()
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS videos (
-            video_id TEXT PRIMARY KEY,
-            title TEXT,
-            channel_id TEXT,
-            channel_name TEXT,
-            thumbnail TEXT,
-            published_at TEXT,
-            first_seen TEXT
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS videos (
+        video_id TEXT PRIMARY KEY, title TEXT, channel_id TEXT, channel_name TEXT,
+        thumbnail TEXT, published_at TEXT, first_seen TEXT
+    )''')
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS video_stats (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            video_id TEXT,
-            views INTEGER,
-            likes INTEGER,
-            comments INTEGER,
-            recorded_at TEXT,
-            FOREIGN KEY (video_id) REFERENCES videos(video_id)
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS video_stats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, video_id TEXT, views INTEGER,
+        likes INTEGER, comments INTEGER, recorded_at TEXT
+    )''')
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS channels (
-            channel_id TEXT PRIMARY KEY,
-            channel_name TEXT,
-            first_seen TEXT
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS channels (
+        channel_id TEXT PRIMARY KEY, channel_name TEXT, first_seen TEXT
+    )''')
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS channel_stats (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            channel_id TEXT,
-            subscribers INTEGER,
-            recorded_at TEXT,
-            FOREIGN KEY (channel_id) REFERENCES channels(channel_id)
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS channel_stats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, channel_id TEXT, subscribers INTEGER, recorded_at TEXT
+    )''')
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS search_history (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            keyword TEXT,
-            country TEXT,
-            language TEXT,
-            sort_by TEXT,
-            results_count INTEGER,
-            searched_at TEXT
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS search_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, keyword TEXT, country TEXT,
+        language TEXT, sort_by TEXT, results_count INTEGER, searched_at TEXT
+    )''')
     
-    c.execute('''
-        CREATE TABLE IF NOT EXISTS trending_alerts (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            video_id TEXT,
-            alert_type TEXT,
-            old_value INTEGER,
-            new_value INTEGER,
-            change_percent REAL,
-            detected_at TEXT,
-            FOREIGN KEY (video_id) REFERENCES videos(video_id)
-        )
-    ''')
+    c.execute('''CREATE TABLE IF NOT EXISTS trending_alerts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, video_id TEXT, alert_type TEXT,
+        old_value INTEGER, new_value INTEGER, change_percent REAL, detected_at TEXT
+    )''')
     
     conn.commit()
     conn.close()
 
 init_db()
 
-# 국가 코드 + 기본 언어 매핑
+# 국가 코드
 COUNTRIES = {
-    "전세계": ("", ""),
-    "중국": ("CN", "zh"),
-    "인도": ("IN", "hi"),
-    "미국": ("US", "en"),
-    "인도네시아": ("ID", "id"),
-    "파키스탄": ("PK", "ur"),
-    "브라질": ("BR", "pt"),
-    "나이지리아": ("NG", "en"),
-    "방글라데시": ("BD", "bn"),
-    "러시아": ("RU", "ru"),
-    "멕시코": ("MX", "es"),
-    "일본": ("JP", "ja"),
-    "에티오피아": ("ET", "am"),
-    "필리핀": ("PH", "tl"),
-    "이집트": ("EG", "ar"),
-    "베트남": ("VN", "vi"),
-    "콩고민주공화국": ("CD", "fr"),
-    "터키": ("TR", "tr"),
-    "이란": ("IR", "fa"),
-    "독일": ("DE", "de"),
-    "태국": ("TH", "th"),
-    "영국": ("GB", "en"),
-    "프랑스": ("FR", "fr"),
-    "이탈리아": ("IT", "it"),
-    "남아공": ("ZA", "en"),
-    "탄자니아": ("TZ", "sw"),
-    "미얀마": ("MM", "my"),
-    "한국": ("KR", "ko"),
-    "콜롬비아": ("CO", "es"),
-    "케냐": ("KE", "sw"),
-    "스페인": ("ES", "es"),
-    "아르헨티나": ("AR", "es"),
-    "알제리": ("DZ", "ar"),
-    "우크라이나": ("UA", "uk"),
-    "이라크": ("IQ", "ar"),
-    "캐나다": ("CA", "en"),
-    "폴란드": ("PL", "pl"),
-    "모로코": ("MA", "ar"),
-    "사우디": ("SA", "ar"),
-    "페루": ("PE", "es"),
-    "말레이시아": ("MY", "ms"),
+    "전세계": ("", ""), "중국": ("CN", "zh"), "인도": ("IN", "hi"), "미국": ("US", "en"),
+    "인도네시아": ("ID", "id"), "파키스탄": ("PK", "ur"), "브라질": ("BR", "pt"),
+    "나이지리아": ("NG", "en"), "방글라데시": ("BD", "bn"), "러시아": ("RU", "ru"),
+    "멕시코": ("MX", "es"), "일본": ("JP", "ja"), "에티오피아": ("ET", "am"),
+    "필리핀": ("PH", "tl"), "이집트": ("EG", "ar"), "베트남": ("VN", "vi"),
+    "콩고민주공화국": ("CD", "fr"), "터키": ("TR", "tr"), "이란": ("IR", "fa"),
+    "독일": ("DE", "de"), "태국": ("TH", "th"), "영국": ("GB", "en"),
+    "프랑스": ("FR", "fr"), "이탈리아": ("IT", "it"), "남아공": ("ZA", "en"),
+    "탄자니아": ("TZ", "sw"), "미얀마": ("MM", "my"), "한국": ("KR", "ko"),
+    "콜롬비아": ("CO", "es"), "케냐": ("KE", "sw"), "스페인": ("ES", "es"),
+    "아르헨티나": ("AR", "es"), "알제리": ("DZ", "ar"), "우크라이나": ("UA", "uk"),
+    "이라크": ("IQ", "ar"), "캐나다": ("CA", "en"), "폴란드": ("PL", "pl"),
+    "모로코": ("MA", "ar"), "사우디": ("SA", "ar"), "페루": ("PE", "es"), "말레이시아": ("MY", "ms"),
 }
 
 LANGUAGES = {
-    "자동 (국가 기반)": "",
-    "영어": "en",
-    "중국어": "zh",
-    "힌디어": "hi",
-    "스페인어": "es",
-    "아랍어": "ar",
-    "벵골어": "bn",
-    "포르투갈어": "pt",
-    "러시아어": "ru",
-    "일본어": "ja",
-    "펀자브어": "pa",
-    "독일어": "de",
-    "인도네시아어": "id",
-    "페르시아어": "fa",
-    "프랑스어": "fr",
-    "베트남어": "vi",
-    "터키어": "tr",
-    "한국어": "ko",
-    "타밀어": "ta",
-    "이탈리아어": "it",
-    "텔루구어": "te",
-    "마라티어": "mr",
-    "우르두어": "ur",
-    "태국어": "th",
-    "구자라트어": "gu",
-    "폴란드어": "pl",
-    "말라얄람어": "ml",
-    "칸나다어": "kn",
-    "우크라이나어": "uk",
-    "필리핀어": "tl",
-    "미얀마어": "my",
-    "네덜란드어": "nl",
-    "루마니아어": "ro",
-    "스와힐리어": "sw",
-    "그리스어": "el",
-    "체코어": "cs",
-    "헝가리어": "hu",
-    "스웨덴어": "sv",
-    "히브리어": "he",
-    "핀란드어": "fi",
-    "노르웨이어": "no",
+    "자동 (국가 기반)": "", "영어": "en", "중국어": "zh", "힌디어": "hi",
+    "스페인어": "es", "아랍어": "ar", "벵골어": "bn", "포르투갈어": "pt",
+    "러시아어": "ru", "일본어": "ja", "펀자브어": "pa", "독일어": "de",
+    "인도네시아어": "id", "페르시아어": "fa", "프랑스어": "fr", "베트남어": "vi",
+    "터키어": "tr", "한국어": "ko", "타밀어": "ta", "이탈리아어": "it",
+    "텔루구어": "te", "마라티어": "mr", "우르두어": "ur", "태국어": "th",
+    "구자라트어": "gu", "폴란드어": "pl", "말라얄람어": "ml", "칸나다어": "kn",
+    "우크라이나어": "uk", "필리핀어": "tl", "미얀마어": "my", "네덜란드어": "nl",
+    "루마니아어": "ro", "스와힐리어": "sw", "그리스어": "el", "체코어": "cs",
+    "헝가리어": "hu", "스웨덴어": "sv", "히브리어": "he", "핀란드어": "fi", "노르웨이어": "no",
 }
 
-SORT_OPTIONS = {
-    "조회수 순": "viewCount",
-    "최신순": "date",
-    "관련성 순": "relevance",
-    "평점 순": "rating",
-}
-
-DATE_OPTIONS = {
-    "전체 기간": "",
-    "오늘": "today",
-    "이번 주": "thisWeek",
-    "이번 달": "thisMonth",
-    "올해": "thisYear",
-}
+SORT_OPTIONS = {"조회수 순": "viewCount", "최신순": "date", "관련성 순": "relevance", "평점 순": "rating"}
+DATE_OPTIONS = {"전체 기간": "", "오늘": "today", "이번 주": "thisWeek", "이번 달": "thisMonth", "올해": "thisYear"}
 
 def format_count(count):
-    if count >= 1000000000:
-        return f"{count/1000000000:.1f}B"
-    elif count >= 1000000:
-        return f"{count/1000000:.1f}M"
-    elif count >= 1000:
-        return f"{count/1000:.1f}K"
+    if count >= 1000000000: return f"{count/1000000000:.1f}B"
+    elif count >= 1000000: return f"{count/1000000:.1f}M"
+    elif count >= 1000: return f"{count/1000:.1f}K"
     return str(count)
 
+def get_ai_pick_rating(videos_data):
+    """Claude API로 AI Pick 등급 산정"""
+    if not claude_client or not videos_data:
+        # API 없으면 자체 알고리즘으로 계산
+        return calculate_local_rating(videos_data)
+    
+    try:
+        # 상위 100개만 분석 (API 비용 절감)
+        sample = videos_data[:100]
+        
+        video_info = "\n".join([
+            f"#{i+1}. 제목: {v['title'][:50]}, 채널: {v['channel_name']}, "
+            f"조회수: {v['views']}, 좋아요: {v['likes']}, 댓글: {v['comments']}, "
+            f"구독자: {v.get('subs', 0)}"
+            for i, v in enumerate(sample)
+        ])
+        
+        response = claude_client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=2000,
+            messages=[{
+                "role": "user",
+                "content": f"""다음 YouTube 영상 목록을 분석하여 각 영상의 종합 품질 등급을 매겨주세요.
+
+평가 기준:
+- 조회수 대비 좋아요/댓글 비율 (engagement)
+- 채널 구독자 대비 조회수 (viral potential)
+- 전반적인 인기도와 성장 가능성
+
+등급 (숫자로만 응답):
+0 = 없음 (평균 이하)
+1 = ♥ (평균)
+2 = ⭐ (좋음)
+3 = ⭐⭐ (매우 좋음)
+4 = ⭐⭐⭐ (최고)
+
+각 영상 번호와 등급만 쉼표로 구분하여 응답하세요.
+예시: 1:3,2:2,3:4,4:1,5:0
+
+영상 목록:
+{video_info}
+
+응답 (번호:등급 형식으로만):"""
+            }]
+        )
+        
+        # 응답 파싱
+        ratings = {}
+        result_text = response.content[0].text.strip()
+        pairs = re.findall(r'(\d+):(\d)', result_text)
+        for idx, rating in pairs:
+            ratings[int(idx)-1] = int(rating)
+        
+        return ratings
+    
+    except Exception as e:
+        print(f"AI Rating Error: {e}")
+        return calculate_local_rating(videos_data)
+
+def calculate_local_rating(videos_data):
+    """로컬 알고리즘으로 등급 계산"""
+    ratings = {}
+    
+    if not videos_data:
+        return ratings
+    
+    # 통계 계산
+    views_list = [v['views'] for v in videos_data if v['views'] > 0]
+    if not views_list:
+        return ratings
+    
+    avg_views = sum(views_list) / len(views_list)
+    max_views = max(views_list)
+    
+    for i, v in enumerate(videos_data):
+        views = v['views']
+        likes = v['likes']
+        comments = v['comments']
+        subs = v.get('subs', 0)
+        
+        # 스코어 계산
+        score = 0
+        
+        # 조회수 점수 (0-40)
+        if views > 0:
+            view_score = min(40, (views / max_views) * 40)
+            score += view_score
+        
+        # engagement 점수 (0-30)
+        if views > 0:
+            engagement = ((likes + comments * 2) / views) * 100
+            engagement_score = min(30, engagement * 3)
+            score += engagement_score
+        
+        # viral 점수 (구독자 ���비 조회수) (0-30)
+        if subs > 0 and views > 0:
+            viral = views / subs
+            viral_score = min(30, viral * 10)
+            score += viral_score
+        elif views > avg_views:
+            score += 15
+        
+        # 등급 결정
+        if score >= 70:
+            ratings[i] = 4  # ⭐⭐⭐
+        elif score >= 50:
+            ratings[i] = 3  # ⭐⭐
+        elif score >= 30:
+            ratings[i] = 2  # ⭐
+        elif score >= 15:
+            ratings[i] = 1  # ♥
+        else:
+            ratings[i] = 0  # 없음
+    
+    return ratings
+
+def get_rating_display(rating):
+    """등급을 이모지로 변환"""
+    displays = {
+        0: "",
+        1: "♥",
+        2: "⭐",
+        3: "⭐⭐",
+        4: "⭐⭐⭐"
+    }
+    return displays.get(rating, "")
+
 def get_real_trending_keywords(region_code="KR", language="ko"):
-    """YouTube 인기 동영상에서 실제 트렌딩 키워드 추출"""
     try:
-        # 1. 인기 동영상 가져오기
         response = youtube.videos().list(
-            part="snippet",
-            chart="mostPopular",
-            regionCode=region_code if region_code else "US",
-            maxResults=50
+            part="snippet", chart="mostPopular",
+            regionCode=region_code if region_code else "US", maxResults=50
         ).execute()
         
         keywords = []
@@ -217,236 +318,122 @@ def get_real_trending_keywords(region_code="KR", language="ko"):
             channel = item["snippet"]["channelTitle"]
             tags = item["snippet"].get("tags", [])
             
-            # 태그에서 키워드 추출
             for tag in tags[:3]:
                 tag_clean = tag.strip().lower()
                 if tag_clean not in seen and 2 <= len(tag_clean) <= 20:
                     keywords.append(tag)
                     seen.add(tag_clean)
             
-            # 채널명 추출
-            if channel not in seen and len(channel) > 1:
+            if channel not in seen:
                 keywords.append(channel)
                 seen.add(channel.lower())
             
-            # 제목에서 주요 단어 추출 (한글/영문)
-            if region_code == "KR":
-                words = re.findall(r'[가-힣]{2,10}', title)
-            else:
-                words = re.findall(r'[A-Za-z]{3,15}', title)
-            
+            words = re.findall(r'[가-힣]{2,10}' if region_code == "KR" else r'[A-Za-z]{3,15}', title)
             for word in words[:2]:
-                word_lower = word.lower()
-                if word_lower not in seen and word_lower not in ['the', 'and', 'for', 'with', 'this', 'that', 'from']:
+                if word.lower() not in seen and word.lower() not in ['the','and','for','with']:
                     keywords.append(word)
-                    seen.add(word_lower)
+                    seen.add(word.lower())
             
             if len(keywords) >= 30:
                 break
         
-        # 2. 인기 검색어 추가 (카테고리별)
-        popular_categories = {
-            "KR": ["뉴진스", "BTS", "먹방", "브이로그", "게임", "shorts", "드라마", "영화", "음악", "코딩", "AI", "축구", "야구", "아이돌", "뷰티"],
-            "US": ["Taylor Swift", "NBA", "NFL", "gaming", "mukbang", "vlog", "music", "movie", "AI", "coding", "shorts", "podcast", "news", "tech", "finance"],
-            "JP": ["アニメ", "ゲーム", "音楽", "vlog", "料理", "猫", "犬", "ニュース", "映画", "ドラマ", "歌ってみた", "踊ってみた", "ASMR", "shorts", "AI"],
+        popular = {
+            "KR": ["뉴진스","BTS","먹방","브이로그","게임","shorts","드라마","영화","음악","코딩","AI","축구"],
+            "US": ["Taylor Swift","NBA","NFL","gaming","vlog","music","AI","coding","shorts","news"],
+            "JP": ["アニメ","ゲーム","音楽","vlog","料理","猫","映画","ASMR","shorts","AI"],
         }
-        
-        extra = popular_categories.get(region_code, popular_categories["US"])
-        for kw in extra:
+        for kw in popular.get(region_code, popular["US"]):
             if kw.lower() not in seen:
                 keywords.append(kw)
                 seen.add(kw.lower())
         
-        return keywords[:20] if keywords else get_default_trending(region_code)
-    
-    except Exception as e:
-        print(f"트렌딩 키워드 오류: {e}")
-        return get_default_trending(region_code)
-
-def get_default_trending(region_code="KR"):
-    """기본 인기 검색어 (국가별)"""
-    defaults = {
-        "KR": ["AI", "ChatGPT", "뉴진스", "BTS", "게임", "먹방", "브이로그", "shorts", "음악", "축구", "드라마", "영화", "코딩", "주식", "부동산"],
-        "US": ["AI", "ChatGPT", "gaming", "music", "NBA", "NFL", "vlog", "shorts", "movie", "news", "tech", "finance", "cooking", "fitness", "travel"],
-        "JP": ["AI", "アニメ", "ゲーム", "音楽", "vlog", "料理", "ニュース", "映画", "shorts", "ASMR", "猫", "旅行", "ファ��ション", "コスメ", "勉強"],
-    }
-    return defaults.get(region_code, defaults["US"])
+        return keywords[:20] if keywords else ["AI","ChatGPT","뉴진스","BTS","게임","먹방","브이로그","shorts"]
+    except:
+        return ["AI","ChatGPT","뉴진스","BTS","게임","먹방","브이로그","shorts","음악","축구"]
 
 def save_to_db(videos_data, channels_data, keyword, country, language, sort_by):
     conn = sqlite3.connect("youtube_data.db")
     c = conn.cursor()
     now = datetime.now().isoformat()
     
-    c.execute('''
-        INSERT INTO search_history (keyword, country, language, sort_by, results_count, searched_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-    ''', (keyword, country, language, sort_by, len(videos_data), now))
+    c.execute('INSERT INTO search_history (keyword,country,language,sort_by,results_count,searched_at) VALUES (?,?,?,?,?,?)',
+              (keyword, country, language, sort_by, len(videos_data), now))
     
     for video in videos_data:
-        c.execute('''
-            INSERT OR IGNORE INTO videos (video_id, title, channel_id, channel_name, thumbnail, published_at, first_seen)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        ''', (video['video_id'], video['title'], video['channel_id'], video['channel_name'], 
-              video['thumbnail'], video['published_at'], now))
+        c.execute('INSERT OR IGNORE INTO videos (video_id,title,channel_id,channel_name,thumbnail,published_at,first_seen) VALUES (?,?,?,?,?,?,?)',
+                  (video['video_id'], video['title'], video['channel_id'], video['channel_name'], video['thumbnail'], video['published_at'], now))
         
-        c.execute('''
-            SELECT views FROM video_stats 
-            WHERE video_id = ? 
-            ORDER BY recorded_at DESC LIMIT 1
-        ''', (video['video_id'],))
-        prev_stats = c.fetchone()
+        c.execute('SELECT views FROM video_stats WHERE video_id=? ORDER BY recorded_at DESC LIMIT 1', (video['video_id'],))
+        prev = c.fetchone()
         
-        c.execute('''
-            INSERT INTO video_stats (video_id, views, likes, comments, recorded_at)
-            VALUES (?, ?, ?, ?, ?)
-        ''', (video['video_id'], video['views'], video['likes'], video['comments'], now))
+        c.execute('INSERT INTO video_stats (video_id,views,likes,comments,recorded_at) VALUES (?,?,?,?,?)',
+                  (video['video_id'], video['views'], video['likes'], video['comments'], now))
         
-        if prev_stats and prev_stats[0] > 0:
-            change_percent = ((video['views'] - prev_stats[0]) / prev_stats[0]) * 100
-            if change_percent >= 20:
-                c.execute('''
-                    INSERT INTO trending_alerts (video_id, alert_type, old_value, new_value, change_percent, detected_at)
-                    VALUES (?, ?, ?, ?, ?, ?)
-                ''', (video['video_id'], 'views_surge', prev_stats[0], video['views'], change_percent, now))
-    
-    for channel_id, subs in channels_data.items():
-        c.execute('INSERT OR IGNORE INTO channels (channel_id, channel_name, first_seen) VALUES (?, ?, ?)', 
-                  (channel_id, '', now))
+        if prev and prev[0] > 0:
+            change = ((video['views'] - prev[0]) / prev[0]) * 100
+            if change >= 20:
+                c.execute('INSERT INTO trending_alerts (video_id,alert_type,old_value,new_value,change_percent,detected_at) VALUES (?,?,?,?,?,?)',
+                          (video['video_id'], 'views_surge', prev[0], video['views'], change, now))
+    
+    for ch_id, subs in channels_data.items():
+        c.execute('INSERT OR IGNORE INTO channels (channel_id,channel_name,first_seen) VALUES (?,?,?)', (ch_id, '', now))
         if isinstance(subs, int):
-            c.execute('INSERT INTO channel_stats (channel_id, subscribers, recorded_at) VALUES (?, ?, ?)', 
-                      (channel_id, subs, now))
+            c.execute('INSERT INTO channel_stats (channel_id,subscribers,recorded_at) VALUES (?,?,?)', (ch_id, subs, now))
     
     conn.commit()
     conn.close()
 
-def get_trending_alerts():
-    conn = sqlite3.connect("youtube_data.db")
-    c = conn.cursor()
-    c.execute('''
-        SELECT ta.video_id, v.title, v.channel_name, ta.alert_type, 
-               ta.old_value, ta.new_value, ta.change_percent, ta.detected_at
-        FROM trending_alerts ta
-        JOIN videos v ON ta.video_id = v.video_id
-        ORDER BY ta.detected_at DESC LIMIT 20
-    ''')
-    alerts = c.fetchall()
-    conn.close()
-    return alerts
-
-def get_search_history():
-    conn = sqlite3.connect("youtube_data.db")
-    c = conn.cursor()
-    c.execute('''
-        SELECT keyword, country, language, sort_by, results_count, searched_at
-        FROM search_history ORDER BY searched_at DESC LIMIT 50
-    ''')
-    history = c.fetchall()
-    conn.close()
-    return history
-
-def get_top_growing_videos(hours=24):
-    conn = sqlite3.connect("youtube_data.db")
-    c = conn.cursor()
-    cutoff = (datetime.now() - timedelta(hours=hours)).isoformat()
-    c.execute('''
-        SELECT v.video_id, v.title, v.channel_name, v.thumbnail,
-               MIN(vs.views) as min_views, MAX(vs.views) as max_views,
-               ((MAX(vs.views) - MIN(vs.views)) * 100.0 / MIN(vs.views)) as growth_rate
-        FROM videos v
-        JOIN video_stats vs ON v.video_id = vs.video_id
-        WHERE vs.recorded_at > ?
-        GROUP BY v.video_id
-        HAVING min_views > 0 AND max_views > min_views
-        ORDER BY growth_rate DESC LIMIT 10
-    ''', (cutoff,))
-    results = c.fetchall()
-    conn.close()
-    return results
-
 def get_db_stats():
     conn = sqlite3.connect("youtube_data.db")
     c = conn.cursor()
-    c.execute("SELECT COUNT(*) FROM videos")
-    video_count = c.fetchone()[0]
-    c.execute("SELECT COUNT(*) FROM video_stats")
-    stats_count = c.fetchone()[0]
-    c.execute("SELECT COUNT(*) FROM channels")
-    channel_count = c.fetchone()[0]
-    c.execute("SELECT COUNT(*) FROM search_history")
-    search_count = c.fetchone()[0]
-    c.execute("SELECT COUNT(*) FROM trending_alerts")
-    alert_count = c.fetchone()[0]
+    stats = {}
+    for table, key in [("videos","videos"),("video_stats","stats"),("channels","channels"),("search_history","searches"),("trending_alerts","alerts")]:
+        c.execute(f"SELECT COUNT(*) FROM {table}")
+        stats[key] = c.fetchone()[0]
     conn.close()
-    return {"videos": video_count, "stats_records": stats_count, "channels": channel_count, 
-            "searches": search_count, "alerts": alert_count}
+    return stats
 
 def update_trending(country):
-    """국가 변경시 트렌딩 키워드 + 언어 자동 업데이트"""
-    region, default_lang = COUNTRIES.get(country, ("", ""))
-    keywords = get_real_trending_keywords(region if region else "US", default_lang)
+    region, lang = COUNTRIES.get(country, ("", ""))
+    keywords = get_real_trending_keywords(region or "US", lang)
     return gr.update(choices=keywords, value=None)
 
-def use_trending_keyword(trending_keyword):
-    return trending_keyword if trending_keyword else ""
+def use_trending_keyword(kw):
+    return kw if kw else ""
 
-def search_videos(keyword, country, language, sort_by, date_filter, max_results, save_db_flag=True):
+def search_videos(keyword, country, language, sort_by, date_filter, max_results):
     if not keyword or not keyword.strip():
-        return "검색어를 입력하세요.", ""
+        return "⚠️ 검색어를 입력하세요!", ""
     
     max_results = int(max_results)
     all_items = []
-    next_page_token = None
+    next_page = None
     
-    # 국가 코드 + 기본 언어 가져오기
     region_code, default_lang = COUNTRIES.get(country, ("", ""))
+    lang_code = default_lang if language == "자동 (국가 기반)" else LANGUAGES.get(language, "")
     
-    # 언어 설정: "자동"이면 국가 기본 언어 사용
-    if language == "자동 (국가 기반)":
-        lang_code = default_lang
-    else:
-        lang_code = LANGUAGES.get(language, "")
-    
-    search_params = {
-        "q": keyword,
-        "part": "snippet",
-        "type": "video",
-        "order": SORT_OPTIONS[sort_by],
-    }
-    
-    # 국가 + 언어 둘 다 적용
-    if region_code:
-        search_params["regionCode"] = region_code
-    if lang_code:
-        search_params["relevanceLanguage"] = lang_code
+    params = {"q": keyword, "part": "snippet", "type": "video", "order": SORT_OPTIONS[sort_by]}
+    if region_code: params["regionCode"] = region_code
+    if lang_code: params["relevanceLanguage"] = lang_code
     
     if date_filter != "전체 기간":
         now = datetime.utcnow()
-        if date_filter == "오늘":
-            after = now - timedelta(days=1)
-        elif date_filter == "이번 주":
-            after = now - timedelta(weeks=1)
-        elif date_filter == "이번 달":
-            after = now - timedelta(days=30)
-        elif date_filter == "올해":
-            after = now - timedelta(days=365)
-        search_params["publishedAfter"] = after.strftime("%Y-%m-%dT%H:%M:%SZ")
+        deltas = {"오늘": 1, "이번 주": 7, "이번 달": 30, "올해": 365}
+        after = now - timedelta(days=deltas.get(date_filter, 0))
+        params["publishedAfter"] = after.strftime("%Y-%m-%dT%H:%M:%SZ")
     
+    # 페이지네이션으로 최대 1000개까지
     while len(all_items) < max_results:
-        search_params["maxResults"] = min(50, max_results - len(all_items))
-        if next_page_token:
-            search_params["pageToken"] = next_page_token
-        
-        response = youtube.search().list(**search_params).execute()
-        items = response.get("items", [])
+        params["maxResults"] = min(50, max_results - len(all_items))
+        if next_page: params["pageToken"] = next_page
         
-        if not items:
-            break
+        resp = youtube.search().list(**params).execute()
+        items = resp.get("items", [])
+        if not items: break
         
         all_items.extend(items)
-        next_page_token = response.get("nextPageToken")
-        
-        if not next_page_token:
-            break
+        next_page = resp.get("nextPageToken")
+        if not next_page: break
     
     if not all_items:
         return "검색 결과가 없습니다.", ""
@@ -454,144 +441,138 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
     video_ids = [item["id"]["videoId"] for item in all_items]
     channel_ids = list(set([item["snippet"]["channelId"] for item in all_items]))
     
+    # 비디오 통계
     video_stats = {}
     for i in range(0, len(video_ids), 50):
-        batch_ids = video_ids[i:i+50]
-        video_details = youtube.videos().list(id=",".join(batch_ids), part="statistics").execute()
-        for v in video_details.get("items", []):
-            stats = v["statistics"]
+        batch = video_ids[i:i+50]
+        details = youtube.videos().list(id=",".join(batch), part="statistics").execute()
+        for v in details.get("items", []):
+            s = v["statistics"]
             video_stats[v["id"]] = {
-                "views": int(stats.get("viewCount", 0)),
-                "views_fmt": format_count(int(stats.get("viewCount", 0))),
-                "likes": int(stats.get("likeCount", 0)),
-                "likes_fmt": format_count(int(stats.get("likeCount", 0))),
-                "comments": int(stats.get("commentCount", 0)),
-                "comments_fmt": format_count(int(stats.get("commentCount", 0))),
+                "views": int(s.get("viewCount", 0)),
+                "likes": int(s.get("likeCount", 0)),
+                "comments": int(s.get("commentCount", 0)),
             }
     
+    # 채널 통계
     channel_subs = {}
     channel_subs_raw = {}
     for i in range(0, len(channel_ids), 50):
-        batch_ids = channel_ids[i:i+50]
-        channel_details = youtube.channels().list(id=",".join(batch_ids), part="statistics").execute()
-        for ch in channel_details.get("items", []):
-            sub_count = ch["statistics"].get("subscriberCount", "0")
-            if sub_count:
-                channel_subs_raw[ch["id"]] = int(sub_count)
-                channel_subs[ch["id"]] = format_count(int(sub_count))
+        batch = channel_ids[i:i+50]
+        details = youtube.channels().list(id=",".join(batch), part="statistics").execute()
+        for ch in details.get("items", []):
+            sub = ch["statistics"].get("subscriberCount", "0")
+            if sub:
+                channel_subs_raw[ch["id"]] = int(sub)
+                channel_subs[ch["id"]] = format_count(int(sub))
             else:
                 channel_subs[ch["id"]] = "비공개"
     
+    # 데이터 준비
     videos_data = []
     for item in all_items:
-        video_id = item["id"]["videoId"]
-        snippet = item["snippet"]
-        stats = video_stats.get(video_id, {})
+        vid = item["id"]["videoId"]
+        snip = item["snippet"]
+        st = video_stats.get(vid, {})
         videos_data.append({
-            "video_id": video_id,
-            "title": snippet["title"],
-            "channel_id": snippet["channelId"],
-            "channel_name": snippet["channelTitle"],
-            "thumbnail": snippet["thumbnails"]["default"]["url"],
-            "published_at": snippet["publishedAt"],
-            "views": stats.get("views", 0),
-            "likes": stats.get("likes", 0),
-            "comments": stats.get("comments", 0),
+            "video_id": vid, "title": snip["title"],
+            "channel_id": snip["channelId"], "channel_name": snip["channelTitle"],
+            "thumbnail": snip["thumbnails"]["default"]["url"],
+            "published_at": snip["publishedAt"],
+            "views": st.get("views", 0), "likes": st.get("likes", 0),
+            "comments": st.get("comments", 0),
+            "subs": channel_subs_raw.get(snip["channelId"], 0),
         })
     
-    if save_db_flag:
-        save_to_db(videos_data, channel_subs_raw, keyword, country, language, sort_by)
+    # AI Pick 등급 계산
+    ai_ratings = get_ai_pick_rating(videos_data)
     
-    # JavaScript 정렬 기능 포함 HTML
+    # DB 저장
+    save_to_db(videos_data, channel_subs_raw, keyword, country, language, sort_by)
+    
+    # HTML 생성
     html = f'''
     <style>
-        .yt-table {{ width: 100%; border-collapse: collapse; font-size: 14px; }}
+        .yt-table {{ width:100%; border-collapse:collapse; font-family:'Comic Neue',cursive; }}
         .yt-table th {{ 
-            background: #ff0000; color: white; padding: 12px 8px; 
-            text-align: left; position: sticky; top: 0; cursor: pointer;
-            user-select: none;
+            background:#EF4444; color:white; padding:12px 8px; text-align:left;
+            cursor:pointer; user-select:none; border:2px solid #1F2937;
+            font-family:'Bangers',cursive; letter-spacing:1px;
+        }}
+        .yt-table th:hover {{ background:#DC2626; }}
+        .yt-table th.sort-asc::after {{ content:" ▲"; }}
+        .yt-table th.sort-desc::after {{ content:" ▼"; }}
+        .yt-table td {{ padding:10px 8px; border-bottom:2px solid #1F2937; vertical-align:middle; background:#FFFFFF; }}
+        .yt-table tr:hover td {{ background:#FEF9C3; }}
+        .yt-table img {{ border-radius:4px; border:2px solid #1F2937; }}
+        .yt-table a {{ color:#3B82F6; text-decoration:none; font-weight:700; }}
+        .yt-table a:hover {{ color:#EF4444; }}
+        .yt-rank {{ font-family:'Bangers',cursive; color:#EF4444; text-align:center; font-size:1.1rem; }}
+        .yt-views {{ font-weight:700; color:#3B82F6; }}
+        .ai-pick {{ color:#FACC15; text-shadow:1px 1px 0 #1F2937; font-size:1.1rem; }}
+        .result-header {{ 
+            background:#3B82F6; color:white; padding:15px; border-radius:8px;
+            border:3px solid #1F2937; box-shadow:4px 4px 0 #1F2937;
+            font-family:'Comic Neue',cursive; font-weight:700; margin-bottom:15px;
         }}
-        .yt-table th:hover {{ background: #cc0000; }}
-        .yt-table th::after {{ content: " ⇅"; font-size: 10px; opacity: 0.7; }}
-        .yt-table th.sort-asc::after {{ content: " ▲"; opacity: 1; }}
-        .yt-table th.sort-desc::after {{ content: " ▼"; opacity: 1; }}
-        .yt-table td {{ padding: 10px 8px; border-bottom: 1px solid #ddd; vertical-align: middle; }}
-        .yt-table tr:hover {{ background: #f5f5f5; }}
-        .yt-table img {{ border-radius: 4px; }}
-        .yt-table a {{ color: #1a0dab; text-decoration: none; }}
-        .yt-table a:hover {{ text-decoration: underline; }}
-        .yt-rank {{ font-weight: bold; color: #ff0000; text-align: center; }}
-        .yt-views {{ font-weight: bold; color: #065fd4; }}
-        .yt-subs {{ color: #606060; }}
-        .yt-date {{ color: #888; font-size: 12px; }}
     </style>
     
-    <p><b>총 {len(all_items)}개 결과</b> | 검색어: "{keyword}" | 국가: {country} | 언어: {language} | 정렬: {sort_by}</p>
-    <p style="color: #666; font-size: 12px;">💡 테이블 헤더 클릭시 해당 컬럼으로 정렬됩니다</p>
-    
-    <div style="max-height: 800px; overflow-y: auto;">
-    <table class="yt-table" id="resultTable">
-        <thead>
-            <tr>
-                <th data-type="number" style="width:50px;">순위</th>
-                <th data-type="none" style="width:120px;">썸네일</th>
-                <th data-type="string">제목</th>
-                <th data-type="string" style="width:150px;">채널</th>
-                <th data-type="number" style="width:80px;">구독자</th>
-                <th data-type="number" style="width:80px;">조회수</th>
-                <th data-type="number" style="width:60px;">좋아요</th>
-                <th data-type="number" style="width:60px;">댓글</th>
-                <th data-type="date" style="width:90px;">게시일</th>
-            </tr>
-        </thead>
+    <div class="result-header">
+        🎬 총 <b>{len(all_items)}개</b> 결과 | 🔍 "{keyword}" | 🌍 {country} | 📊 {sort_by}
+        <br><span style="font-size:0.9rem;">💡 헤더 클릭 = 정렬 | AI Pick: ♥(평균) ⭐(좋음) ⭐⭐(매우좋음) ⭐⭐⭐(최고)</span>
+    </div>
+    
+    <div style="max-height:700px; overflow-y:auto; border:3px solid #1F2937; border-radius:8px;">
+    <table class="yt-table" id="ytTable">
+        <thead><tr>
+            <th data-col="0" data-type="num" style="width:50px;">순위</th>
+            <th style="width:100px;">썸네일</th>
+            <th data-col="2" data-type="str">제목</th>
+            <th data-col="3" data-type="str" style="width:120px;">채널</th>
+            <th data-col="4" data-type="num" style="width:70px;">구독자</th>
+            <th data-col="5" data-type="num" style="width:70px;">조회수</th>
+            <th data-col="6" data-type="num" style="width:55px;">좋아요</th>
+            <th data-col="7" data-type="num" style="width:55px;">댓글</th>
+            <th data-col="8" data-type="num" style="width:70px;">AI Pick</th>
+            <th data-col="9" data-type="str" style="width:85px;">게시일</th>
+        </tr></thead>
         <tbody>
     '''
     
-    for i, item in enumerate(all_items, 1):
-        video_id = item["id"]["videoId"]
-        snippet = item["snippet"]
-        channel_id = snippet["channelId"]
+    for i, v in enumerate(videos_data):
+        vid = v["video_id"]
+        title = v["title"][:45] + "..." if len(v["title"]) > 45 else v["title"]
+        channel = v["channel_name"][:12] + "..." if len(v["channel_name"]) > 12 else v["channel_name"]
+        url = f"https://youtube.com/watch?v={vid}"
+        ch_url = f"https://youtube.com/channel/{v['channel_id']}"
+        published = v["published_at"][:10]
         
-        title = snippet["title"]
-        title_display = title[:50] + "..." if len(title) > 50 else title
-        channel = snippet["channelTitle"]
-        channel_display = channel[:15] + "..." if len(channel) > 15 else channel
-        thumbnail = snippet["thumbnails"]["default"]["url"]
-        published = snippet["publishedAt"][:10]
-        url = f"https://youtube.com/watch?v={video_id}"
-        channel_url = f"https://youtube.com/channel/{channel_id}"
+        views = v["views"]
+        likes = v["likes"]
+        comments = v["comments"]
+        subs = v["subs"]
         
-        stats = video_stats.get(video_id, {})
-        views = stats.get("views", 0)
-        views_fmt = stats.get("views_fmt", "N/A")
-        likes = stats.get("likes", 0)
-        likes_fmt = stats.get("likes_fmt", "N/A")
-        comments = stats.get("comments", 0)
-        comments_fmt = stats.get("comments_fmt", "N/A")
-        subs_raw = channel_subs_raw.get(channel_id, 0)
-        subs_fmt = channel_subs.get(channel_id, "N/A")
+        rating = ai_ratings.get(i, 0)
+        rating_display = get_rating_display(rating)
         
-        if i == 1:
-            rank_style = "color: #FFD700; font-size: 18px;"
-        elif i == 2:
-            rank_style = "color: #C0C0C0; font-size: 16px;"
-        elif i == 3:
-            rank_style = "color: #CD7F32; font-size: 16px;"
-        else:
-            rank_style = ""
+        rank_style = ""
+        if i == 0: rank_style = "color:#FFD700; font-size:1.3rem;"
+        elif i == 1: rank_style = "color:#C0C0C0; font-size:1.2rem;"
+        elif i == 2: rank_style = "color:#CD7F32; font-size:1.2rem;"
         
         html += f'''
-            <tr>
-                <td class="yt-rank" style="{rank_style}" data-value="{i}">{i}</td>
-                <td><a href="{url}" target="_blank"><img src="{thumbnail}" width="100"></a></td>
-                <td data-value="{title}"><a href="{url}" target="_blank">{title_display}</a></td>
-                <td data-value="{channel}"><a href="{channel_url}" target="_blank">{channel_display}</a></td>
-                <td class="yt-subs" data-value="{subs_raw}">{subs_fmt}</td>
-                <td class="yt-views" data-value="{views}">{views_fmt}</td>
-                <td data-value="{likes}">{likes_fmt}</td>
-                <td data-value="{comments}">{comments_fmt}</td>
-                <td class="yt-date" data-value="{published}">{published}</td>
-            </tr>
+        <tr>
+            <td class="yt-rank" style="{rank_style}" data-v="{i+1}">{i+1}</td>
+            <td><a href="{url}" target="_blank"><img src="{v['thumbnail']}" width="90"></a></td>
+            <td data-v="{v['title']}"><a href="{url}" target="_blank">{title}</a></td>
+            <td data-v="{v['channel_name']}"><a href="{ch_url}" target="_blank">{channel}</a></td>
+            <td data-v="{subs}">{format_count(subs)}</td>
+            <td class="yt-views" data-v="{views}">{format_count(views)}</td>
+            <td data-v="{likes}">{format_count(likes)}</td>
+            <td data-v="{comments}">{format_count(comments)}</td>
+            <td class="ai-pick" data-v="{rating}">{rating_display}</td>
+            <td data-v="{published}">{published}</td>
+        </tr>
         '''
     
     html += '''
@@ -600,167 +581,308 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
     </div>
     
     <script>
-    (function() {
-        const table = document.getElementById('resultTable');
-        if (!table) return;
+    (function(){
+        var table = document.getElementById('ytTable');
+        if(!table) return;
+        var headers = table.querySelectorAll('th[data-col]');
+        var sortCol = -1, sortAsc = true;
         
-        const headers = table.querySelectorAll('th');
-        let currentSort = { col: -1, asc: true };
-        
-        headers.forEach((header, index) => {
-            if (header.dataset.type === 'none') return;
-            
-            header.addEventListener('click', () => {
-                const tbody = table.querySelector('tbody');
-                const rows = Array.from(tbody.querySelectorAll('tr'));
-                const type = header.dataset.type;
+        headers.forEach(function(th){
+            th.onclick = function(){
+                var col = parseInt(this.dataset.col);
+                var type = this.dataset.type;
+                var tbody = table.querySelector('tbody');
+                var rows = Array.from(tbody.querySelectorAll('tr'));
                 
-                // 정렬 방향 토글
-                if (currentSort.col === index) {
-                    currentSort.asc = !currentSort.asc;
-                } else {
-                    currentSort.col = index;
-                    currentSort.asc = true;
-                }
+                if(sortCol === col){ sortAsc = !sortAsc; }
+                else { sortCol = col; sortAsc = true; }
                 
-                // 헤더 스타일 업데이트
-                headers.forEach(h => h.classList.remove('sort-asc', 'sort-desc'));
-                header.classList.add(currentSort.asc ? 'sort-asc' : 'sort-desc');
+                headers.forEach(function(h){ h.classList.remove('sort-asc','sort-desc'); });
+                this.classList.add(sortAsc ? 'sort-asc' : 'sort-desc');
                 
-                // 정렬
-                rows.sort((a, b) => {
-                    const aVal = a.cells[index].dataset.value || a.cells[index].textContent;
-                    const bVal = b.cells[index].dataset.value || b.cells[index].textContent;
-                    
-                    let result = 0;
-                    if (type === 'number') {
-                        result = parseFloat(aVal) - parseFloat(bVal);
-                    } else if (type === 'date') {
-                        result = new Date(aVal) - new Date(bVal);
+                rows.sort(function(a,b){
+                    var aVal = a.cells[col].dataset.v || a.cells[col].textContent;
+                    var bVal = b.cells[col].dataset.v || b.cells[col].textContent;
+                    var result = 0;
+                    if(type === 'num'){
+                        result = parseFloat(aVal||0) - parseFloat(bVal||0);
                     } else {
-                        result = aVal.localeCompare(bVal, 'ko');
+                        result = (aVal||'').localeCompare(bVal||'','ko');
                     }
-                    
-                    return currentSort.asc ? result : -result;
+                    return sortAsc ? result : -result;
                 });
                 
-                // 재배치
-                rows.forEach(row => tbody.appendChild(row));
-            });
+                rows.forEach(function(row){ tbody.appendChild(row); });
+            };
         });
     })();
     </script>
     '''
     
-    db_stats = get_db_stats()
-    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회"
+    stats = get_db_stats()
+    stats_html = f"📊 DB: 영상 {stats['videos']} | 기록 {stats['stats']} | 채널 {stats['channels']} | 검색 {stats['searches']}"
     
     return html, stats_html
 
 def show_trending_alerts():
-    alerts = get_trending_alerts()
+    """급상승 알림 + 실시간 데이터 갱신"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    # 최근 급상승 알림
+    c.execute('''
+        SELECT ta.video_id, v.title, v.channel_name, ta.old_value, ta.new_value, ta.change_percent, ta.detected_at
+        FROM trending_alerts ta
+        JOIN videos v ON ta.video_id = v.video_id
+        ORDER BY ta.detected_at DESC LIMIT 30
+    ''')
+    alerts = c.fetchall()
+    conn.close()
+    
     if not alerts:
-        return "<p>급상승 알림이 없습니다. 데이터를 더 수집해주세요.</p>"
+        # 알림 없으면 현재 인기 급상승 영상 직접 조회
+        try:
+            resp = youtube.videos().list(part="snippet,statistics", chart="mostPopular", regionCode="KR", maxResults=20).execute()
+            
+            html = '''
+            <div style="background:#FACC15; padding:15px; border:3px solid #1F2937; border-radius:8px; margin-bottom:15px;">
+                <h3 style="font-family:'Bangers',cursive; margin:0;">🔥 현재 급상승 인기 영상 (한국)</h3>
+                <p style="margin:5px 0 0 0; font-size:0.9rem;">데이터 축적 후 변화율 기반 알림이 표시됩니다</p>
+            </div>
+            <div style="display:flex; flex-wrap:wrap; gap:15px;">
+            '''
+            
+            for i, item in enumerate(resp.get("items", [])[:20], 1):
+                snip = item["snippet"]
+                stats = item["statistics"]
+                vid = item["id"]
+                title = snip["title"][:30] + "..." if len(snip["title"]) > 30 else snip["title"]
+                views = format_count(int(stats.get("viewCount", 0)))
+                url = f"https://youtube.com/watch?v={vid}"
+                thumb = snip["thumbnails"]["medium"]["url"]
+                
+                html += f'''
+                <div style="width:180px; background:#FFF; border:3px solid #1F2937; border-radius:8px; padding:10px; box-shadow:4px 4px 0 #1F2937;">
+                    <a href="{url}" target="_blank"><img src="{thumb}" style="width:100%; border-radius:5px; border:2px solid #1F2937;"></a>
+                    <p style="margin:8px 0 5px 0; font-size:12px; font-weight:700; color:#1F2937;">{i}. {title}</p>
+                    <p style="margin:0; font-size:14px; color:#EF4444; font-weight:700;">👀 {views}</p>
+                </div>
+                '''
+            
+            html += '</div>'
+            return html
+        except Exception as e:
+            return f"<p>데이터 로드 오류: {e}</p>"
     
     html = '''
-    <h3>🔥 급상승 알림 (조회수 20% 이상 증가)</h3>
-    <table style="width:100%; border-collapse: collapse;">
-        <thead><tr style="background: #ff6b6b; color: white;">
-            <th style="padding:10px;">영상</th><th>채널</th><th>이전</th><th>현재</th><th>증가율</th><th>감지시간</th>
+    <div style="background:#EF4444; color:white; padding:15px; border:3px solid #1F2937; border-radius:8px; margin-bottom:15px;">
+        <h3 style="font-family:'Bangers',cursive; margin:0;">🔥 급상승 알림 (조회수 20%+ 증가)</h3>
+    </div>
+    <table style="width:100%; border-collapse:collapse; font-family:'Comic Neue',cursive;">
+        <thead><tr style="background:#1F2937; color:#FACC15;">
+            <th style="padding:10px; border:2px solid #1F2937;">영상</th>
+            <th style="padding:10px;">채널</th>
+            <th style="padding:10px;">이전</th>
+            <th style="padding:10px;">현재</th>
+            <th style="padding:10px;">증가율</th>
+            <th style="padding:10px;">감지시간</th>
         </tr></thead><tbody>
     '''
-    for alert in alerts:
-        video_id, title, channel, _, old_val, new_val, change_pct, detected = alert
-        title = title[:30] + "..." if len(title) > 30 else title
-        url = f"https://youtube.com/watch?v={video_id}"
-        html += f'''<tr style="border-bottom:1px solid #ddd;">
-            <td style="padding:8px;"><a href="{url}" target="_blank">{title}</a></td>
-            <td>{channel}</td><td>{format_count(old_val)}</td><td>{format_count(new_val)}</td>
-            <td style="color:red;font-weight:bold;">+{change_pct:.1f}%</td>
-            <td>{detected[:16].replace("T"," ")}</td>
-        </tr>'''
+    
+    for vid, title, channel, old_v, new_v, pct, detected in alerts:
+        title = title[:25] + "..." if len(title) > 25 else title
+        url = f"https://youtube.com/watch?v={vid}"
+        html += f'''
+        <tr style="background:#FFF; border-bottom:2px solid #1F2937;">
+            <td style="padding:10px;"><a href="{url}" target="_blank" style="color:#3B82F6; font-weight:700;">{title}</a></td>
+            <td style="padding:10px;">{channel}</td>
+            <td style="padding:10px;">{format_count(old_v)}</td>
+            <td style="padding:10px;">{format_count(new_v)}</td>
+            <td style="padding:10px; color:#EF4444; font-weight:700;">+{pct:.1f}%</td>
+            <td style="padding:10px; font-size:12px;">{detected[:16].replace("T"," ")}</td>
+        </tr>
+        '''
+    
     html += '</tbody></table>'
     return html
 
 def show_top_growing():
-    results = get_top_growing_videos(24)
+    """급성장 TOP - DB + 실시간 조회"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    cutoff = (datetime.now() - timedelta(hours=48)).isoformat()
+    
+    c.execute('''
+        SELECT v.video_id, v.title, v.channel_name, v.thumbnail,
+               MIN(vs.views) as min_v, MAX(vs.views) as max_v,
+               ((MAX(vs.views) - MIN(vs.views)) * 100.0 / MIN(vs.views)) as growth
+        FROM videos v
+        JOIN video_stats vs ON v.video_id = vs.video_id
+        WHERE vs.recorded_at > ?
+        GROUP BY v.video_id
+        HAVING min_v > 0 AND max_v > min_v
+        ORDER BY growth DESC LIMIT 20
+    ''', (cutoff,))
+    results = c.fetchall()
+    conn.close()
+    
     if not results:
-        return "<p>최근 24시간 내 급성장 데이터가 없습니다.</p>"
+        # DB 없으면 실시간 인기 영상 표시
+        try:
+            resp = youtube.videos().list(part="snippet,statistics", chart="mostPopular", regionCode="KR", maxResults=20).execute()
+            
+            html = '''
+            <div style="background:#3B82F6; color:white; padding:15px; border:3px solid #1F2937; border-radius:8px; margin-bottom:15px;">
+                <h3 style="font-family:'Bangers',cursive; margin:0;">📈 현재 인기 급상승 TOP 20</h3>
+                <p style="margin:5px 0 0 0; font-size:0.9rem;">검색을 여러 번 수행하면 성장률 데이터가 축적됩니다</p>
+            </div>
+            <div style="display:flex; flex-wrap:wrap; gap:15px;">
+            '''
+            
+            items = resp.get("items", [])
+            for i, item in enumerate(items[:20], 1):
+                snip = item["snippet"]
+                stats = item["statistics"]
+                views = int(stats.get("viewCount", 0))
+                likes = int(stats.get("likeCount", 0))
+                
+                # 간단한 engagement 계산
+                engagement = (likes / views * 100) if views > 0 else 0
+                
+                title = snip["title"][:25] + "..." if len(snip["title"]) > 25 else snip["title"]
+                url = f"https://youtube.com/watch?v={item['id']}"
+                thumb = snip["thumbnails"]["medium"]["url"]
+                
+                html += f'''
+                <div style="width:180px; background:#FFF; border:3px solid #1F2937; border-radius:8px; padding:10px; box-shadow:4px 4px 0 #1F2937;">
+                    <a href="{url}" target="_blank"><img src="{thumb}" style="width:100%; border-radius:5px; border:2px solid #1F2937;"></a>
+                    <p style="margin:8px 0 5px 0; font-size:12px; font-weight:700;">{i}. {title}</p>
+                    <p style="margin:0; font-size:11px; color:#666;">{snip["channelTitle"][:15]}</p>
+                    <p style="margin:5px 0 0 0; font-size:14px; color:#3B82F6; font-weight:700;">👀 {format_count(views)}</p>
+                    <p style="margin:2px 0 0 0; font-size:12px; color:#EF4444;">❤️ {engagement:.2f}%</p>
+                </div>
+                '''
+            
+            html += '</div>'
+            return html
+        except Exception as e:
+            return f"<p>데이터 로드 오류: {e}</p>"
+    
+    html = '''
+    <div style="background:#3B82F6; color:white; padding:15px; border:3px solid #1F2937; border-radius:8px; margin-bottom:15px;">
+        <h3 style="font-family:'Bangers',cursive; margin:0;">📈 48시간 급성장 TOP 20</h3>
+    </div>
+    <div style="display:flex; flex-wrap:wrap; gap:15px;">
+    '''
     
-    html = '<h3>📈 24시간 급성장 TOP 10</h3><div style="display:flex;flex-wrap:wrap;gap:15px;">'
-    for i, (video_id, title, channel, thumbnail, min_v, max_v, growth) in enumerate(results, 1):
+    for i, (vid, title, channel, thumb, min_v, max_v, growth) in enumerate(results, 1):
         title = title[:25] + "..." if len(title) > 25 else title
-        url = f"https://youtube.com/watch?v={video_id}"
-        html += f'''<div style="width:180px;border:1px solid #ddd;border-radius:8px;padding:10px;">
-            <a href="{url}" target="_blank"><img src="{thumbnail}" style="width:100%;border-radius:5px;"></a>
-            <p style="margin:5px 0;font-size:12px;"><b>{i}.</b> {title}</p>
-            <p style="margin:0;font-size:11px;color:#666;">{channel}</p>
-            <p style="margin:5px 0;font-size:14px;color:#ff0000;font-weight:bold;">📈 +{growth:.1f}%</p>
-        </div>'''
+        url = f"https://youtube.com/watch?v={vid}"
+        
+        html += f'''
+        <div style="width:180px; background:#FFF; border:3px solid #1F2937; border-radius:8px; padding:10px; box-shadow:4px 4px 0 #1F2937;">
+            <a href="{url}" target="_blank"><img src="{thumb}" style="width:100%; border-radius:5px; border:2px solid #1F2937;"></a>
+            <p style="margin:8px 0 5px 0; font-size:12px; font-weight:700;">{i}. {title}</p>
+            <p style="margin:0; font-size:11px; color:#666;">{channel[:15]}</p>
+            <p style="margin:5px 0 0 0; font-size:16px; color:#EF4444; font-weight:700; font-family:'Bangers',cursive;">📈 +{growth:.1f}%</p>
+            <p style="margin:2px 0 0 0; font-size:11px; color:#888;">{format_count(int(min_v))} → {format_count(int(max_v))}</p>
+        </div>
+        '''
+    
     html += '</div>'
     return html
 
 def show_search_history():
-    history = get_search_history()
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    c.execute('SELECT keyword,country,language,sort_by,results_count,searched_at FROM search_history ORDER BY searched_at DESC LIMIT 50')
+    history = c.fetchall()
+    conn.close()
+    
     if not history:
-        return "<p>검색 기록이 없습니다.</p>"
-    
-    html = '''<h3>🕐 최근 검색 기록</h3>
-    <table style="width:100%;border-collapse:collapse;">
-        <thead><tr style="background:#333;color:white;">
-            <th style="padding:10px;">검색어</th><th>국가</th><th>언어</th><th>정렬</th><th>결과수</th><th>시간</th>
-        </tr></thead><tbody>'''
-    for kw, country, lang, sort_by, count, searched_at in history:
-        html += f'''<tr style="border-bottom:1px solid #ddd;">
-            <td style="padding:8px;"><b>{kw}</b></td><td>{country}</td><td>{lang}</td>
-            <td>{sort_by}</td><td>{count}</td><td>{searched_at[:16].replace("T"," ")}</td>
-        </tr>'''
+        return "<p style='font-family:Comic Neue,cursive;'>검색 기록이 없습니다.</p>"
+    
+    html = '''
+    <div style="background:#1F2937; color:#FACC15; padding:15px; border:3px solid #1F2937; border-radius:8px; margin-bottom:15px;">
+        <h3 style="font-family:'Bangers',cursive; margin:0;">🕐 최근 검색 기록</h3>
+    </div>
+    <table style="width:100%; border-collapse:collapse; font-family:'Comic Neue',cursive;">
+        <thead><tr style="background:#FACC15; color:#1F2937;">
+            <th style="padding:10px; border:2px solid #1F2937;">검색어</th>
+            <th style="padding:10px;">국가</th><th style="padding:10px;">언어</th>
+            <th style="padding:10px;">정렬</th><th style="padding:10px;">결과</th><th style="padding:10px;">시간</th>
+        </tr></thead><tbody>
+    '''
+    
+    for kw, country, lang, sort_by, cnt, searched in history:
+        html += f'''
+        <tr style="background:#FFF; border-bottom:2px solid #1F2937;">
+            <td style="padding:10px; font-weight:700;">{kw}</td>
+            <td style="padding:10px;">{country}</td><td style="padding:10px;">{lang}</td>
+            <td style="padding:10px;">{sort_by}</td><td style="padding:10px;">{cnt}</td>
+            <td style="padding:10px; font-size:12px;">{searched[:16].replace("T"," ")}</td>
+        </tr>
+        '''
+    
     html += '</tbody></table>'
     return html
 
 # 초기 트렌딩
 initial_trending = get_real_trending_keywords("KR", "ko")
 
-with gr.Blocks() as demo:
-    gr.Markdown("## YouTube 인기 영상 검색기 + 트렌드 분석")
+with gr.Blocks(css=css) as demo:
+    gr.HTML('''
+        <div style="text-align:center; margin:20px 0;">
+            <a href="https://www.humangen.ai" target="_blank">
+                <img src="https://img.shields.io/static/v1?label=🏠 HOME&message=HUMANGEN.AI&color=0000ff&labelColor=ffcc00&style=for-the-badge">
+            </a>
+        </div>
+    ''')
     
-    db_stats_display = gr.Markdown("📊 DB 통계 로딩중...")
+    gr.Markdown("# 🎬 YOUTUBE TREND ANALYZER 📊", elem_classes="header-text")
+    
+    db_stats = gr.Markdown("📊 DB 로딩중...")
     
     with gr.Tabs():
         with gr.Tab("🔍 검색"):
-            gr.Markdown("### 🔥 실시간 인기 검색어 (YouTube 트렌딩 기반)")
-            trending_radio = gr.Radio(choices=initial_trending, label="클릭하면 검색창에 자동 입력", interactive=True)
+            gr.Markdown("### 🔥 실시간 인기 검색어")
+            trending = gr.Radio(choices=initial_trending, label="클릭시 자동 입력", interactive=True)
             
             with gr.Row():
                 keyword = gr.Textbox(label="검색어", placeholder="검색어 입력...", scale=3)
                 btn = gr.Button("🔍 검색", variant="primary", scale=1)
-                refresh_btn = gr.Button("🔄 갱신", scale=1)
+                refresh = gr.Button("🔄 갱신", variant="secondary", scale=1)
             
             with gr.Row():
-                country = gr.Dropdown(list(COUNTRIES.keys()), value="한국", label="국가 (인구순)")
+                country = gr.Dropdown(list(COUNTRIES.keys()), value="한국", label="국가")
                 language = gr.Dropdown(list(LANGUAGES.keys()), value="자동 (국가 기반)", label="언어")
                 sort_by = gr.Dropdown(list(SORT_OPTIONS.keys()), value="조회수 순", label="정렬")
                 date_filter = gr.Dropdown(list(DATE_OPTIONS.keys()), value="전체 기간", label="기간")
-                max_results = gr.Slider(10, 300, value=50, step=10, label="결과 수")
+                max_results = gr.Slider(10, 1000, value=100, step=10, label="결과 수")
             
-            search_output = gr.HTML()
+            output = gr.HTML()
         
         with gr.Tab("🔥 급상승"):
-            gr.Button("🔄 새로고침", variant="secondary").click(show_trending_alerts, outputs=gr.HTML())
-            alerts_output = gr.HTML()
+            alerts_btn = gr.Button("🔄 새로고침", variant="primary")
+            alerts_out = gr.HTML()
         
         with gr.Tab("📈 급성장 TOP"):
-            gr.Button("🔄 새로고침", variant="secondary").click(show_top_growing, outputs=gr.HTML())
-            growing_output = gr.HTML()
+            growing_btn = gr.Button("🔄 새로고침", variant="primary")
+            growing_out = gr.HTML()
         
         with gr.Tab("🕐 검색 기록"):
-            gr.Button("🔄 새로고침", variant="secondary").click(show_search_history, outputs=gr.HTML())
-            history_output = gr.HTML()
-    
-    trending_radio.change(use_trending_keyword, trending_radio, keyword)
-    country.change(update_trending, country, trending_radio)
-    btn.click(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [search_output, db_stats_display])
-    keyword.submit(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [search_output, db_stats_display])
-    refresh_btn.click(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [search_output, db_stats_display])
+            history_btn = gr.Button("🔄 새로고침", variant="primary")
+            history_out = gr.HTML()
+    
+    # 이벤트
+    trending.change(use_trending_keyword, trending, keyword)
+    country.change(update_trending, country, trending)
+    btn.click(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [output, db_stats])
+    keyword.submit(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [output, db_stats])
+    refresh.click(search_videos, [keyword, country, language, sort_by, date_filter, max_results], [output, db_stats])
+    
+    alerts_btn.click(show_trending_alerts, outputs=alerts_out)
+    growing_btn.click(show_top_growing, outputs=growing_out)
+    history_btn.click(show_search_history, outputs=history_out)
 
-demo.launch()
+demo.launch()