app.py

import os
import logging
from flask import Flask, request, jsonify, send_file, render_template, Response, send_from_directory, session, redirect, url_for, make_response
from werkzeug.middleware.proxy_fix import ProxyFix
from flask_cors import CORS
import yt_dlp
from dotenv import load_dotenv
import datetime
import requests
import re
from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound

from video_processor import YouTubeProcessor
from lib.cache_manager import CacheManager
from lib.local_video_manager import LocalVideoManager
from lib.config_manager import ConfigManager
from lib.movie_api import movie_api
from lib.summarizer import summarize_text
# Load environment variables
load_dotenv()

# Configure logging
logging.basicConfig(level=logging.DEBUG)

# Create the Flask app
app = Flask(__name__)
app.secret_key = os.environ.get("SESSION_SECRET", "dev-secret-key-change-in-production")
app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=7)  # Session lasts 7 days
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
CORS(app)

# Configure upload folder
UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'downloads')
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

# Ensure upload folder exists
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

# Initialize cache manager
cache_manager = CacheManager()

# Initialize YouTube processor
youtube_processor = YouTubeProcessor()

# Initialize local video manager
local_video_manager = LocalVideoManager()

# Initialize config manager
config_manager = ConfigManager()

# Context processor to make config available in all templates
@app.context_processor
def inject_config():
    """Inject config into all templates"""
    return {'config': config_manager.get_config()}

@app.route('/api/config')
def generate_config_js():
    """Generate dynamic config.js file with actual config values"""
    config = config_manager.get_config()
    
    js_content = f"""// Global configuration object accessible to all JavaScript files
// This file is generated by the server with actual config values
// Generated at: {datetime.datetime.now().isoformat()}
window.APP_CONFIG = {{
    videos_per_page: {config.get('videos_per_page', 24)},
    logo_text: "{config.get('logo_text', 'KCTube')}",
    theme: "{config.get('theme', 'dark')}",
    language: "{config.get('language', 'vi')}",
    auto_play: {str(config.get('auto_play', False)).lower()},
    background_play: {str(config.get('background_play', False)).lower()},
    download_path: "{config.get('download_path', '/downloads')}",
    cache_enabled: {str(config.get('cache_enabled', True)).lower()},
    cache_duration: {config.get('cache_duration', 3600)},
    max_downloads: {config.get('max_downloads', 5)},
    quality_preference: "{config.get('quality_preference', 'best')}",
    format_preference: "{config.get('format_preference', 'mp4')}"
}};

// Helper function to get config value with default
window.getConfig = function(key, defaultValue = null) {{
    return window.APP_CONFIG[key] !== undefined ? window.APP_CONFIG[key] : defaultValue;
}};

// Helper function to update config value (for runtime updates)
window.updateConfig = function(key, value) {{
    window.APP_CONFIG[key] = value;
    // Trigger custom event for config changes
    window.dispatchEvent(new CustomEvent('configChanged', {{ 
        detail: {{ key: key, value: value }} 
    }}));
}};

// Helper function to listen for config changes
window.onConfigChange = function(callback) {{
    window.addEventListener('configChanged', function(event) {{
        callback(event.detail.key, event.detail.value);
    }});
}};

// Helper function to get videos per page
window.getVideosPerPage = function() {{
    return window.getConfig('videos_per_page', 24);
}};

// Helper function to get logo text
window.getLogoText = function() {{
    return window.getConfig('logo_text', 'KCTube');
}};

// Helper function to get theme
window.getTheme = function() {{
    return window.getConfig('theme', 'dark');
}};

// Helper function to check if auto play is enabled
window.isAutoPlayEnabled = function() {{
    return window.getConfig('auto_play', false);
}};

// Helper function to check if background play is enabled
window.isBackgroundPlayEnabled = function() {{
    return window.getConfig('background_play', false);
}};
"""
    
    response = Response(js_content, mimetype='application/javascript')
    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = '0'
    return response

# Configure yt-dlp options
ydl_opts = {
    'format': 'best',
    'quiet': True,
    'no_warnings': True,
    'extract_flat': True,
    'force_generic_extractor': False
}

def format_duration(seconds):
    if not seconds:
        return '0:00'
    minutes, seconds = divmod(int(seconds), 60)
    hours, minutes = divmod(minutes, 60)
    if hours > 0:
        return f'{hours}:{minutes:02d}:{seconds:02d}'
    return f'{minutes}:{seconds:02d}'

def format_view_count(count):
    if not count:
        return '0 lượt xem'
    if count >= 1000000:
        return f'{count/1000000:.1f}M lượt xem'
    elif count >= 1000:
        return f'{count/1000:.1f}K lượt xem'
    return f'{count} lượt xem'

@app.route('/player')
def player_page():
    """Test page for KCTube player"""
    return render_template('player.html')

@app.route('/my-videos', methods=['GET', 'POST'])
def my_videos_page():
    """Render the My Videos page, protected by password if set"""
    print(f"DEBUG: Accessing /my-videos, method: {request.method}")
    print(f"DEBUG: Has password: {config_manager.has_password()}")
    
    # Check if password protection is enabled
    if config_manager.has_password():
        print("DEBUG: Password protection is enabled")
        
        # Check authentication cookie
        auth_cookie = request.cookies.get('my_videos_auth')
        print(f"DEBUG: Auth cookie: {auth_cookie}")
        
        if request.method == 'POST':
            # Handle password submission
            password = request.form.get('password', '')
            print(f"DEBUG: Password submitted: {bool(password)}")
            if config_manager.check_password(password):
                print("DEBUG: Password is correct, setting cookie and redirecting")
                response = redirect(url_for('my_videos_page'))
                response.set_cookie('my_videos_auth', 'true', max_age=7*24*60*60)  # 7 days
                return response
            else:
                print("DEBUG: Password is incorrect, redirecting to login with error")
                return redirect(url_for('my_videos_login', error='invalid'))
        
        # GET request - check if authenticated
        if not auth_cookie or auth_cookie != 'true':
            print("DEBUG: Not authenticated, redirecting to login")
            return redirect(url_for('my_videos_login'))
        
        # Authenticated - show my videos
        print("DEBUG: Authenticated, showing my videos")
        response = make_response(render_template('my_videos.html'))
        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        response.headers['Pragma'] = 'no-cache'
        response.headers['Expires'] = '0'
        return response
    
    # No password protection - show my videos directly
    print("DEBUG: No password protection, showing my videos directly")
    response = make_response(render_template('my_videos.html'))
    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = '0'
    return response

@app.route('/my-videos/login', methods=['GET', 'POST'])
def my_videos_login():
    """Login page for My Videos"""
    print(f"DEBUG: Accessing /my-videos/login, method: {request.method}")
    
    # Check if password protection is enabled
    if not config_manager.has_password():
        print("DEBUG: No password protection, redirecting to my videos")
        return redirect(url_for('my_videos_page'))
    
    # Check if already authenticated
    auth_cookie = request.cookies.get('my_videos_auth')
    if auth_cookie == 'true':
        print("DEBUG: Already authenticated, redirecting to my videos")
        return redirect(url_for('my_videos_page'))
    
    # Handle password submission
    if request.method == 'POST':
        password = request.form.get('password', '')
        print(f"DEBUG: Password submitted: {bool(password)}")
        if config_manager.check_password(password):
            print("DEBUG: Password is correct, setting cookie and redirecting")
            response = redirect(url_for('my_videos_page'))
            response.set_cookie('my_videos_auth', 'true', max_age=7*24*60*60)  # 7 days
            return response
        else:
            print("DEBUG: Password is incorrect")
            return render_template('my_videos_login.html', error=True)
    
    # GET request - show login form
    error = request.args.get('error') == 'invalid'
    print(f"DEBUG: Showing login form, error: {error}")
    return render_template('my_videos_login.html', error=error)

@app.route('/my-videos/logout')
def my_videos_logout():
    """Logout from My Videos (clear cookie)"""
    response = redirect(url_for('my_videos_page'))
    response.delete_cookie('my_videos_auth')
    return response

@app.route('/movies')
def movies_page():
    """Render the Movies page"""
    return render_template('movies.html')

@app.route('/tienganh')
def tienganh_page():
    """Render the English Learning page"""
    return render_template('tienganh.html')

@app.route('/torrent')
def torrent_page():
    """Render the Torrent Player page"""
    return render_template('torrent.html')

@app.route('/pwa-debug')
def pwa_debug_page():
    """Render the PWA Debug page"""
    return render_template('pwa_debug.html')

@app.route('/about')
def about_page():
    """Render the About (Giới thiệu) page"""
    return render_template('about_kct.html')
@app.route('/test')
def test():
    """Render the About (Giới thiệu) page"""
    return render_template('test.html')

@app.route('/api/category/<category>')
def get_category_videos(category):
    page = int(request.args.get('page', 1))
    config = config_manager.get_config()
    max_results = int(request.args.get('max_results', config.get('videos_per_page', 24)))
    
    # Map category to search terms
    category_map = {
        'music': 'music',
        'gaming': 'gaming',
        'news': 'news',
        'live': 'live stream',
        'shorts': 'shorts'
    }
    
    try:
        search_term = category_map.get(category)
        if not search_term:
            return jsonify({'error': 'Invalid category'}), 400
        
        # Configure yt-dlp for search
        search_opts = ydl_opts.copy()
        search_opts.update({
            'default_search': 'ytsearch',
            'extract_flat': True,
            'quiet': True,
            'no_warnings': True
        })
        
        # Perform search
        with yt_dlp.YoutubeDL(search_opts) as ydl:
            # Add page number to search query
            search_query = f"{search_term} -p{page}"
            result = ydl.extract_info(search_query, download=False)
            
            if not result or 'entries' not in result:
                return jsonify({'videos': [], 'nextPageToken': None})
            
            # Transform the response
            videos = []
            for entry in result['entries'][:max_results]:
                if not entry:
                    continue
                    
                video = {
                    'id': entry.get('id', ''),
                    'title': entry.get('title', ''),
                    'author': entry.get('uploader', ''),
                    'thumbnail': entry.get('thumbnail', ''),
                    'duration': format_duration(entry.get('duration')),
                    'stats': format_view_count(entry.get('view_count', 0))
                }
                videos.append(video)
            
            return jsonify({
                'videos': videos,
                'nextPageToken': str(page + 1) if len(videos) == max_results else None
            })
            
    except Exception as e:
        logging.error(f"Error getting category videos: {str(e)}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/search')
def search_videos():
    """Search YouTube videos"""
    query = request.args.get('q', '')
    config = config_manager.get_config()
    max_results = int(request.args.get('max_results', config.get('videos_per_page', 24)))
    page = int(request.args.get('page', 1))
    
    if not query:
        return jsonify({'videos': [], 'total': 0, 'has_more': False})
    
    try:
        # Generate cache key from query, max_results and page
        cache_key = f"search_{query}_{max_results}_{page}"
        
        # Try to get from cache first
        cached_results = cache_manager.get(cache_key)
        if cached_results:
            logging.info(f"Cache hit for query: {query} (page {page})")
            return jsonify(cached_results)
        
        # If not in cache, perform search
        logging.info(f"Cache miss for query: {query} (page {page})")
        results = youtube_processor.search_videos(query, max_results, page)
        
        # Cache the results
        cache_manager.set(cache_key, results)
        
        return jsonify(results)
    except Exception as e:
        logging.error(f"Search error: {e}")
        return jsonify({'error': f'Search failed: {str(e)}'}), 500

@app.route('/api/related/<video_id>')
def get_related_videos(video_id):
    """Get related videos for a specific video"""
    config = config_manager.get_config()
    max_results = int(request.args.get('max_results', config.get('videos_per_page', 24)))
    
    try:
        # Generate cache key
        cache_key = f"related_{video_id}_{max_results}"
        
        # Try to get from cache first
        cached_results = cache_manager.get(cache_key)
        if cached_results:
            logging.info(f"Cache hit for related videos: {video_id}")
            return jsonify(cached_results)
        
        # If not in cache, get related videos
        logging.info(f"Cache miss for related videos: {video_id}")
        results = youtube_processor.get_related_videos(video_id, max_results)
        
        # Cache the results
        cache_manager.set(cache_key, results)
        
        return jsonify(results)
    except Exception as e:
        logging.error(f"Related videos error: {e}")
        return jsonify({'error': f'Failed to get related videos: {str(e)}'}), 500

@app.route('/api/local/videos')
def get_local_videos():
    """Get paginated list of local videos with optional search"""
    page = int(request.args.get('page', 1))
    config = config_manager.get_config()
    per_page = int(request.args.get('per_page', config.get('videos_per_page', 24)))
    search = request.args.get('search')
    
    videos, total = local_video_manager.get_videos(page, per_page, search)
    
    # If no videos found, try scanning once
    if total == 0:
        try:
            logging.info("No videos found, performing scan...")
            local_video_manager.scan_videos()
            videos, total = local_video_manager.get_videos(page, per_page, search)
            logging.info(f"Scan completed, found {total} videos")
        except Exception as e:
            logging.error(f"Error during automatic scan: {e}")
    
    return jsonify({
        'videos': videos,
        'total': total,
        'page': page,
        'per_page': per_page,
        'total_pages': (total + per_page - 1) // per_page
    })

@app.route('/api/local/videos/<video_id>')
def get_local_video(video_id):
    """Get specific local video by ID"""
    video = local_video_manager.get_video(video_id)
    if not video:
        return jsonify({'error': 'Video not found'}), 404
    return jsonify(video)

@app.route('/api/local/videos/<video_id>/summary')
def get_local_video_summary(video_id):
    """Get AI summary for local video subtitle"""
    subtitle = local_video_manager.get_subtitle(video_id)
    if not subtitle:
        return jsonify({'error': 'Subtitle not found'}), 404
    try:
        summary = summarize_text(subtitle)
        return jsonify({'summary': summary})
    except Exception as e:
        return jsonify({'error': f'Failed to summarize: {str(e)}'}), 500

@app.route('/api/local/videos/<video_id>/stream')
def stream_local_video(video_id):
    """Stream local video file"""
    video = local_video_manager.get_video(video_id)
    if not video:
        return jsonify({'error': 'Video not found'}), 404
    
    return send_file(
        video['path'],
        mimetype='video/mp4',
        as_attachment=False
    )

@app.route('/api/local/videos/scan', methods=['GET'])
def scan_local_videos():
    """Scan for new local videos"""
    try:
        local_video_manager.scan_videos()
        return jsonify({'message': 'Scan completed successfully'})
    except Exception as e:
        logging.error(f"Error scanning videos: {e}")
        return jsonify({'error': str(e)}), 500

# Movie API Routes
@app.route('/api/movies/scenes')
def get_movie_scenes():
    """Get list of movie scenes/categories"""
    try:
        # Get credentials from config or request
        email = request.args.get('email')
        password = request.args.get('password')
        
        scenes = movie_api.get_scenes(email, password)
        return jsonify({
            'scenes': scenes,
            'total': len(scenes)
        })
    except Exception as e:
        logging.error(f"Error getting movie scenes: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/scenes/<scene_name>/videos')
def get_movies_by_scene(scene_name):
    """Get videos from a specific movie scene/category"""
    try:
        page = int(request.args.get('page', 1))
        per_page = int(request.args.get('per_page', 24))
        email = request.args.get('email')
        password = request.args.get('password')
        
        videos = movie_api.get_videos_by_scene(scene_name, email, password)
        
        # Simple pagination
        start_idx = (page - 1) * per_page
        end_idx = start_idx + per_page
        paginated_videos = videos[start_idx:end_idx]
        
        return jsonify({
            'videos': paginated_videos,
            'total': len(videos),
            'page': page,
            'per_page': per_page,
            'total_pages': (len(videos) + per_page - 1) // per_page,
            'scene_name': scene_name
        })
    except Exception as e:
        logging.error(f"Error getting movies for scene {scene_name}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/search')
def search_movies():
    """Search movies across all scenes"""
    try:
        query = request.args.get('q', '')
        page = int(request.args.get('page', 1))
        per_page = int(request.args.get('per_page', 24))
        email = request.args.get('email')
        password = request.args.get('password')
        
        if not query:
            return jsonify({'videos': [], 'total': 0, 'page': page, 'per_page': per_page, 'total_pages': 0})
        
        videos = movie_api.search_videos(query, email, password)
        
        # Simple pagination
        start_idx = (page - 1) * per_page
        end_idx = start_idx + per_page
        paginated_videos = videos[start_idx:end_idx]
        
        return jsonify({
            'videos': paginated_videos,
            'total': len(videos),
            'page': page,
            'per_page': per_page,
            'total_pages': (len(videos) + per_page - 1) // per_page,
            'query': query
        })
    except Exception as e:
        logging.error(f"Error searching movies: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/all')
def get_all_movies():
    """Get all movies from all scenes with pagination"""
    try:
        page = int(request.args.get('page', 1))
        per_page = int(request.args.get('per_page', 24))
        limit = int(request.args.get('limit', 100))
        email = request.args.get('email')
        password = request.args.get('password')
        
        videos = movie_api.get_all_videos(email, password, limit)
        
        # Simple pagination
        start_idx = (page - 1) * per_page
        end_idx = start_idx + per_page
        paginated_videos = videos[start_idx:end_idx]
        
        return jsonify({
            'videos': paginated_videos,
            'total': len(videos),
            'page': page,
            'per_page': per_page,
            'total_pages': (len(videos) + per_page - 1) // per_page
        })
    except Exception as e:
        logging.error(f"Error getting all movies: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/video/<video_id>')
def get_movie_video(video_id):
    """Get specific movie video by ID"""
    try:
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Get all videos and find the specific one
        all_videos = movie_api.get_all_videos(email, password, limit=1000)
        
        for video in all_videos:
            if video.get('id') == video_id:
                return jsonify(video)
        
        return jsonify({'error': 'Video not found'}), 404
    except Exception as e:
        logging.error(f"Error getting movie video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/stream/<video_id>')
def stream_movie_video(video_id):
    """Stream movie video by ID"""
    try:
        logging.info(f"Stream request for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Get all videos and find the specific one
        all_videos = movie_api.get_all_videos(email, password, limit=1000)
        logging.info(f"Found {len(all_videos)} total videos")
        
        target_video = None
        for i, video in enumerate(all_videos):
            video_id_from_api = video.get('id', '')
            logging.info(f"Video {i}: id='{video_id_from_api}', title='{video.get('title', '')}'")
            if video_id_from_api == video_id:
                target_video = video
                logging.info(f"Found target video: {video.get('title', '')}")
                break
        
        if not target_video:
            logging.warning(f"Video not found for ID: '{video_id}'")
            return jsonify({'error': f'Video not found for ID: {video_id}'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            logging.warning(f"Video URL not available for video: {target_video.get('title', '')}")
            return jsonify({'error': 'Video URL not available'}), 404
        
        response_data = {
            'video_url': video_url,
            'title': target_video.get('title'),
            'thumbnail': target_video.get('thumbnail'),
            'id': target_video.get('id')
        }
        
        logging.info(f"Returning video data: {response_data}")
        return jsonify(response_data)
        
    except Exception as e:
        logging.error(f"Error streaming movie video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/proxy/<video_id>')
def proxy_movie_video(video_id):
    """Proxy movie video stream to avoid CORS issues"""
    try:
        logging.info(f"Proxy request for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Check if it's a generated ID (starts with 'movie_')
        if video_id.startswith('movie_'):
            # Extract index from generated ID: movie_{index}_{timestamp}_{random}
            try:
                index = int(video_id.split('_')[1])
                logging.info(f"Generated ID detected, using index: {index}")
                
                # Get all videos and use the index
                all_videos = movie_api.get_all_videos(email, password, limit=1000)
                
                if index < 0 or index >= len(all_videos):
                    return jsonify({'error': f'Video index {index} out of range'}), 404
                
                target_video = all_videos[index]
                logging.info(f"Found video by index: {target_video.get('title', '')}")
                
            except (ValueError, IndexError) as e:
                logging.error(f"Error parsing generated ID {video_id}: {e}")
                return jsonify({'error': 'Invalid generated video ID'}), 400
        else:
            # Original ID - search by ID
            all_videos = movie_api.get_all_videos(email, password, limit=1000)
            
            target_video = None
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Import requests here to avoid circular imports
        import requests
        
        # Stream the video content
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        # Get the video stream
        response = requests.get(video_url, headers=headers, stream=True, verify=False)
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch video: {response.status_code}'}), 500
        
        # Create a Flask response that streams the content
        def generate():
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    yield chunk
        
        # Determine content type
        content_type = response.headers.get('content-type', 'video/mp4')
        
        return Response(
            generate(),
            content_type=content_type,
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type',
                'Content-Length': response.headers.get('content-length', ''),
                'Accept-Ranges': 'bytes',
            }
        )
        
    except Exception as e:
        logging.error(f"Error proxying movie video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/proxy-hls/<video_id>')
def proxy_hls_manifest(video_id):
    """Proxy HLS manifest to avoid CORS issues"""
    try:
        logging.info(f"HLS proxy request for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Check if it's a generated ID (starts with 'movie_')
        if video_id.startswith('movie_'):
            # Extract index from generated ID: movie_{index}_{timestamp}_{random}
            try:
                index = int(video_id.split('_')[1])
                logging.info(f"Generated ID detected for HLS, using index: {index}")
                
                # Get all videos and use the index
                all_videos = movie_api.get_all_videos(email, password, limit=1000)
                
                if index < 0 or index >= len(all_videos):
                    return jsonify({'error': f'Video index {index} out of range'}), 404
                
                target_video = all_videos[index]
                logging.info(f"Found video by index for HLS: {target_video.get('title', '')}")
                
            except (ValueError, IndexError) as e:
                logging.error(f"Error parsing generated ID {video_id}: {e}")
                return jsonify({'error': 'Invalid generated video ID'}), 400
        else:
            # Original ID - search by ID
            all_videos = movie_api.get_all_videos(email, password, limit=1000)
            
            target_video = None
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Import requests here to avoid circular imports
        import requests
        
        # Get the HLS manifest
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(video_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch HLS manifest: {response.status_code}'}), 500
        
        # Get the manifest content
        manifest_content = response.text
        
        # Replace segment URLs to use our FFmpeg proxy
        base_url = video_url.rsplit('/', 1)[0] + '/'
        proxy_base = f'/api/movies/ffmpeg-segment/{video_id}/'
        
        # Replace segment URLs in the manifest
        import re
        
        # Function to properly replace segment URLs
        def replace_segment_urls_in_manifest(manifest_content, proxy_base):
            lines = manifest_content.split('\n')
            modified_lines = []
            
            for line in lines:
                stripped_line = line.strip()
                
                # Check if this line contains a segment URL (not a comment and contains segment extension)
                if (stripped_line and 
                    not stripped_line.startswith('#') and 
                    (stripped_line.endswith('.ts') or stripped_line.endswith('.m4s') or stripped_line.endswith('.mp4'))):
                    
                    # If it's an absolute URL, extract just the filename
                    if stripped_line.startswith('http'):
                        segment_name = stripped_line.split('/')[-1]
                        modified_line = proxy_base + segment_name
                    else:
                        # It's a relative URL, just prepend the proxy base
                        modified_line = proxy_base + stripped_line
                    
                    logging.info(f"Replaced segment URL: {stripped_line} -> {modified_line}")
                    modified_lines.append(modified_line)
                else:
                    # Keep the line as is
                    modified_lines.append(line)
            
            return '\n'.join(modified_lines)
        
        # Apply the replacement
        manifest_content = replace_segment_urls_in_manifest(manifest_content, proxy_base)
        
        # Also replace audio and subtitle URLs if they exist
        manifest_content = re.sub(r'URI="([^"]+\.m3u8)"', r'URI="/api/movies/ffmpeg-hls-audio/' + video_id + r'/\1"', manifest_content)
        
        # Replace subtitle URLs (VTT, SRT, ASS files)
        manifest_content = re.sub(r'URI="([^"]+\.(vtt|srt|ass|ssa))"', r'URI="/api/movies/ffmpeg-subtitle/' + video_id + r'/\1"', manifest_content)
        
        # Add debug logging for manifest content
        logging.info(f"Original manifest length: {len(response.text)}")
        logging.info(f"Modified manifest length: {len(manifest_content)}")
        logging.info(f"Segment replacements made: {manifest_content.count(proxy_base)}")
        
        # Log a sample of the modified manifest
        lines = manifest_content.split('\n')
        segment_lines = [line for line in lines if '.ts' in line or '.m4s' in line or '.mp4' in line]
        if segment_lines:
            logging.info(f"Sample segment lines: {segment_lines[:3]}")
        
        # Add CORS headers for the manifest
        return Response(
            manifest_content,
            content_type='application/vnd.apple.mpegurl',
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type, Range',
                'Access-Control-Expose-Headers': 'Content-Length, Content-Range',
                'Cache-Control': 'public, max-age=300',
            }
        )
        
    except Exception as e:
        logging.error(f"Error in FFmpeg HLS proxy for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/ffmpeg-segment/<video_id>/<segment>')
def ffmpeg_segment_proxy(video_id, segment):
    """Proxy HLS segments using FFmpeg"""
    try:
        logging.info(f"FFmpeg segment proxy request for video_id: '{video_id}', segment: '{segment}'")
        
        # Get the original video URL to construct segment URL
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Check if it's a generated ID (starts with 'movie_')
        if video_id.startswith('movie_'):
            # Extract index from generated ID: movie_{index}_{timestamp}_{random}
            try:
                index = int(video_id.split('_')[1])
                logging.info(f"Generated ID detected for segment, using index: {index}")
                
                # Get all videos and use the index
                all_videos = movie_api.get_all_videos(email, password, limit=1000)
                
                if index < 0 or index >= len(all_videos):
                    return jsonify({'error': f'Video index {index} out of range'}), 404
                
                target_video = all_videos[index]
                logging.info(f"Found video by index for segment: {target_video.get('title', '')}")
                
            except (ValueError, IndexError) as e:
                logging.error(f"Error parsing generated ID {video_id}: {e}")
                return jsonify({'error': 'Invalid generated video ID'}), 400
        else:
            # Original ID - search by ID
            all_videos = movie_api.get_all_videos(email, password, limit=1000)
            
            target_video = None
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Try multiple base URL strategies
        possible_base_urls = []
        
        # Strategy 1: Use the same directory as the manifest
        base_url = video_url.rsplit('/', 1)[0] + '/'
        possible_base_urls.append(base_url)
        
        # Strategy 2: Try parent directory
        if '/' in base_url.rstrip('/'):
            parent_base = base_url.rstrip('/').rsplit('/', 1)[0] + '/'
            possible_base_urls.append(parent_base)
        
        # Strategy 3: Try common HLS directory patterns
        common_patterns = ['segments/', 'chunks/', 'fragments/', 'ts/', 'hls/']
        for pattern in common_patterns:
            possible_base_urls.append(base_url + pattern)
        
        # Strategy 4: Try removing common prefixes from segment name
        segment_variations = [segment]
        if segment.startswith('segment_'):
            segment_variations.append(segment[8:])  # Remove 'segment_' prefix
        if segment.startswith('chunk_'):
            segment_variations.append(segment[6:])  # Remove 'chunk_' prefix
        
        # Strategy 5: Try different segment naming patterns
        # If segment is like "0_1.ts", try "segment_0_1.ts", "chunk_0_1.ts", etc.
        if '_' in segment and segment.endswith('.ts'):
            base_name = segment.replace('.ts', '')
            parts = base_name.split('_')
            if len(parts) >= 2:
                # Try different naming patterns
                segment_variations.extend([
                    f"segment_{base_name}.ts",
                    f"chunk_{base_name}.ts",
                    f"fragment_{base_name}.ts",
                    f"{parts[0]}_{parts[1]}.ts",  # Keep original
                    f"{parts[1]}_{parts[0]}.ts",  # Reverse order
                ])
        
        # Import requests here to avoid circular imports
        import requests
        
        # Get the segment
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = None
        successful_url = None
        
        # Try each possible base URL and segment variation
        for base_url in possible_base_urls:
            for segment_var in segment_variations:
                segment_url = base_url + segment_var
                logging.info(f"Trying segment URL: {segment_url}")
                
                try:
                    response = requests.get(segment_url, headers=headers, stream=True, verify=False, timeout=10)
                    if response.status_code == 200:
                        successful_url = segment_url
                        logging.info(f"Successfully found segment at: {successful_url}")
                        break
                except Exception as e:
                    logging.warning(f"Failed to fetch segment from {segment_url}: {e}")
                    continue
            
            if successful_url:
                break
        
        if not response or response.status_code != 200:
            # If all strategies failed, try the original approach
            segment_url = video_url.rsplit('/', 1)[0] + '/' + segment
            logging.info(f"Trying fallback segment URL: {segment_url}")
            
            try:
                response = requests.get(segment_url, headers=headers, stream=True, verify=False, timeout=10)
                successful_url = segment_url
            except Exception as e:
                logging.error(f"Failed to fetch segment from fallback URL: {e}")
                return jsonify({'error': f'Failed to fetch segment: {segment}'}), 500
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch segment: {response.status_code}'}), 500
        
        # Check if response has content
        content_length = response.headers.get('content-length', '0')
        if content_length == '0' or not content_length:
            logging.warning(f"Segment {segment} has no content length")
        
        # Stream the segment content
        def generate():
            chunk_count = 0
            total_size = 0
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    chunk_count += 1
                    total_size += len(chunk)
                    yield chunk
            
            logging.info(f"Streamed segment {segment}: {chunk_count} chunks, {total_size} bytes")
        
        # Determine content type based on segment extension
        content_type = 'video/MP2T'  # Default for .ts files
        if segment.endswith('.m4s'):
            content_type = 'video/mp4'
        elif segment.endswith('.mp4'):
            content_type = 'video/mp4'
        
        logging.info(f"Successfully proxying segment {segment} from {successful_url}")
        
        return Response(
            generate(),
            content_type=content_type,
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type, Range',
                'Access-Control-Expose-Headers': 'Content-Length, Content-Range',
                'Content-Length': response.headers.get('content-length', ''),
                'Accept-Ranges': 'bytes',
                'Cache-Control': 'public, max-age=3600',
            }
        )
        
    except Exception as e:
        logging.error(f"Error in FFmpeg segment proxy for segment {segment}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/ffmpeg-subtitle/<video_id>/<path:subtitle_url>')
def ffmpeg_subtitle_proxy(video_id, subtitle_url):
    """Proxy subtitle streams"""
    try:
        # Decode the subtitle URL
        import urllib.parse
        subtitle_url = urllib.parse.unquote(subtitle_url)
        
        # Import requests here to avoid circular imports
        import requests
        
        # Get the subtitle file
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(subtitle_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch subtitle: {response.status_code}'}), 500
        
        # Determine content type based on file extension
        content_type = 'text/plain'
        if subtitle_url.endswith('.vtt'):
            content_type = 'text/vtt'
        elif subtitle_url.endswith('.srt'):
            content_type = 'application/x-subrip'
        elif subtitle_url.endswith('.ass') or subtitle_url.endswith('.ssa'):
            content_type = 'text/x-ass'
        
        return Response(
            response.content,
            content_type=content_type,
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type',
            }
        )
        
    except Exception as e:
        logging.error(f"Error in FFmpeg subtitle proxy for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/test-hls/<video_id>')
def test_hls_stream(video_id):
    """Test HLS stream to check if it's working properly"""
    try:
        logging.info(f"Testing HLS stream for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Get video data
        all_videos = movie_api.get_all_videos(email, password, limit=1000)
        
        target_video = None
        if video_id.startswith('movie_'):
            try:
                index = int(video_id.split('_')[1])
                if index >= 0 and index < len(all_videos):
                    target_video = all_videos[index]
            except (ValueError, IndexError):
                pass
        else:
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Test the original URL
        import requests
        
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(video_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({
                'error': f'Failed to fetch HLS manifest: {response.status_code}',
                'status_code': response.status_code,
                'headers': dict(response.headers)
            }), 500
        
        # Check if it's actually an HLS manifest
        content = response.text
        is_hls = '#EXTM3U' in content
        
        # Count segments
        segment_count = content.count('.ts') + content.count('.m4s') + content.count('.mp4')
        
        return jsonify({
            'success': True,
            'is_hls': is_hls,
            'content_length': len(content),
            'segment_count': segment_count,
            'content_preview': content[:500] + '...' if len(content) > 500 else content,
            'original_url': video_url,
            'proxy_url': f'/api/movies/ffmpeg-hls/{video_id}'
        })
        
    except Exception as e:
        logging.error(f"Error testing HLS stream for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/ffmpeg-hls/<video_id>')
def ffmpeg_hls_proxy(video_id):
    """Proxy HLS manifest and modify it to use FFmpeg proxy for segments"""
    try:
        logging.info(f"FFmpeg HLS proxy request for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Check if it's a generated ID (starts with 'movie_')
        if video_id.startswith('movie_'):
            # Extract index from generated ID: movie_{index}_{timestamp}_{random}
            try:
                index = int(video_id.split('_')[1])
                logging.info(f"Generated ID detected for FFmpeg HLS, using index: {index}")
                
                # Get all videos and use the index
                all_videos = movie_api.get_all_videos(email, password, limit=1000)
                
                if index < 0 or index >= len(all_videos):
                    return jsonify({'error': f'Video index {index} out of range'}), 404
                
                target_video = all_videos[index]
                logging.info(f"Found video by index for FFmpeg HLS: {target_video.get('title', '')}")
                
            except (ValueError, IndexError) as e:
                logging.error(f"Error parsing generated ID {video_id}: {e}")
                return jsonify({'error': 'Invalid generated video ID'}), 400
        else:
            # Original ID - search by ID
            all_videos = movie_api.get_all_videos(email, password, limit=1000)
            
            target_video = None
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Import requests here to avoid circular imports
        import requests
        
        # Get the HLS manifest
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(video_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch HLS manifest: {response.status_code}'}), 500
        
        # Get the manifest content
        manifest_content = response.text
        
        # Replace segment URLs to use our FFmpeg proxy
        base_url = video_url.rsplit('/', 1)[0] + '/'
        proxy_base = f'/api/movies/ffmpeg-segment/{video_id}/'
        
        # Replace segment URLs in the manifest
        import re
        
        # Function to properly replace segment URLs
        def replace_segment_urls_in_manifest(manifest_content, proxy_base):
            lines = manifest_content.split('\n')
            modified_lines = []
            
            for line in lines:
                stripped_line = line.strip()
                
                # Check if this line contains a segment URL (not a comment and contains segment extension)
                if (stripped_line and 
                    not stripped_line.startswith('#') and 
                    (stripped_line.endswith('.ts') or stripped_line.endswith('.m4s') or stripped_line.endswith('.mp4'))):
                    
                    # If it's an absolute URL, extract just the filename
                    if stripped_line.startswith('http'):
                        segment_name = stripped_line.split('/')[-1]
                        modified_line = proxy_base + segment_name
                    else:
                        # It's a relative URL, just prepend the proxy base
                        modified_line = proxy_base + stripped_line
                    
                    logging.info(f"Replaced segment URL: {stripped_line} -> {modified_line}")
                    modified_lines.append(modified_line)
                else:
                    # Keep the line as is
                    modified_lines.append(line)
            
            return '\n'.join(modified_lines)
        
        # Apply the replacement
        manifest_content = replace_segment_urls_in_manifest(manifest_content, proxy_base)
        
        # Also replace audio and subtitle URLs if they exist
        manifest_content = re.sub(r'URI="([^"]+\.m3u8)"', r'URI="/api/movies/ffmpeg-hls-audio/' + video_id + r'/\1"', manifest_content)
        
        # Replace subtitle URLs (VTT, SRT, ASS files)
        manifest_content = re.sub(r'URI="([^"]+\.(vtt|srt|ass|ssa))"', r'URI="/api/movies/ffmpeg-subtitle/' + video_id + r'/\1"', manifest_content)
        
        # Add debug logging for manifest content
        logging.info(f"Original manifest length: {len(response.text)}")
        logging.info(f"Modified manifest length: {len(manifest_content)}")
        logging.info(f"Segment replacements made: {manifest_content.count(proxy_base)}")
        
        # Log a sample of the modified manifest
        lines = manifest_content.split('\n')
        segment_lines = [line for line in lines if '.ts' in line or '.m4s' in line or '.mp4' in line]
        if segment_lines:
            logging.info(f"Sample segment lines: {segment_lines[:3]}")
        
        # Add CORS headers for the manifest
        return Response(
            manifest_content,
            content_type='application/vnd.apple.mpegurl',
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type, Range',
                'Access-Control-Expose-Headers': 'Content-Length, Content-Range',
                'Cache-Control': 'public, max-age=300',
            }
        )
        
    except Exception as e:
        logging.error(f"Error in FFmpeg HLS proxy for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/ffmpeg-hls-audio/<video_id>/<path:audio_url>')
def ffmpeg_hls_audio_proxy(video_id, audio_url):
    """Proxy HLS audio streams"""
    try:
        # Decode the audio URL
        import urllib.parse
        audio_url = urllib.parse.unquote(audio_url)
        
        # Import requests here to avoid circular imports
        import requests
        
        # Get the audio manifest
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(audio_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({'error': f'Failed to fetch audio manifest: {response.status_code}'}), 500
        
        # Get the manifest content
        manifest_content = response.text
        
        # Replace segment URLs to use our proxy
        base_url = audio_url.rsplit('/', 1)[0] + '/'
        proxy_base = f'/api/movies/ffmpeg-segment/{video_id}/'
        
        # Replace segment URLs in the manifest
        import re
        manifest_content = re.sub(r'([^/]+\.ts)', proxy_base + r'\1', manifest_content)
        
        return Response(
            manifest_content,
            content_type='application/vnd.apple.mpegurl',
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type',
            }
        )
        
    except Exception as e:
        logging.error(f"Error in FFmpeg audio proxy for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/debug-hls/<video_id>')
def debug_hls_stream(video_id):
    """Debug HLS stream to identify issues"""
    try:
        logging.info(f"Debug HLS stream for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Get video data
        all_videos = movie_api.get_all_videos(email, password, limit=1000)
        
        target_video = None
        if video_id.startswith('movie_'):
            try:
                index = int(video_id.split('_')[1])
                if index >= 0 and index < len(all_videos):
                    target_video = all_videos[index]
            except (ValueError, IndexError):
                pass
        else:
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Test the original URL
        import requests
        
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(video_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({
                'error': f'Failed to fetch HLS manifest: {response.status_code}',
                'status_code': response.status_code,
                'headers': dict(response.headers)
            }), 500
        
        # Analyze the manifest content
        content = response.text
        lines = content.split('\n')
        
        # Extract segment URLs
        segment_urls = []
        for line in lines:
            if line.strip() and not line.startswith('#') and ('.ts' in line or '.m4s' in line or '.mp4' in line):
                segment_urls.append(line.strip())
        
        # Test a few segment URLs
        segment_tests = []
        for i, segment_url in enumerate(segment_urls[:3]):  # Test first 3 segments
            try:
                # Make segment URL absolute if it's relative
                if not segment_url.startswith('http'):
                    base_url = video_url.rsplit('/', 1)[0] + '/'
                    segment_url = base_url + segment_url
                
                seg_response = requests.head(segment_url, headers=headers, verify=False, timeout=10)
                segment_tests.append({
                    'segment': segment_url,
                    'status_code': seg_response.status_code,
                    'content_length': seg_response.headers.get('content-length', 'unknown'),
                    'content_type': seg_response.headers.get('content-type', 'unknown')
                })
            except Exception as e:
                segment_tests.append({
                    'segment': segment_url,
                    'error': str(e)
                })
        
        return jsonify({
            'success': True,
            'video_title': target_video.get('title', ''),
            'original_url': video_url,
            'proxy_url': f'/api/movies/ffmpeg-hls/{video_id}',
            'manifest_info': {
                'total_lines': len(lines),
                'segment_count': len(segment_urls),
                'is_hls': '#EXTM3U' in content,
                'content_length': len(content)
            },
            'sample_segments': segment_urls[:5],
            'segment_tests': segment_tests,
            'manifest_preview': content[:1000] + '...' if len(content) > 1000 else content
        })
        
    except Exception as e:
        logging.error(f"Error debugging HLS stream for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/movies/validate-manifest/<video_id>')
def validate_hls_manifest(video_id):
    """Validate HLS manifest and test segment accessibility"""
    try:
        logging.info(f"Validating HLS manifest for video_id: '{video_id}'")
        
        email = request.args.get('email')
        password = request.args.get('password')
        
        # Get video data
        all_videos = movie_api.get_all_videos(email, password, limit=1000)
        
        target_video = None
        if video_id.startswith('movie_'):
            try:
                index = int(video_id.split('_')[1])
                if index >= 0 and index < len(all_videos):
                    target_video = all_videos[index]
            except (ValueError, IndexError):
                pass
        else:
            for video in all_videos:
                if video.get('id') == video_id:
                    target_video = video
                    break
        
        if not target_video:
            return jsonify({'error': 'Video not found'}), 404
        
        video_url = target_video.get('video_url')
        if not video_url:
            return jsonify({'error': 'Video URL not available'}), 404
        
        # Test the original URL
        import requests
        
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://meocon.xyz/',
        }
        
        response = requests.get(video_url, headers=headers, verify=False)
        
        if response.status_code != 200:
            return jsonify({
                'error': f'Failed to fetch HLS manifest: {response.status_code}',
                'status_code': response.status_code,
                'headers': dict(response.headers)
            }), 500
        
        # Analyze the manifest content
        content = response.text
        lines = content.split('\n')
        
        # Extract segment URLs
        segment_urls = []
        for line in lines:
            if line.strip() and not line.startswith('#') and ('.ts' in line or '.m4s' in line or '.mp4' in line):
                segment_urls.append(line.strip())
        
        # Test segment accessibility
        segment_tests = []
        accessible_segments = 0
        
        for i, segment_url in enumerate(segment_urls[:5]):  # Test first 5 segments
            try:
                # Make segment URL absolute if it's relative
                if not segment_url.startswith('http'):
                    base_url = video_url.rsplit('/', 1)[0] + '/'
                    segment_url = base_url + segment_url
                
                seg_response = requests.head(segment_url, headers=headers, verify=False, timeout=10)
                
                is_accessible = seg_response.status_code == 200
                if is_accessible:
                    accessible_segments += 1
                
                segment_tests.append({
                    'segment': segment_url,
                    'status_code': seg_response.status_code,
                    'content_length': seg_response.headers.get('content-length', 'unknown'),
                    'content_type': seg_response.headers.get('content-type', 'unknown'),
                    'accessible': is_accessible
                })
            except Exception as e:
                segment_tests.append({
                    'segment': segment_url,
                    'error': str(e),
                    'accessible': False
                })
        
        # Calculate accessibility percentage
        accessibility_percentage = (accessible_segments / len(segment_tests)) * 100 if segment_tests else 0
        
        # Determine if manifest is valid
        is_valid = accessibility_percentage >= 80  # At least 80% of segments should be accessible
        
        return jsonify({
            'success': True,
            'video_title': target_video.get('title', ''),
            'original_url': video_url,
            'proxy_url': f'/api/movies/ffmpeg-hls/{video_id}',
            'manifest_info': {
                'total_lines': len(lines),
                'segment_count': len(segment_urls),
                'is_hls': '#EXTM3U' in content,
                'content_length': len(content),
                'is_valid': is_valid,
                'accessibility_percentage': accessibility_percentage
            },
            'segment_tests': segment_tests,
            'recommendation': 'valid' if is_valid else 'invalid',
            'issues': [] if is_valid else [
                'Some segments are not accessible',
                'Check segment URLs in manifest',
                'Verify CORS settings'
            ]
        })
        
    except Exception as e:
        logging.error(f"Error validating HLS manifest for video {video_id}: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/service-worker.js')
def service_worker():
    """Serve the service worker file from the root URL"""
    return send_from_directory('.', 'service-worker.js', mimetype='application/javascript')

@app.route('/api/ai-suggest', methods=['POST'])
def ai_suggest():
    """Phân tích nhu cầu người dùng từ lịch sử từ khoá và gợi ý nội dung phù hợp bằng AI Pollinations"""
    try:
        data = request.get_json()
        keywords = data.get('keywords', [])
        if not keywords or not isinstance(keywords, list):
            return jsonify({'error': 'Missing or invalid keywords'}), 400

        # Tạo prompt cho AI
        prompt = (
            "Dựa trên các từ khoá tìm kiếm sau của người dùng: "
            f"{', '.join(keywords)}. "
            "Hãy phân tích nhu cầu, sở thích và trả về một danh sách các từ khoá tìm kiếm ngắn gọn để đáp ứng nhu cầu tìm kiếm các video liên quan tới từ khoá đầu vào. "
            "Chỉ trả về kết quả dưới dạng JSON với trường duy nhất: 'search_keywords' (danh sách các từ khoá gợi ý để tìm kiếm)."
        )

        # Gọi API AI Pollinations
        ai_url = f"https://text.pollinations.ai/{requests.utils.quote(prompt)}"
        ai_response = requests.get(ai_url, timeout=30)
        if ai_response.status_code != 200:
            return jsonify({'error': 'AI service error', 'status_code': ai_response.status_code}), 502

        # Xử lý kết quả trả về (giả định là text hoặc JSON)
        try:
            result = ai_response.json()
        except Exception:
            # Nếu không phải JSON, thử trích xuất JSON từ text (markdown hoặc thuần)
            import re, json as pyjson
            text = ai_response.text
            # Tìm đoạn JSON trong markdown
            match = re.search(r'```json\\n([\s\S]+?)\\n```', text)
            if not match:
                match = re.search(r'```json\n([\s\S]+?)\n```', text)
            if not match:
                match = re.search(r'```([\s\S]+?)```', text)
            if match:
                json_str = match.group(1)
                try:
                    result = pyjson.loads(json_str)
                except Exception:
                    result = {'raw': text}
            else:
                # Nếu không tìm thấy, thử parse toàn bộ text
                try:
                    result = pyjson.loads(text)
                except Exception:
                    result = {'raw': text}

        return jsonify({'result': result})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api-docs')
def api_docs_page():
    """Render the RESTful API documentation page"""
    return render_template('api_docs.html')
@app.route('/chupanh')
def chupanh():
    """Render the RESTful API documentation page"""
    return render_template('chupanh.html')
@app.route('/api/trending/<category>')
def get_trending_videos_api(category):
    """Get trending videos for a category"""
    page = int(request.args.get('page', 1))
    per_page = int(request.args.get('per_page', 24))
    
    if category == 'mixed' or category == 'trending':
        result = trending.get_mixed_trending(page=page, per_page=per_page)
    else:
        result = trending.get_trending_videos(category, page=page, per_page=per_page)
    
    return jsonify(result)

@app.route('/api/trending')
def get_all_trending():
    """Get mixed trending videos from all categories"""
    page = int(request.args.get('page', 1))
    per_page = int(request.args.get('per_page', 24))
    
    result = trending.get_mixed_trending(page=page, per_page=per_page)
    return jsonify(result)

@app.route('/trending')
def trending_page():
    """Render the Trending page using data from /api/trending"""
    import requests
    from flask import render_template
    api_url = request.url_root.rstrip('/') + '/api/trending'
    try:
        resp = requests.get(api_url)
        data = resp.json() if resp.status_code == 200 else {'videos': []}
    except Exception as e:
        data = {'videos': [], 'error': str(e)}
    return render_template('trending.html', trending=data)

def extract_video_id(url_or_id: str) -> str:
    """Extract YouTube video ID from URL or return as is if already ID."""
    match = re.search(r"(?:v=|youtu\\.be/)([0-9A-Za-z_-]{11})", url_or_id)
    if match:
        return match.group(1)
    return url_or_id

def get_transcript_text(video_id: str) -> str:
    """Fetch transcript from YouTube video."""
    try:
        transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en', 'vi'])
        transcript_text = " ".join([entry['text'] for entry in transcript])
        return transcript_text
    except TranscriptsDisabled:
        raise Exception("Transcripts are disabled for this video")
    except NoTranscriptFound:
        raise Exception("No transcript found for this video")
    except Exception as e:
        raise Exception(f"Error fetching transcript: {str(e)}")

@app.route('/api/youtube/summary/<video_id>')
def get_youtube_video_summary(video_id):
    """Get AI summary for YouTube video subtitle (GET, giữ nguyên endpoint)"""
    try:
        # Cho phép truyền cả URL hoặc video_id
        video_id = extract_video_id(video_id)
        transcript_text = get_transcript_text(video_id)
        if len(transcript_text) < 50:
            return jsonify({'error': 'Transcript is too short to summarize'}), 400
        max_input_length = 1024
        transcript_text_cut = transcript_text[:max_input_length]
        summary = summarize_text(transcript_text_cut, max_length=150, min_length=30)
        return jsonify({
            'original': transcript_text_cut,
            'summary': summary
        })
    except Exception as e:
        return jsonify({'error': f'Error processing request: {str(e)}'}), 500

# Import routes after app creation to avoid circular imports
from routes import *

if __name__ == '__main__':
    # Scan videos when server starts
    try:
        logging.info("Performing initial video scan...")
        local_video_manager.scan_videos()
        logging.info("Initial video scan completed")
    except Exception as e:
        logging.error(f"Error during initial video scan: {e}")
    
    app.run(host='0.0.0.0', port=5005, debug=True)