Update app.py

app.py

@@ -3,7 +3,7 @@ from googleapiclient.discovery import build
 import os
 import sqlite3
 from datetime import datetime, timedelta
-import json
+import re
 
 API_KEY = os.getenv("YOUTUBE_API_KEY")
 youtube = build("youtube", "v3", developerKey=API_KEY)
@@ -13,7 +13,6 @@ 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,
@@ -26,7 +25,6 @@ def init_db():
         )
     ''')
     
-    # 영상 통계 히스토리 (시간별 추적)
     c.execute('''
         CREATE TABLE IF NOT EXISTS video_stats (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -39,7 +37,6 @@ def init_db():
         )
     ''')
     
-    # 채널 데이터 테이블
     c.execute('''
         CREATE TABLE IF NOT EXISTS channels (
             channel_id TEXT PRIMARY KEY,
@@ -48,7 +45,6 @@ def init_db():
         )
     ''')
     
-    # 채널 통계 히스토리
     c.execute('''
         CREATE TABLE IF NOT EXISTS channel_stats (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -59,7 +55,6 @@ def init_db():
         )
     ''')
     
-    # 검색 기록 테이블
     c.execute('''
         CREATE TABLE IF NOT EXISTS search_history (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -72,7 +67,6 @@ def init_db():
         )
     ''')
     
-    # 급상승 알림 테이블
     c.execute('''
         CREATE TABLE IF NOT EXISTS trending_alerts (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -91,54 +85,53 @@ def init_db():
 
 init_db()
 
-# 국가 코드 - 인구 순 상위 40개
+# 국가 코드 + 기본 언어 매핑
 COUNTRIES = {
-    "전세계": "",
-    "중국": "CN",
-    "인도": "IN",
-    "미국": "US",
-    "인도네시아": "ID",
-    "파키스탄": "PK",
-    "브라질": "BR",
-    "나이지리아": "NG",
-    "방글라데시": "BD",
-    "러시아": "RU",
-    "멕시코": "MX",
-    "일본": "JP",
-    "에티오피아": "ET",
-    "필리핀": "PH",
-    "이집트": "EG",
-    "베트남": "VN",
-    "콩고민주공화국": "CD",
-    "터키": "TR",
-    "이란": "IR",
-    "독일": "DE",
-    "태국": "TH",
-    "영국": "GB",
-    "프랑스": "FR",
-    "이탈리아": "IT",
-    "남아공": "ZA",
-    "탄자니아": "TZ",
-    "미얀마": "MM",
-    "한국": "KR",
-    "콜롬비아": "CO",
-    "케냐": "KE",
-    "스페인": "ES",
-    "아르헨티나": "AR",
-    "알제리": "DZ",
-    "우크라이나": "UA",
-    "이라크": "IQ",
-    "캐나다": "CA",
-    "폴란드": "PL",
-    "모로코": "MA",
-    "사우디": "SA",
-    "페루": "PE",
-    "말레이시아": "MY",
+    "전세계": ("", ""),
+    "중국": ("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"),
 }
 
-# 언어 코드 - 사용 인구 순 상위 40개
 LANGUAGES = {
-    "전체": "",
+    "자동 (국가 기반)": "",
     "영어": "en",
     "중국어": "zh",
     "힌디어": "hi",
@@ -205,27 +198,97 @@ def format_count(count):
         return f"{count/1000:.1f}K"
     return str(count)
 
+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
+        ).execute()
+        
+        keywords = []
+        seen = set()
+        
+        for item in response.get("items", []):
+            title = item["snippet"]["title"]
+            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:
+                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)
+            
+            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']:
+                    keywords.append(word)
+                    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"],
+        }
+        
+        extra = popular_categories.get(region_code, popular_categories["US"])
+        for kw in extra:
+            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"])
+
 def save_to_db(videos_data, channels_data, keyword, country, language, sort_by):
-    """검색 결과를 DB에 저장"""
     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))
     
     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('''
             SELECT views FROM video_stats 
             WHERE video_id = ? 
@@ -233,13 +296,11 @@ def save_to_db(videos_data, channels_data, keyword, country, language, sort_by):
         ''', (video['video_id'],))
         prev_stats = 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))
         
-        # 급상승 감지 (조회수 20% 이상 증가)
         if prev_stats and prev_stats[0] > 0:
             change_percent = ((video['views'] - prev_stats[0]) / prev_stats[0]) * 100
             if change_percent >= 20:
@@ -249,79 +310,44 @@ def save_to_db(videos_data, channels_data, keyword, country, language, sort_by):
                 ''', (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))
-        
-        # 채널 통계 저장
+        c.execute('INSERT OR IGNORE INTO channels (channel_id, channel_name, first_seen) VALUES (?, ?, ?)', 
+                  (channel_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 (?, ?, ?)', 
+                      (channel_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
+        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
+        FROM search_history ORDER BY searched_at DESC LIMIT 50
     ''')
-    
-    history = c.fetchall()
-    conn.close()
-    return history
-
-def get_video_history(video_id):
-    """특정 영상의 통계 히스토리"""
-    conn = sqlite3.connect("youtube_data.db")
-    c = conn.cursor()
-    
-    c.execute('''
-        SELECT views, likes, comments, recorded_at
-        FROM video_stats
-        WHERE video_id = ?
-        ORDER BY recorded_at ASC
-    ''', (video_id,))
-    
     history = c.fetchall()
     conn.close()
     return history
 
 def get_top_growing_videos(hours=24):
-    """급성장 영상 TOP 10"""
     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,
@@ -331,84 +357,39 @@ def get_top_growing_videos(hours=24):
         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
+        ORDER BY growth_rate DESC LIMIT 10
     ''', (cutoff,))
-    
     results = c.fetchall()
     conn.close()
     return results
 
 def get_db_stats():
-    """DB 통계"""
     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]
-    
     conn.close()
-    
-    return {
-        "videos": video_count,
-        "stats_records": stats_count,
-        "channels": channel_count,
-        "searches": search_count,
-        "alerts": alert_count
-    }
-
-def get_trending_keywords(region_code="KR"):
-    try:
-        response = youtube.videos().list(
-            part="snippet",
-            chart="mostPopular",
-            regionCode=region_code if region_code else "US",
-            maxResults=20
-        ).execute()
-        
-        keywords = []
-        seen = set()
-        for item in response.get("items", []):
-            channel = item["snippet"]["channelTitle"]
-            keyword = channel.split()[0] if len(channel.split()) > 0 else item["snippet"]["title"].split()[0]
-            if keyword not in seen and len(keyword) > 1:
-                keywords.append(keyword)
-                seen.add(keyword)
-            if len(keywords) >= 15:
-                break
-        
-        return keywords if keywords else get_default_trending()
-    except:
-        return get_default_trending()
-
-def get_default_trending():
-    return [
-        "AI", "ChatGPT", "뉴진스", "BTS", "Netflix", 
-        "게임", "먹방", "브이로그", "shorts", "음악",
-        "축구", "NBA", "애니메이션", "영화 리뷰", "코딩"
-    ]
+    return {"videos": video_count, "stats_records": stats_count, "channels": channel_count, 
+            "searches": search_count, "alerts": alert_count}
 
 def update_trending(country):
-    region = COUNTRIES.get(country, "")
-    keywords = get_trending_keywords(region if region else "US")
+    """국가 변경시 트렌딩 키워드 + 언어 자동 업데이트"""
+    region, default_lang = COUNTRIES.get(country, ("", ""))
+    keywords = get_real_trending_keywords(region if region else "US", default_lang)
     return gr.update(choices=keywords, value=None)
 
 def use_trending_keyword(trending_keyword):
     return trending_keyword if trending_keyword else ""
 
-def search_videos(keyword, country, language, sort_by, date_filter, max_results, save_db=True):
+def search_videos(keyword, country, language, sort_by, date_filter, max_results, save_db_flag=True):
     if not keyword or not keyword.strip():
         return "검색어를 입력하세요.", ""
     
@@ -416,6 +397,15 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
     all_items = []
     next_page_token = None
     
+    # 국가 코드 + 기본 언어 가져오기
+    region_code, default_lang = COUNTRIES.get(country, ("", ""))
+    
+    # 언어 설정: "자동"이면 국가 기본 언어 사용
+    if language == "자동 (국가 기반)":
+        lang_code = default_lang
+    else:
+        lang_code = LANGUAGES.get(language, "")
+    
     search_params = {
         "q": keyword,
         "part": "snippet",
@@ -423,10 +413,11 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
         "order": SORT_OPTIONS[sort_by],
     }
     
-    if COUNTRIES[country]:
-        search_params["regionCode"] = COUNTRIES[country]
-    if LANGUAGES[language]:
-        search_params["relevanceLanguage"] = LANGUAGES[language]
+    # 국가 + 언어 둘 다 적용
+    if region_code:
+        search_params["regionCode"] = region_code
+    if lang_code:
+        search_params["relevanceLanguage"] = lang_code
     
     if date_filter != "전체 기간":
         now = datetime.utcnow()
@@ -450,7 +441,7 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
         
         if not items:
             break
-            
+        
         all_items.extend(items)
         next_page_token = response.get("nextPageToken")
         
@@ -466,11 +457,7 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
     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()
-        
+        video_details = youtube.videos().list(id=",".join(batch_ids), part="statistics").execute()
         for v in video_details.get("items", []):
             stats = v["statistics"]
             video_stats[v["id"]] = {
@@ -486,11 +473,7 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
     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()
-        
+        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:
@@ -499,13 +482,11 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
             else:
                 channel_subs[ch["id"]] = "비공개"
     
-    # DB 저장용 데이터 준비
     videos_data = []
     for item in all_items:
         video_id = item["id"]["videoId"]
         snippet = item["snippet"]
         stats = video_stats.get(video_id, {})
-        
         videos_data.append({
             "video_id": video_id,
             "title": snippet["title"],
@@ -518,15 +499,22 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
             "comments": stats.get("comments", 0),
         })
     
-    # DB에 저장
-    if save_db:
+    if save_db_flag:
         save_to_db(videos_data, channel_subs_raw, keyword, country, language, sort_by)
     
-    # HTML 테이블 생성
+    # JavaScript 정렬 기능 포함 HTML
     html = f'''
     <style>
         .yt-table {{ width: 100%; border-collapse: collapse; font-size: 14px; }}
-        .yt-table th {{ background: #ff0000; color: white; padding: 12px 8px; text-align: left; position: sticky; top: 0; }}
+        .yt-table th {{ 
+            background: #ff0000; color: white; padding: 12px 8px; 
+            text-align: left; position: sticky; top: 0; cursor: pointer;
+            user-select: none;
+        }}
+        .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; }}
@@ -536,22 +524,24 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
         .yt-views {{ font-weight: bold; color: #065fd4; }}
         .yt-subs {{ color: #606060; }}
         .yt-date {{ color: #888; font-size: 12px; }}
-        .surge {{ background: #fff3cd !important; }}
     </style>
-    <p><b>총 {len(all_items)}개 결과</b> | 검색어: "{keyword}" | 정렬: {sort_by} | 💾 DB 저장 완료</p>
+    
+    <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">
+    <table class="yt-table" id="resultTable">
         <thead>
             <tr>
-                <th style="width:50px;">순위</th>
-                <th style="width:120px;">썸네일</th>
-                <th>제목</th>
-                <th style="width:150px;">채널</th>
-                <th style="width:80px;">구독자</th>
-                <th style="width:80px;">조회수</th>
-                <th style="width:60px;">좋아요</th>
-                <th style="width:60px;">댓글</th>
-                <th style="width:90px;">게시일</th>
+                <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>
         <tbody>
@@ -563,21 +553,23 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
         channel_id = snippet["channelId"]
         
         title = snippet["title"]
-        if len(title) > 50:
-            title = title[:50] + "..."
+        title_display = title[:50] + "..." if len(title) > 50 else title
         channel = snippet["channelTitle"]
-        if len(channel) > 15:
-            channel = channel[:15] + "..."
+        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}"
         
         stats = video_stats.get(video_id, {})
-        views = stats.get("views_fmt", "N/A")
-        likes = stats.get("likes_fmt", "N/A")
-        comments = stats.get("comments_fmt", "N/A")
-        subs = channel_subs.get(channel_id, "N/A")
+        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")
         
         if i == 1:
             rank_style = "color: #FFD700; font-size: 18px;"
@@ -590,173 +582,154 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results,
         
         html += f'''
             <tr>
-                <td class="yt-rank" style="{rank_style}">{i}</td>
+                <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><a href="{url}" target="_blank">{title}</a></td>
-                <td><a href="{channel_url}" target="_blank">{channel}</a></td>
-                <td class="yt-subs">{subs}</td>
-                <td class="yt-views">{views}</td>
-                <td>{likes}</td>
-                <td>{comments}</td>
-                <td class="yt-date">{published}</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>
         '''
     
-    html += '</tbody></table></div>'
+    html += '''
+        </tbody>
+    </table>
+    </div>
+    
+    <script>
+    (function() {
+        const table = document.getElementById('resultTable');
+        if (!table) return;
+        
+        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;
+                
+                // 정렬 방향 토글
+                if (currentSort.col === index) {
+                    currentSort.asc = !currentSort.asc;
+                } else {
+                    currentSort.col = index;
+                    currentSort.asc = true;
+                }
+                
+                // 헤더 스타일 업데이트
+                headers.forEach(h => h.classList.remove('sort-asc', 'sort-desc'));
+                header.classList.add(currentSort.asc ? '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);
+                    } else {
+                        result = aVal.localeCompare(bVal, 'ko');
+                    }
+                    
+                    return currentSort.asc ? result : -result;
+                });
+                
+                // 재배치
+                rows.forEach(row => tbody.appendChild(row));
+            });
+        });
+    })();
+    </script>
+    '''
     
-    # DB 통계 업데이트
     db_stats = get_db_stats()
-    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회 | 알림 {db_stats['alerts']}건"
+    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회"
     
     return html, stats_html
 
 def show_trending_alerts():
-    """급상승 알림 표시"""
     alerts = get_trending_alerts()
-    
     if not alerts:
-        return "<p>아직 급상승 알림이 없습니다. 데이터를 더 수집해주세요.</p>"
+        return "<p>급상승 알림이 없습니다. 데이터를 더 수집해주세요.</p>"
     
     html = '''
-    <style>
-        .alert-table { width: 100%; border-collapse: collapse; }
-        .alert-table th { background: #ff6b6b; color: white; padding: 10px; }
-        .alert-table td { padding: 10px; border-bottom: 1px solid #ddd; }
-        .surge-badge { background: #ff0000; color: white; padding: 2px 8px; border-radius: 10px; font-size: 12px; }
-    </style>
     <h3>🔥 급상승 알림 (조회수 20% 이상 증가)</h3>
-    <table class="alert-table">
-        <thead>
-            <tr>
-                <th>영상</th>
-                <th>채널</th>
-                <th>이전</th>
-                <th>현재</th>
-                <th>증가율</th>
-                <th>감지 시간</th>
-            </tr>
-        </thead>
-        <tbody>
+    <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>
+        </tr></thead><tbody>
     '''
-    
     for alert in alerts:
-        video_id, title, channel, alert_type, old_val, new_val, change_pct, detected = alert
+        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}"
-        detected_fmt = detected[:16].replace("T", " ")
-        
-        html += f'''
-            <tr>
-                <td><a href="{url}" target="_blank">{title}</a></td>
-                <td>{channel}</td>
-                <td>{format_count(old_val)}</td>
-                <td>{format_count(new_val)}</td>
-                <td><span class="surge-badge">+{change_pct:.1f}%</span></td>
-                <td>{detected_fmt}</td>
-            </tr>
-        '''
-    
+        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>'''
     html += '</tbody></table>'
     return html
 
 def show_top_growing():
-    """급성장 영상 TOP 10"""
     results = get_top_growing_videos(24)
-    
     if not results:
-        return "<p>최근 24시간 내 급성장 영상 데이터가 없습니다.</p>"
-    
-    html = '''
-    <h3>📈 24시간 급성장 TOP 10</h3>
-    <div style="display: flex; flex-wrap: wrap; gap: 15px;">
-    '''
+        return "<p>최근 24시간 내 급성장 데이터가 없습니다.</p>"
     
-    for i, (video_id, title, channel, thumbnail, min_views, max_views, growth) in enumerate(results, 1):
+    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):
         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>
-            <p style="margin: 0; font-size: 10px; color: #888;">{format_count(min_views)} → {format_count(max_views)}</p>
-        </div>
-        '''
-    
+        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>'''
     html += '</div>'
     return html
 
 def show_search_history():
-    """검색 기록 표시"""
     history = get_search_history()
-    
     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 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 keyword, country, language, sort_by, count, searched_at in history:
-        searched_fmt = searched_at[:16].replace("T", " ")
-        html += f'''
-            <tr style="border-bottom: 1px solid #ddd;">
-                <td style="padding: 8px;"><b>{keyword}</b></td>
-                <td style="padding: 8px;">{country}</td>
-                <td style="padding: 8px;">{language}</td>
-                <td style="padding: 8px;">{sort_by}</td>
-                <td style="padding: 8px;">{count}</td>
-                <td style="padding: 8px;">{searched_fmt}</td>
-            </tr>
-        '''
-    
+    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>'''
     html += '</tbody></table>'
     return html
 
-def refresh_all():
-    """전체 데이터 갱신"""
-    db_stats = get_db_stats()
-    alerts = show_trending_alerts()
-    growing = show_top_growing()
-    history = show_search_history()
-    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회 | 알림 {db_stats['alerts']}건"
-    
-    return alerts, growing, history, stats_html
-
-# 초기 트렌딩 키워드
-initial_trending = get_default_trending()
+# 초기 트렌딩
+initial_trending = get_real_trending_keywords("KR", "ko")
 
 with gr.Blocks() as demo:
     gr.Markdown("## YouTube 인기 영상 검색기 + 트렌드 분석")
     
-    # DB 통계
     db_stats_display = gr.Markdown("📊 DB 통계 로딩중...")
     
     with gr.Tabs():
-        # 탭 1: 검색
         with gr.Tab("���� 검색"):
-            gr.Markdown("### 🔥 실시간 인기 검색어")
-            trending_radio = gr.Radio(
-                choices=initial_trending,
-                label="클릭하면 검색창에 자동 입력",
-                interactive=True
-            )
+            gr.Markdown("### 🔥 실시간 인기 검색어 (YouTube 트렌딩 기반)")
+            trending_radio = gr.Radio(choices=initial_trending, label="클릭하면 검색창에 자동 입력", interactive=True)
             
             with gr.Row():
                 keyword = gr.Textbox(label="검색어", placeholder="검색어 입력...", scale=3)
@@ -765,51 +738,29 @@ with gr.Blocks() as demo:
             
             with gr.Row():
                 country = gr.Dropdown(list(COUNTRIES.keys()), value="한국", label="국가 (인구순)")
-                language = gr.Dropdown(list(LANGUAGES.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="결과 수")
             
             search_output = gr.HTML()
         
-        # 탭 2: 급상승
         with gr.Tab("🔥 급상승"):
-            refresh_alerts_btn = gr.Button("🔄 새로고침", variant="secondary")
+            gr.Button("🔄 새로고침", variant="secondary").click(show_trending_alerts, outputs=gr.HTML())
             alerts_output = gr.HTML()
         
-        # 탭 3: 급성장
         with gr.Tab("📈 급성장 TOP"):
-            refresh_growing_btn = gr.Button("🔄 새로고침", variant="secondary")
+            gr.Button("🔄 새로고침", variant="secondary").click(show_top_growing, outputs=gr.HTML())
             growing_output = gr.HTML()
         
-        # 탭 4: 검색 기록
         with gr.Tab("🕐 검색 기록"):
-            refresh_history_btn = gr.Button("🔄 새로고침", variant="secondary")
+            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]
-    )
-    
-    refresh_alerts_btn.click(show_trending_alerts, outputs=alerts_output)
-    refresh_growing_btn.click(show_top_growing, outputs=growing_output)
-    refresh_history_btn.click(show_search_history, outputs=history_output)
+    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])
 
 demo.launch()