Update app.py

app.py

@@ -109,407 +109,449 @@
 #     """)
 
 
+# import streamlit as st
+# import yt_dlp
+# import os
+# from pathlib import Path
+# import time
+# from datetime import datetime
+# import json
+
+# # Set page config
+# st.set_page_config(page_title="YouTube Video Downloader", page_icon="📺", layout="wide")
+
+# # Set the title of the app
+# st.title("YouTube Video Downloader 📺")
+
+# # Create output directory if it doesn't exist
+# output_dir = Path("downloads")
+# output_dir.mkdir(exist_ok=True)
+
+# # Authentication settings
+# AUTH_CONFIG = {
+#     'COOKIES_FILE': 'youtube.com_cookies.txt',
+#     'TOKEN_FILE': 'auth_token.json'
+# }
+
+# def load_auth_token():
+#     try:
+#         if os.path.exists(AUTH_CONFIG['TOKEN_FILE']):
+#             with open(AUTH_CONFIG['TOKEN_FILE'], 'r') as f:
+#                 data = json.load(f)
+#                 if datetime.fromisoformat(data['expires']) > datetime.now():
+#                     return data['token']
+#     except Exception:
+#         pass
+#     return None
+
+# def save_auth_token(token):
+#     with open(AUTH_CONFIG['TOKEN_FILE'], 'w') as f:
+#         json.dump({
+#             'token': token,
+#             'expires': (datetime.now().isoformat())
+#         }, f)
+
+# def setup_ydl_options(has_cookies):
+#     opts = {
+#         'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+#         'outtmpl': str(output_dir / '%(title)s.%(ext)s'),
+#         'merge_output_format': 'mp4',
+#         'quiet': True,
+#         'no_warnings': True,
+#         'extract_flat': False,
+#         'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+#         'referer': 'https://www.youtube.com/',
+#         'http_chunk_size': 10485760,
+#         'retries': 3,
+#         'file_access_retries': 3,
+#         'fragment_retries': 3,
+#         'skip_unavailable_fragments': True,
+#         'abort_on_unavailable_fragment': False,
+#     }
+    
+#     # Add cookies file if available
+#     if has_cookies:
+#         opts['cookiefile'] = AUTH_CONFIG['COOKIES_FILE']
+    
+#     # Add authentication token if available
+#     token = load_auth_token()
+#     if token:
+#         opts['headers'] = {
+#             'Authorization': f'Bearer {token}'
+#         }
+    
+#     return opts
+
+# def download_video(url, progress_callback):
+#     max_retries = 3
+#     retry_count = 0
+    
+#     while retry_count < max_retries:
+#         try:
+#             has_cookies = os.path.exists(AUTH_CONFIG['COOKIES_FILE'])
+#             ydl_opts = setup_ydl_options(has_cookies)
+            
+#             # Add progress hooks
+#             def progress_hook(d):
+#                 if d['status'] == 'downloading':
+#                     try:
+#                         progress = d['downloaded_bytes'] / d['total_bytes']
+#                         progress_callback(progress, f"Downloading: {progress:.1%}")
+#                     except:
+#                         progress_callback(0, "Downloading... (size unknown)")
+#                 elif d['status'] == 'finished':
+#                     progress_callback(1.0, "Processing...")
+                    
+#             ydl_opts['progress_hooks'] = [progress_hook]
+            
+#             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+#                 info = ydl.extract_info(url, download=True)
+#                 filename = ydl.prepare_filename(info)
+#                 return filename, None
+                
+#         except yt_dlp.utils.ExtractorError as e:
+#             if "Sign in to confirm you're not a bot" in str(e):
+#                 retry_count += 1
+#                 if retry_count < max_retries:
+#                     time.sleep(5)  # Wait before retry
+#                     continue
+#                 return None, "Bot detection triggered. Please try again later or use authentication."
+#             return None, f"Video extraction failed: {str(e)}"
+            
+#         except Exception as e:
+#             return None, f"Download failed: {str(e)}"
+    
+#     return None, "Maximum retries reached. Please try again later."
+
+# # Main UI
+# col1, col2 = st.columns([2, 1])
+
+# with col1:
+#     video_url = st.text_input("Enter YouTube Video URL:", placeholder="https://www.youtube.com/watch?v=...")
+    
+#     if st.button("Download", type="primary"):
+#         if video_url:
+#             progress_bar = st.progress(0)
+#             status_text = st.empty()
+            
+#             def update_progress(progress, status):
+#                 progress_bar.progress(progress)
+#                 status_text.text(status)
+            
+#             downloaded_file, error = download_video(video_url, update_progress)
+            
+#             if downloaded_file and os.path.exists(downloaded_file):
+#                 with open(downloaded_file, 'rb') as file:
+#                     st.download_button(
+#                         label="⬇️ Download Video",
+#                         data=file,
+#                         file_name=os.path.basename(downloaded_file),
+#                         mime="video/mp4"
+#                     )
+#                 st.success("✅ Download ready!")
+#             else:
+#                 st.error(f"❌ {error}")
+#         else:
+#             st.warning("⚠️ Please enter a valid YouTube URL.")
+
+# with col2:
+#     with st.expander("⚙️ Settings & Information"):
+#         st.markdown("""
+#         **Authentication Status:**
+#         """)
+        
+#         if os.path.exists(AUTH_CONFIG['COOKIES_FILE']):
+#             st.success("✅ Cookie authentication available")
+#         else:
+#             st.warning("""
+#             ⚠️ No cookie authentication configured
+            
+#             To enable cookie authentication:
+#             1. Export cookies from your browser
+#             2. Save as 'youtube.com_cookies.txt' in the app directory
+#             """)
+        
+#         st.markdown("""
+#         **Download Options:**
+#         - Videos are downloaded in best available quality
+#         - Format: MP4 (when available)
+#         - Automatic quality selection
+#         """)
+
+# with st.expander("❓ Help & Troubleshooting"):
+#     st.markdown("""
+#     **Common Issues & Solutions:**
+    
+#     1. **Bot Detection:**
+#        - The app implements automatic retries
+#        - Use cookie authentication for better success rate
+#        - Wait a few minutes between attempts
+    
+#     2. **Download Fails:**
+#        - Verify the video is public
+#        - Check your internet connection
+#        - Try a different video
+#        - Clear browser cache and cookies
+    
+#     3. **Quality Issues:**
+#        - The app automatically selects the best available quality
+#        - Some videos may have quality restrictions
+#        - Premium content may require authentication
+    
+#     **Need More Help?**
+#     - Check if the video is available in your region
+#     - Verify YouTube's terms of service
+#     - Consider using cookie authentication
+#     """)
+
+
 import streamlit as st
 import yt_dlp
 import os
 from pathlib import Path
 import time
+import random
 from datetime import datetime
 import json
+import requests
+from fake_useragent import UserAgent
+import http.cookiejar as cookielib
 
 # Set page config
 st.set_page_config(page_title="YouTube Video Downloader", page_icon="📺", layout="wide")
-
-# Set the title of the app
 st.title("YouTube Video Downloader 📺")
 
-# Create output directory if it doesn't exist
-output_dir = Path("downloads")
-output_dir.mkdir(exist_ok=True)
-
-# Authentication settings
-AUTH_CONFIG = {
-    'COOKIES_FILE': 'youtube.com_cookies.txt',
-    'TOKEN_FILE': 'auth_token.json'
-}
-
-def load_auth_token():
-    try:
-        if os.path.exists(AUTH_CONFIG['TOKEN_FILE']):
-            with open(AUTH_CONFIG['TOKEN_FILE'], 'r') as f:
-                data = json.load(f)
-                if datetime.fromisoformat(data['expires']) > datetime.now():
-                    return data['token']
-    except Exception:
-        pass
-    return None
-
-def save_auth_token(token):
-    with open(AUTH_CONFIG['TOKEN_FILE'], 'w') as f:
-        json.dump({
-            'token': token,
-            'expires': (datetime.now().isoformat())
-        }, f)
-
-def setup_ydl_options(has_cookies):
-    opts = {
+# Constants and Configurations
+class Config:
+    OUTPUT_DIR = Path("downloads")
+    COOKIES_FILE = 'youtube.com_cookies.txt'
+    TOKEN_FILE = 'auth_token.json'
+    MAX_RETRIES = 5
+    RETRY_DELAYS = [3, 5, 10, 15, 30]  # Progressive delays in seconds
+    
+    HEADERS_POOL = [
+        {
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        },
+        {
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+        }
+    ]
+
+# Create output directory
+Config.OUTPUT_DIR.mkdir(exist_ok=True)
+
+# Session management
+class SessionManager:
+    @staticmethod
+    def create_cookie_jar():
+        return cookielib.MozillaCookieJar(Config.COOKIES_FILE)
+    
+    @staticmethod
+    def get_random_headers():
+        ua = UserAgent()
+        headers = random.choice(Config.HEADERS_POOL).copy()
+        headers['User-Agent'] = ua.random
+        return headers
+    
+    @staticmethod
+    def get_session():
+        session = requests.Session()
+        if os.path.exists(Config.COOKIES_FILE):
+            session.cookies = SessionManager.create_cookie_jar()
+            session.cookies.load(ignore_discard=True, ignore_expires=True)
+        session.headers.update(SessionManager.get_random_headers())
+        return session
+
+def get_download_options(session_headers=None):
+    """Enhanced download options with anti-bot measures"""
+    options = {
         'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-        'outtmpl': str(output_dir / '%(title)s.%(ext)s'),
+        'outtmpl': str(Config.OUTPUT_DIR / '%(title)s.%(ext)s'),
         'merge_output_format': 'mp4',
         'quiet': True,
         'no_warnings': True,
         'extract_flat': False,
-        'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        'referer': 'https://www.youtube.com/',
-        'http_chunk_size': 10485760,
-        'retries': 3,
+        'nocheckcertificate': True,
+        'http_chunk_size': random.randint(10000000, 15000000),  # Random chunk size
+        'retries': Config.MAX_RETRIES,
         'file_access_retries': 3,
         'fragment_retries': 3,
+        'retry_sleep_functions': {'http': lambda n: random.uniform(1, 5) * n},
         'skip_unavailable_fragments': True,
         'abort_on_unavailable_fragment': False,
     }
     
-    # Add cookies file if available
-    if has_cookies:
-        opts['cookiefile'] = AUTH_CONFIG['COOKIES_FILE']
+    if os.path.exists(Config.COOKIES_FILE):
+        options['cookiefile'] = Config.COOKIES_FILE
     
-    # Add authentication token if available
-    token = load_auth_token()
-    if token:
-        opts['headers'] = {
-            'Authorization': f'Bearer {token}'
-        }
+    if session_headers:
+        options['headers'] = session_headers
     
-    return opts
+    return options
 
-def download_video(url, progress_callback):
-    max_retries = 3
-    retry_count = 0
-    
-    while retry_count < max_retries:
+def download_with_retry(url, progress_callback):
+    """Enhanced download function with multiple retry strategies"""
+    for attempt in range(Config.MAX_RETRIES):
         try:
-            has_cookies = os.path.exists(AUTH_CONFIG['COOKIES_FILE'])
-            ydl_opts = setup_ydl_options(has_cookies)
+            session = SessionManager.get_session()
+            ydl_opts = get_download_options(session.headers)
             
-            # Add progress hooks
             def progress_hook(d):
                 if d['status'] == 'downloading':
                     try:
                         progress = d['downloaded_bytes'] / d['total_bytes']
                         progress_callback(progress, f"Downloading: {progress:.1%}")
                     except:
-                        progress_callback(0, "Downloading... (size unknown)")
+                        progress_callback(-1, f"Downloading... (Attempt {attempt + 1}/{Config.MAX_RETRIES})")
                 elif d['status'] == 'finished':
                     progress_callback(1.0, "Processing...")
-                    
+            
             ydl_opts['progress_hooks'] = [progress_hook]
             
+            # Pre-check video availability
+            with yt_dlp.YoutubeDL({'quiet': True}) as ydl:
+                try:
+                    ydl.extract_info(url, download=False)
+                except Exception as e:
+                    if "This video is not available" in str(e):
+                        return None, "Video is not available. It might be private or deleted."
+            
+            # Actual download
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 info = ydl.extract_info(url, download=True)
                 filename = ydl.prepare_filename(info)
                 return filename, None
                 
         except yt_dlp.utils.ExtractorError as e:
-            if "Sign in to confirm you're not a bot" in str(e):
-                retry_count += 1
-                if retry_count < max_retries:
-                    time.sleep(5)  # Wait before retry
-                    continue
-                return None, "Bot detection triggered. Please try again later or use authentication."
-            return None, f"Video extraction failed: {str(e)}"
+            error_msg = str(e)
+            if "Sign in to confirm you're not a bot" in error_msg:
+                delay = Config.RETRY_DELAYS[min(attempt, len(Config.RETRY_DELAYS)-1)]
+                progress_callback(-1, f"Bot detection encountered. Waiting {delay}s before retry...")
+                time.sleep(delay)
+                continue
+            return None, f"Video extraction failed: {error_msg}"
             
         except Exception as e:
-            return None, f"Download failed: {str(e)}"
+            error_msg = str(e)
+            if attempt < Config.MAX_RETRIES - 1:
+                delay = Config.RETRY_DELAYS[attempt]
+                progress_callback(-1, f"Download failed. Retrying in {delay}s... ({attempt + 1}/{Config.MAX_RETRIES})")
+                time.sleep(delay)
+                continue
+            return None, f"Download failed after {Config.MAX_RETRIES} attempts: {error_msg}"
     
     return None, "Maximum retries reached. Please try again later."
 
-# Main UI
-col1, col2 = st.columns([2, 1])
-
-with col1:
-    video_url = st.text_input("Enter YouTube Video URL:", placeholder="https://www.youtube.com/watch?v=...")
+# UI Components
+def render_main_ui():
+    col1, col2 = st.columns([2, 1])
     
-    if st.button("Download", type="primary"):
-        if video_url:
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            def update_progress(progress, status):
-                progress_bar.progress(progress)
-                status_text.text(status)
-            
-            downloaded_file, error = download_video(video_url, update_progress)
-            
-            if downloaded_file and os.path.exists(downloaded_file):
-                with open(downloaded_file, 'rb') as file:
-                    st.download_button(
-                        label="⬇️ Download Video",
-                        data=file,
-                        file_name=os.path.basename(downloaded_file),
-                        mime="video/mp4"
-                    )
-                st.success("✅ Download ready!")
+    with col1:
+        video_url = st.text_input("Enter YouTube Video URL:", placeholder="https://www.youtube.com/watch?v=...")
+        
+        if st.button("Download", type="primary"):
+            if video_url:
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                def update_progress(progress, status):
+                    if progress >= 0:
+                        progress_bar.progress(progress)
+                    status_text.text(status)
+                
+                downloaded_file, error = download_with_retry(video_url, update_progress)
+                
+                if downloaded_file and os.path.exists(downloaded_file):
+                    with open(downloaded_file, 'rb') as file:
+                        st.download_button(
+                            label="⬇️ Download Video",
+                            data=file,
+                            file_name=os.path.basename(downloaded_file),
+                            mime="video/mp4"
+                        )
+                    st.success("✅ Download completed successfully!")
+                else:
+                    st.error(f"❌ {error}")
             else:
-                st.error(f"❌ {error}")
-        else:
-            st.warning("⚠️ Please enter a valid YouTube URL.")
+                st.warning("⚠️ Please enter a valid YouTube URL.")
+    
+    with col2:
+        render_settings_panel()
 
-with col2:
+def render_settings_panel():
     with st.expander("⚙️ Settings & Information"):
-        st.markdown("""
-        **Authentication Status:**
-        """)
+        st.markdown("**Authentication Status:**")
         
-        if os.path.exists(AUTH_CONFIG['COOKIES_FILE']):
-            st.success("✅ Cookie authentication available")
+        if os.path.exists(Config.COOKIES_FILE):
+            st.success("✅ Cookie authentication active")
+            if st.button("Remove Cookie File"):
+                try:
+                    os.remove(Config.COOKIES_FILE)
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Failed to remove cookie file: {str(e)}")
         else:
             st.warning("""
             ⚠️ No cookie authentication configured
             
             To enable cookie authentication:
-            1. Export cookies from your browser
-            2. Save as 'youtube.com_cookies.txt' in the app directory
+            1. Install a browser extension to export cookies
+            2. Export cookies from YouTube (while logged in)
+            3. Save as 'youtube.com_cookies.txt' in the app directory
             """)
-        
-        st.markdown("""
-        **Download Options:**
-        - Videos are downloaded in best available quality
-        - Format: MP4 (when available)
-        - Automatic quality selection
-        """)
-
-with st.expander("❓ Help & Troubleshooting"):
-    st.markdown("""
-    **Common Issues & Solutions:**
-    
-    1. **Bot Detection:**
-       - The app implements automatic retries
-       - Use cookie authentication for better success rate
-       - Wait a few minutes between attempts
-    
-    2. **Download Fails:**
-       - Verify the video is public
-       - Check your internet connection
-       - Try a different video
-       - Clear browser cache and cookies
-    
-    3. **Quality Issues:**
-       - The app automatically selects the best available quality
-       - Some videos may have quality restrictions
-       - Premium content may require authentication
-    
-    **Need More Help?**
-    - Check if the video is available in your region
-    - Verify YouTube's terms of service
-    - Consider using cookie authentication
-    """)
-
-
-# import streamlit as st
-# import yt_dlp
-# import os
-# from pathlib import Path
-# from http.cookiejar import MozillaCookieJar
-# import random
-# import time
-
-# # Constants
-# COOKIES_FILE = 'youtube.com_cookies.txt'
-# OUTPUT_DIR = Path("downloads")
-
-# # Set page config
-# st.set_page_config(page_title="YouTube Video Downloader", page_icon="📺")
-# st.title("YouTube Video Downloader 📺")
-
-# # Create output directory if it doesn't exist
-# OUTPUT_DIR.mkdir(exist_ok=True)
-
-# def get_random_user_agent():
-#     """랜덤 User-Agent 생성"""
-#     user_agents = [
-#         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
-#         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0',
-#         'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15',
-#         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'
-#     ]
-#     return random.choice(user_agents)
-
-# def validate_cookies():
-#     """쿠키 파일 유효성 검사"""
-#     if not os.path.exists(COOKIES_FILE):
-#         return False, "Cookie file not found"
-    
-#     try:
-#         cookie_jar = MozillaCookieJar(COOKIES_FILE)
-#         cookie_jar.load()
-#         return True, "Cookies loaded successfully"
-#     except Exception as e:
-#         return False, f"Cookie error: {str(e)}"
-
-# def download_with_retry(url, ydl_opts, max_retries=3, delay=5):
-#     """재시도 로직이 포함된 다운로드 함수"""
-#     last_error = None
-    
-#     for attempt in range(max_retries):
-#         try:
-#             # 매 시도마다 새로운 User-Agent 사용
-#             ydl_opts['headers']['User-Agent'] = get_random_user_agent()
-            
-#             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-#                 info = ydl.extract_info(url, download=True)
-#                 filename = ydl.prepare_filename(info)
-#                 return filename, info
-                
-#         except yt_dlp.utils.DownloadError as e:
-#             last_error = e
-#             if "Sign in to confirm you're not a bot" in str(e):
-#                 if attempt < max_retries - 1:
-#                     st.warning(f"Bot detection encountered. Retrying in {delay} seconds... (Attempt {attempt + 1}/{max_retries})")
-#                     time.sleep(delay)
-#                     delay *= 2  # 지수 백오프
-#                     continue
-#             elif "HTTP Error 429" in str(e):
-#                 if attempt < max_retries - 1:
-#                     st.warning(f"Rate limit detected. Waiting {delay} seconds... (Attempt {attempt + 1}/{max_retries})")
-#                     time.sleep(delay * 2)  # 레이트 리밋의 경우 더 긴 대기 시간
-#                     continue
-#         except Exception as e:
-#             last_error = e
-#             if attempt < max_retries - 1:
-#                 st.warning(f"Error occurred. Retrying... (Attempt {attempt + 1}/{max_retries})")
-#                 time.sleep(delay)
-#                 continue
-    
-#     # 모든 재시도 실패 후
-#     raise last_error or Exception("Download failed after all retries")
-
-# def download_video(url):
-#     try:
-#         ydl_opts = {
-#             'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-#             'outtmpl': str(OUTPUT_DIR / '%(title)s.%(ext)s'),
-#             'merge_output_format': 'mp4',
-            
-#             # 쿠키 설정
-#             'cookiefile': COOKIES_FILE,
-            
-#             # 향상된 옵션
-#             'quiet': True,
-#             'no_warnings': True,
-#             'extract_flat': False,
-#             'socket_timeout': 30,
-#             'retries': 10,
-#             'fragment_retries': 10,
-            
-#             # 향상된 헤더
-#             'headers': {
-#                 'User-Agent': get_random_user_agent(),
-#                 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
-#                 'Accept-Language': 'en-US,en;q=0.5',
-#                 'Accept-Encoding': 'gzip, deflate, br',
-#                 'Connection': 'keep-alive',
-#                 'Upgrade-Insecure-Requests': '1',
-#                 'Sec-Fetch-Dest': 'document',
-#                 'Sec-Fetch-Mode': 'navigate',
-#                 'Sec-Fetch-Site': 'none',
-#                 'Sec-Fetch-User': '?1',
-#                 'DNT': '1',
-#                 'Sec-GPC': '1',
-#                 'Pragma': 'no-cache',
-#                 'Cache-Control': 'no-cache',
-#             },
             
-#             # 추가 옵션
-#             'age_limit': None,
-#             'geo_bypass': True,
-#             'geo_bypass_country': 'US',
-#             'sleep_interval': 2,
-#             'max_sleep_interval': 5,
-#         }
+            # Cookie file uploader
+            uploaded_file = st.file_uploader("Upload Cookie File", type=['txt'])
+            if uploaded_file is not None:
+                try:
+                    with open(Config.COOKIES_FILE, 'wb') as f:
+                        f.write(uploaded_file.getvalue())
+                    st.success("✅ Cookie file uploaded successfully!")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Failed to save cookie file: {str(e)}")
+
+def render_help_section():
+    with st.expander("❓ Help & Troubleshooting"):
+        st.markdown("""
+        **Common Issues & Solutions:**
         
-#         # 진행 상황 표시
-#         progress_bar = st.progress(0)
-#         status_text = st.empty()
+        1. **Bot Detection Issues:**
+           - The app now implements multiple retry strategies
+           - Uses random delays between attempts
+           - Rotates User-Agents automatically
+           - Uses cookie authentication when available
         
-#         def progress_hook(d):
-#             if d['status'] == 'downloading':
-#                 try:
-#                     progress = d['downloaded_bytes'] / d['total_bytes']
-#                     progress_bar.progress(progress)
-#                     status_text.text(f"Downloading: {progress:.1%} | Speed: {d.get('speed_str', 'N/A')} | ETA: {d.get('eta_str', 'N/A')}")
-#                 except:
-#                     status_text.text(f"Downloading... Speed: {d.get('speed_str', 'N/A')}")
-#             elif d['status'] == 'finished':
-#                 progress_bar.progress(1.0)
-#                 status_text.text("Processing downloaded files...")
-                
-#         ydl_opts['progress_hooks'] = [progress_hook]
+        2. **Download Problems:**
+           - Check if the video is public and available
+           - Verify your internet connection
+           - Try uploading a fresh cookie file
+           - Clear browser cache and try again
         
-#         return download_with_retry(url, ydl_opts)
-            
-#     except Exception as e:
-#         raise Exception(f"Download error: {str(e)}")
-
-# # 쿠키 상태 확인
-# cookie_valid, cookie_message = validate_cookies()
-# if not cookie_valid:
-#     st.warning(f"⚠️ Cookie Issue: {cookie_message}")
-# else:
-#     st.success("✅ Cookies loaded successfully")
+        3. **Quality Settings:**
+           - Automatically selects best available quality
+           - Prioritizes MP4 format when available
+           - Handles premium content with proper authentication
+        
+        **Need More Help?**
+        - Make sure you're using an up-to-date browser
+        - Check if the video is available in your region
+        - Consider using a VPN if region-blocked
+        - Ensure your cookie file is recent and valid
+        """)
 
-# # 비디오 URL 입력
-# video_url = st.text_input("Enter YouTube Video URL:", placeholder="https://www.youtube.com/watch?v=...")
+# Main App
+def main():
+    render_main_ui()
+    render_help_section()
 
-# # 다운로드 버튼
-# if st.button("Download Video"):
-#     if not video_url:
-#         st.warning("⚠️ Please enter a valid YouTube URL.")
-#     elif not cookie_valid:
-#         st.error("❌ Cannot proceed without valid cookies.")
-#     else:
-#         try:
-#             with st.spinner("Preparing download..."):
-#                 downloaded_file_path, video_info = download_video(video_url)
-                
-#             if downloaded_file_path and os.path.exists(downloaded_file_path):
-#                 file_size = os.path.getsize(downloaded_file_path)
-#                 st.info(f"""
-#                 **Download Complete!**
-#                 - File: {os.path.basename(downloaded_file_path)}
-#                 - Size: {file_size / (1024*1024):.1f} MB
-#                 """)
-                
-#                 with open(downloaded_file_path, 'rb') as file:
-#                     st.download_button(
-#                         label="💾 Download Video",
-#                         data=file,
-#                         file_name=os.path.basename(downloaded_file_path),
-#                         mime="video/mp4"
-#                     )
-#             else:
-#                 st.error("❌ Download failed. Please try again.")
-#         except Exception as e:
-#             st.error(f"❌ {str(e)}")
-
-# # Help 섹션
-# with st.expander("ℹ️ Troubleshooting Guide"):
-#     st.markdown(f"""
-#     **Current Status:**
-#     - Cookie File: {'✅ Found' if os.path.exists(COOKIES_FILE) else '❌ Not Found'}
-#     - Cookie Validity: {'✅ Valid' if cookie_valid else '❌ Invalid'}
-    
-#     **Common Issues:**
-#     1. Bot Detection:
-#        - The app will automatically retry with different settings
-#        - Each retry uses a random User-Agent and headers
-       
-#     2. Cookie Problems:
-#        - Current cookie file: {COOKIES_FILE}
-#        - Make sure the cookie file is up to date
-#        - Export fresh cookies when issues persist
-       
-#     3. Download Fails:
-#        - Try again after a few minutes
-#        - Check if the video is available in your region
-#        - Verify that the video is public
-#     """)
+if __name__ == "__main__":
+    main()