video_generator_module.py

import os
import logging
import random
from moviepy.editor import (
    AudioFileClip, ImageClip, concatenate_videoclips, 
    VideoFileClip, ColorClip, CompositeVideoClip, TextClip
)
from pathlib import Path
import math
# Thêm đoạn này vào đầu file video_generator_module.py
import PIL.Image
from moviepy.config import change_settings

change_settings({"IMAGEMAGICK_BINARY": r"C:\Program Files\ImageMagick-7.1.2-Q16-HDRI\magick.exe"})

# Patch thuộc tính ANTIALIAS nếu thiếu
if not hasattr(PIL.Image, 'ANTIALIAS'):
    PIL.Image.ANTIALIAS = PIL.Image.Resampling.LANCZOS

# --- CẤU HÌNH LOGGING ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# --- HẰNG SỐ VÀ THIẾT LẬP CHUNG ---
DEFAULT_SAVE_DIR = "generated_video_output"
DEFAULT_ASPECT_RATIOS = {
    "ngang": (16, 9),   # Phổ biến cho YouTube, Facebook feed
    "doc": (9, 16),     # Phổ biến cho TikTok, Reels, Shorts
    "vuong": (1, 1)     # Phổ biến cho Instagram Feed, Twitter
}

# Cấu hình cho thumbnail overlay
THUMBNAIL_SHOW_DURATION = 5.0  # 5 giây đầu
THUMBNAIL_HEIGHT_RATIO = 1/3    # 1/3 chiều cao video (có thể bị điều chỉnh)
LOGO_SIZE_RATIO = 0.08         # Logo chiếm 8% chiều rộng video
LOGO_MARGIN = 20               # Margin từ góc
TEXT_MARGIN = 20               # Margin cho text trong thumbnail

# --- HỖ TRỢ CHUYỂN ĐỔI TỶ LỆ KHUNG HÌNH ---
def get_resolution(aspect_ratio_key: str, height: int = 1080) -> tuple[int, int]:
    """
    Trả về độ phân giải (width, height) dựa trên key tỷ lệ khung hình và chiều cao mong muốn.
    """
    if aspect_ratio_key not in DEFAULT_ASPECT_RATIOS:
        raise ValueError(f"Tỷ lệ khung hình '{aspect_ratio_key}' không hỗ trợ. Hãy chọn trong: {list(DEFAULT_ASPECT_RATIOS.keys())}")
    
    width_ratio, height_ratio = DEFAULT_ASPECT_RATIOS[aspect_ratio_key]
    
    if height_ratio == 0: 
        raise ValueError("Tỷ lệ chiều cao không được bằng 0.")
    
    width = int(height * width_ratio / height_ratio)
    width = width + (width % 2) # Đảm bảo kích thước là số chẵn
    
    logging.info(f"Độ phân giải cho '{aspect_ratio_key}' (height={height}): ({width}, {height})")
    return (width, height)

def get_media_dimensions(clip):
    """
    Lấy kích thước thực tế của media clip
    """
    if hasattr(clip, 'w') and hasattr(clip, 'h'):
        return clip.w, clip.h
    elif hasattr(clip, 'size'):
        return clip.size
    else:
        return None, None

def calculate_aspect_ratio(width, height):
    """
    Tính tỷ lệ khung hình của media
    """
    if width and height and height != 0:
        return width / height
    return None

def smart_fit_and_fill(clip, target_resolution, media_type='image', fill_color=(0, 0, 0)):
    """
    Fit media vào target resolution mà không méo hình, và fill các vùng trống với màu nền.
    
    Args:
        clip: Video hoặc Image clip cần xử lý
        target_resolution: (width, height) của target
        media_type: 'image' hoặc 'video'
        fill_color: Màu nền cho vùng trống (R, G, B)
    
    Returns:
        Composite clip với media được fit và background được fill
    """
    target_width, target_height = target_resolution
    
    # Lấy kích thước gốc của clip
    original_width, original_height = get_media_dimensions(clip)
    
    if not original_width or not original_height:
        logging.warning(f"Không thể lấy kích thước gốc của clip, sử dụng resize thông thường")
        return clip.resize(target_resolution)
    
    original_aspect_ratio = calculate_aspect_ratio(original_width, original_height)
    target_aspect_ratio = target_width / target_height
    
    if not original_aspect_ratio:
        logging.warning(f"Không thể tính tỷ lệ khung hình gốc, sử dụng resize thông thường")
        return clip.resize(target_resolution)
    
    logging.info(f"Media gốc: {original_width}x{original_height} (ratio: {original_aspect_ratio:.2f})")
    logging.info(f"Target: {target_width}x{target_height} (ratio: {target_aspect_ratio:.2f})")
    
    # Kiểm tra nếu tỷ lệ gần như giống nhau
    if abs(original_aspect_ratio - target_aspect_ratio) < 0.01:
        logging.info("Tỷ lệ khung hình gốc phù hợp, chỉ cần resize")
        return clip.resize(target_resolution)
    
    # Tính toán scale để fit (không bị méo)
    scale_by_width = target_width / original_width
    scale_by_height = target_height / original_height
    
    # Chọn scale nhỏ hơn để đảm bảo fit hoàn toàn vào target
    scale_factor = min(scale_by_width, scale_by_height)
    
    # Tính kích thước mới sau khi scale
    new_width = int(original_width * scale_factor)
    new_height = int(original_height * scale_factor)
    
    # Đảm bảo kích thước chẵn
    new_width = new_width + (new_width % 2)
    new_height = new_height + (new_height % 2)
    
    logging.info(f"Scale factor: {scale_factor:.3f}")
    logging.info(f"Media sau khi fit: {new_width}x{new_height}")
    
    # Resize clip với tỷ lệ đã tính
    fitted_clip = clip.resize((new_width, new_height))
    
    # Tính vị trí để center media trong target frame
    x_offset = (target_width - new_width) // 2
    y_offset = (target_height - new_height) // 2
    
    logging.info(f"Vị trí center: ({x_offset}, {y_offset})")
    
    # Tạo background với màu fill
    duration = getattr(clip, 'duration', 1.0) if hasattr(clip, 'duration') else 1.0
    background = ColorClip(
        size=target_resolution, 
        color=fill_color, 
        duration=duration
    ).set_fps(24)
    
    # Đặt vị trí cho fitted clip
    fitted_clip = fitted_clip.set_position((x_offset, y_offset))
    
    # Composite background và fitted clip
    final_clip = CompositeVideoClip([background, fitted_clip], size=target_resolution)
    
    return final_clip

def smart_crop_to_fill(clip, target_resolution, media_type='image', fill_color=(255, 255, 255), bottom_padding: int = 160):
    """
    Crop phần trung tâm của clip sao cho vừa với target resolution mà không bị méo hình.
    Phía dưới sẽ chừa ra một vùng trống (màu đen hoặc màu chỉ định) để hiển thị caption, logo,...

    Args:
        clip: Video hoặc Image clip cần xử lý
        target_resolution: (width, height) đầu ra mong muốn
        media_type: 'image' hoặc 'video'
        fill_color: màu nền cho phần trống
        bottom_padding: chiều cao phần nền đen ở dưới (tính bằng pixel)

    Returns:
        CompositeVideoClip đã crop và chèn vào khung
    """
    target_width, target_height = target_resolution
    effective_crop_height = target_height - bottom_padding  # phần sẽ chứa nội dung

    original_width, original_height = get_media_dimensions(clip)

    if not original_width or not original_height:
        return clip.resize(target_resolution)

    target_ratio = target_width / effective_crop_height
    original_ratio = original_width / original_height

    # Crop giữ phần trung tâm
    if original_ratio > target_ratio:
        new_width = int(original_height * target_ratio)
        x1 = (original_width - new_width) // 2
        x2 = x1 + new_width
        y1 = 0
        y2 = original_height
    else:
        new_height = int(original_width / target_ratio)
        y1 = (original_height - new_height) // 2
        y2 = y1 + new_height
        x1 = 0
        x2 = original_width

    cropped = clip.crop(x1=x1, y1=y1, x2=x2, y2=y2)
    resized_cropped = cropped.resize((target_width, effective_crop_height))

    # Tạo background đen (hoặc màu fill)
    duration = getattr(clip, 'duration', 1.0)
    background = ColorClip(size=target_resolution, color=fill_color, duration=duration).set_fps(24)

    # Đặt phần crop ở top-center
    final = CompositeVideoClip([background, resized_cropped.set_position(("center", "top"))], size=target_resolution)

    return final

# --- CÁC HÀM MỚI CHO THUMBNAIL OVERLAY ---

def create_thumbnail_overlay(
    thumbnail_path: str,
    logo_path: str,
    description: str,
    date: str,
    target_resolution: tuple[int, int],
    duration: float = THUMBNAIL_SHOW_DURATION
) -> CompositeVideoClip:
    """
    Tạo overlay thumbnail với logo và text cho 5 giây đầu video.
    Thumbnail sẽ được scale để CHIỀU RỘNG luôn bao phủ đủ (có thể hi sinh chiều cao).
    
    Layout:
    ┌─────────────────────────┐
    │          VIDEO          │
    │                    LOGO │ ← Góc phải trên
    │                         │
    │                         │
    ├─────────────────────────┤
    │      THUMBNAIL     DATE │ ← Date ở góc phải trên của thumbnail
    │    + DESCRIPTION        │   (Text overlay trên thumbnail)
    │                         │
    └─────────────────────────┘
    
    Args:
        thumbnail_path: Đường dẫn ảnh thumbnail
        logo_path: Đường dẫn logo
        description: Mô tả văn bản (hiển thị trên thumbnail)
        date: Ngày tháng (hiển thị ở góc phải trên thumbnail)
        target_resolution: (width, height) của video
        duration: Thời lượng hiển thị overlay (mặc định 5 giây)
    
    Returns:
        CompositeVideoClip chứa thumbnail overlay
    """
    description = description.upper()
    target_width, target_height = target_resolution
    max_thumbnail_height = int(target_height * THUMBNAIL_HEIGHT_RATIO)
    
    # 1. Tạo nền trong suốt cho overlay
    overlay_background = ColorClip(
        size=target_resolution,
        color=(0, 0, 0),  # Đen
        duration=duration
    ).set_opacity(0.3)  # Trong suốt
    
    overlay_clips = [overlay_background]
    
    # 2. Xử lý thumbnail - SCALE ĐỂ FILL WIDTH
    actual_thumbnail_height = max_thumbnail_height  # Mặc định
    thumbnail_y_position = target_height - max_thumbnail_height
    
    if thumbnail_path and os.path.exists(thumbnail_path):
        try:
            thumbnail_clip = ImageClip(thumbnail_path, duration=duration)
            
            # Lấy kích thước gốc của thumbnail
            original_thumb_width, original_thumb_height = get_media_dimensions(thumbnail_clip)
            
            if original_thumb_width and original_thumb_height:
                # SCALE ĐỂ FILL WIDTH (ưu tiên chiều rộng)
                scale_to_fit_width = target_width / original_thumb_width
                
                # Tính chiều cao sau khi scale theo width
                scaled_height = int(original_thumb_height * scale_to_fit_width)
                
                # Resize thumbnail để fill width
                thumbnail_resized = thumbnail_clip.resize((target_width, scaled_height))
                
                # Nếu chiều cao sau scale vượt quá max_thumbnail_height, crop từ giữa
                if scaled_height > max_thumbnail_height:
                    # Crop từ giữa để giữ lại phần quan trọng nhất
                    crop_start_y = (scaled_height - max_thumbnail_height) // 2
                    crop_end_y = crop_start_y + max_thumbnail_height
                    
                    thumbnail_resized = thumbnail_resized.crop(
                        x1=0, y1=crop_start_y, 
                        x2=target_width, y2=crop_end_y
                    )
                    actual_thumbnail_height = max_thumbnail_height
                    logging.info(f"Thumbnail được crop: từ {scaled_height}px xuống {max_thumbnail_height}px")
                else:
                    # Nếu chiều cao sau scale nhỏ hơn max, cập nhật actual height
                    actual_thumbnail_height = scaled_height
                    
                # Tính lại vị trí Y dựa trên chiều cao thực tế
                thumbnail_y_position = target_height - actual_thumbnail_height
                
                # Đặt vị trí thumbnail ở dưới cùng, fill width
                thumbnail_positioned = thumbnail_resized.set_position((0, thumbnail_y_position)).set_opacity(0.8)
                overlay_clips.append(thumbnail_positioned)
                
                logging.info(f"Thumbnail - Original: {original_thumb_width}x{original_thumb_height}")
                logging.info(f"Thumbnail - Scaled: {target_width}x{scaled_height}")
                logging.info(f"Thumbnail - Final: {target_width}x{actual_thumbnail_height}")
                logging.info(f"Thumbnail - Position: (0, {thumbnail_y_position})")
            else:
                # Fallback nếu không lấy được kích thước
                thumbnail_resized = thumbnail_clip.resize((target_width, max_thumbnail_height))
                thumbnail_positioned = thumbnail_resized.set_position((0, thumbnail_y_position)).set_opacity(0.8)
                overlay_clips.append(thumbnail_positioned)
                logging.warning(f"Sử dụng fallback resize cho thumbnail: {thumbnail_path}")
            
        except Exception as e:
            logging.warning(f"Không thể xử lý thumbnail '{thumbnail_path}': {e}")
    
    # 3. Xử lý logo - đặt ở góc phải trên
    if logo_path and os.path.exists(logo_path):
        try:
            logo_clip = ImageClip(logo_path, duration=duration)
            
            # Resize logo theo tỷ lệ
            logo_width = int(target_width * LOGO_SIZE_RATIO)
            logo_resized = logo_clip.resize(width=logo_width)
            
            # Đặt vị trí logo ở góc phải trên
            logo_x = target_width - logo_resized.w - LOGO_MARGIN
            logo_y = LOGO_MARGIN
            logo_positioned = logo_resized.set_position((logo_x, logo_y))
            overlay_clips.append(logo_positioned)
            
            logging.info(f"Logo - Size: {logo_resized.w}x{logo_resized.h} - Position: ({logo_x}, {logo_y})")
            
        except Exception as e:
            logging.warning(f"Không thể xử lý logo '{logo_path}': {e}")
    
    # 4. Thêm text description - đặt TRONG vùng thumbnail với chất lượng cao
    if description and description.strip():
        try:
            # Tính toán vị trí text trong vùng thumbnail
            desc_y = thumbnail_y_position + TEXT_MARGIN  + 40# Bên trong thumbnail, từ trên xuống
            
            # Font size lớn hơn và responsive
            font_size = max(int(target_width * 0.035), 50)  # Tăng từ 0.025 lên 0.035, minimum 50px
            
            # Sử dụng font an toàn và method tối ưu
            desc_clip = TextClip(
                description.strip(),
                fontsize=font_size,
                font='Open Sans',  # Font an toàn, luôn có sẵn
                color='white',
                method='label',     # Thay đổi từ 'caption' sang 'label' để tránh blur
                align='West',       # Căn trái
                size=(target_width - 4 * TEXT_MARGIN, None)  # Tăng margin để text không bị sát mép
            ).set_duration(duration).set_position((2 * TEXT_MARGIN, desc_y))
            
            overlay_clips.append(desc_clip)
            
        except Exception as e:
            logging.warning(f"Không thể tạo description text: {e}")
    
    # 5. Thêm text date - đặt ở góc phải trên của thumbnail với chất lượng cao
    if date and date.strip():
        try:
            # Tính toán vị trí date ở góc phải trên của thumbnail
            date_y = thumbnail_y_position + TEXT_MARGIN # Cùng hàng với description
            
            # Font size cho date
            date_font_size = max(int(target_width * 0.025), 20)  # Tăng minimum lên 35px
            
            # Tạo date clip để tính toán width chính xác
            date_clip = TextClip(
                date.strip(),
                fontsize=date_font_size,
                font='Open Sans',  # Font an toàn
                color='white',
                method='label',     # Sử dụng 'label' thay vì default để tránh blur
                align='center'
            ).set_duration(duration)
            
            # Tính toán vị trí X để đặt ở góc phải
            date_x = target_width - date_clip.w - 2 * TEXT_MARGIN
            date_positioned = date_clip.set_position((date_x, date_y))
            
            overlay_clips.append(date_positioned)
            logging.info(f"Date text - Font: Arial-Bold {date_font_size}px - Position: ({date_x}, {date_y})")
            
        except Exception as e:
            logging.warning(f"Không thể tạo date text: {e}")
    
    # 6. Composite tất cả các elements
    thumbnail_overlay = CompositeVideoClip(overlay_clips, size=target_resolution)
    
    return thumbnail_overlay
def rate_media_compatibility(clip, target_aspect_ratio, media_type='image'):
    """
    Đánh giá độ phù hợp của media với target aspect ratio.
    Trả về score từ 0-100, càng cao càng phù hợp.
    """
    original_width, original_height = get_media_dimensions(clip)
    
    if not original_width or not original_height:
        return 50  # Score trung bình nếu không xác định được
    
    original_aspect_ratio = calculate_aspect_ratio(original_width, original_height)
    
    if not original_aspect_ratio:
        return 50
    
    # Tính độ chênh lệch aspect ratio
    ratio_diff = abs(original_aspect_ratio - target_aspect_ratio)
    
    # Score dựa trên độ chênh lệch (càng ít chênh lệch càng cao điểm)
    base_score = max(0, 100 - (ratio_diff * 50))
    
    # Bonus cho video (thường linh hoạt hơn ảnh)
    if media_type == 'video':
        base_score += 10
    
    # Penalty nếu resolution quá thấp
    min_dimension = min(original_width, original_height)
    if min_dimension < 480:
        base_score -= 30
    elif min_dimension < 720:
        base_score -= 15
    
    # Bonus nếu media có thể fit tốt (ít vùng trống)
    scale_by_width = 1080 / original_width  # Giả sử target là 1080p
    scale_by_height = 1080 / original_height
    scale_factor = min(scale_by_width, scale_by_height)
    
    # Tính % diện tích media chiếm trong target frame
    fitted_area = (original_width * scale_factor) * (original_height * scale_factor)
    target_area = 1080 * (1080 * target_aspect_ratio if target_aspect_ratio < 1 else 1080)
    area_ratio = fitted_area / target_area
    
    # Bonus nếu media chiếm nhiều diện tích (ít vùng trống)
    if area_ratio > 0.8:
        base_score += 15
    elif area_ratio > 0.6:
        base_score += 10
    elif area_ratio < 0.3:
        base_score -= 10
    
    return max(0, min(100, base_score))

# --- CÁC HÀM XỬ LÝ VIDEO ---

def create_clips_from_media_files(
    media_files: list[str], 
    target_duration: float, 
    aspect_ratio_key: str, 
    resolution: tuple[int, int]
) -> list:
    """
    Chọn và tạo các clip (ảnh hoặc video) từ danh sách media,
    ưu tiên các media có aspect ratio phù hợp.
    - Video sẽ được xử lý bằng smart_crop_to_fill (cắt để lấp đầy)
    - Ảnh sẽ được xử lý bằng smart_fit_and_fill (fit với background)
    """
    if not media_files:
        logging.warning("Không có file media nào được cung cấp.")
        return []

    target_width, target_height = resolution
    target_aspect_ratio = target_width / target_height

    valid_media_objects = []
    for media_path in media_files:
        if not os.path.exists(media_path):
            logging.warning(f"File media không tồn tại, bỏ qua: {media_path}")
            continue
        
        ext = media_path.lower().split('.')[-1]
        clip_obj = None
        media_type = None

        try:
            if ext in ['mp4', 'mov', 'avi', 'mkv', 'webm']: # Định dạng video
                clip_obj = VideoFileClip(media_path)
                media_type = 'video'
            elif ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp', 'tiff']: # Định dạng ảnh
                clip_obj = ImageClip(media_path, duration=3.0) # Duration tạm thời cho ảnh
                media_type = 'image'
            else:
                logging.warning(f"Định dạng file media không hỗ trợ, bỏ qua: {media_path}")
                continue
            
            # Đánh giá độ phù hợp
            compatibility_score = rate_media_compatibility(clip_obj, target_aspect_ratio, media_type)
            logging.info(f"Media '{media_path}' - Type: {media_type} - Compatibility score: {compatibility_score:.1f}")
            
            # Áp dụng xử lý khác nhau cho video và ảnh
            if media_type == 'video':
                # Video: Sử dụng smart_crop_to_fill để cắt và lấp đầy
                processed_clip = smart_crop_to_fill(clip_obj, resolution, media_type, fill_color=(20, 20, 20))
                logging.info(f"Video được xử lý bằng smart_crop_to_fill: {media_path}")
            else:  # image
                # Ảnh: Sử dụng smart_fit_and_fill để fit với background
                processed_clip = smart_fit_and_fill(clip_obj, resolution, media_type, fill_color=(20, 20, 20))
                logging.info(f"Ảnh được xử lý bằng smart_fit_and_fill: {media_path}")

            valid_media_objects.append({
                'clip': processed_clip, 
                'type': media_type, 
                'original_clip': clip_obj,
                'compatibility_score': compatibility_score,
                'path': media_path
            })

        except Exception as e:
            logging.warning(f"Không thể xử lý file media '{media_path}': {e}. Bỏ qua.")
            if clip_obj: 
                clip_obj.close() # Đảm bảo giải phóng tài nguyên nếu có lỗi

    if not valid_media_objects:
        logging.warning("Không tìm thấy file media hợp lệ nào sau khi xử lý.")
        return []

    # Sắp xếp theo compatibility score (cao nhất trước)
    valid_media_objects.sort(key=lambda x: x['compatibility_score'], reverse=True)
    logging.info("Thứ tự ưu tiên các media:")
    for i, media in enumerate(valid_media_objects[:5]):  # Chỉ log 5 cái đầu
        logging.info(f"  {i+1}. {media['path']} - Type: {media['type']} - Score: {media['compatibility_score']:.1f}")

    # Phân bổ thời lượng và chọn media ---
    clips_for_concatenation = []
    total_clip_duration = 0
    
    # Ưu tiên các media có score cao, nhưng vẫn có element ngẫu nhiên
    selected_media = []
    high_score_media = [m for m in valid_media_objects if m['compatibility_score'] >= 70]
    medium_score_media = [m for m in valid_media_objects if 40 <= m['compatibility_score'] < 70]
    
    # Chọn tất cả media hợp lệ
    selected_media = valid_media_objects.copy()
    random.shuffle(selected_media)  # Trộn ngẫu nhiên thứ tự phát
    
    # Tính tổng thời lượng của tất cả video
    total_video_duration = 0
    for media_data in selected_media:
        if media_data['type'] == 'video':
            total_video_duration += getattr(media_data['original_clip'], 'duration', 0)
    
    # Nếu tổng thời lượng video ít hơn target_duration, thêm ảnh vào
    if total_video_duration < target_duration:
        # Thêm tất cả ảnh vào danh sách phát
        pass
    
    # Duyệt qua từng media và thêm vào danh sách phát
    for media_data in selected_media:
        clip = media_data['clip']
        
        # Lấy thời lượng gốc của media
        if media_data['type'] == 'image':
            # Đối với ảnh, mặc định 3 giây
            clip_duration = 3.0
        else:  # video
            # Đối với video, lấy thời lượng gốc
            clip_duration = getattr(media_data['original_clip'], 'duration', 0)
        
        # Nếu thêm clip này vượt quá target_duration, điều chỉnh thời lượng
        remaining_duration = target_duration - total_clip_duration
        if remaining_duration <= 0:
            break
            
        # Nếu thời lượng còn lại ít hơn thời lượng clip, cắt clip
        if clip_duration > remaining_duration:
            clip_duration = remaining_duration
        
        # Đặt thời lượng cho clip
        final_clip = clip.set_duration(clip_duration)
        clips_for_concatenation.append(final_clip)
        total_clip_duration += clip_duration
        
        logging.info(f"Đã thêm {media_data['type']}: {media_data['path']} - Duration: {clip_duration:.1f}s - Score: {media_data['compatibility_score']:.1f}")
        
        # Nếu đã đủ thời lượng, dừng lại
        if total_clip_duration >= target_duration:
            break
        
    return clips_for_concatenation

def create_video_from_audio_and_media(
    audio_path: str,
    source_media_paths: list[str], 
    aspect_ratio_key: str,
    output_filename: str = "output_video.mp4",
    version: int = 1,
    output_dir: str = DEFAULT_SAVE_DIR,
    target_height: int = 1080,
    # Tham số mới cho thumbnail overlay
    thumbnail_path: str = None,
    logo_path: str = None,
    description: str = None,
    date: str = None
) -> str:
    """
    Tạo một phiên bản video dựa trên audio và các file media (ảnh/video).
    Có thể thêm thumbnail overlay với logo và text trong 5 giây đầu.
    Thumbnail sẽ được scale để fill width (có thể hi sinh height).
    """
    if not audio_path or not os.path.exists(audio_path):
        raise FileNotFoundError("File audio không tồn tại hoặc đường dẫn bị thiếu.")
    
    if not source_media_paths:
        raise ValueError("Cần ít nhất một file media để tạo video.")

    try:
        # 1. Lấy độ phân giải
        resolution = get_resolution(aspect_ratio_key, height=target_height)
        
        # 2. Tải Audio Clip và lấy duration
        audio_clip = AudioFileClip(audio_path)
        audio_duration = audio_clip.duration
        logging.info(f"Độ dài audio: {audio_duration:.2f} giây")
        
        # 3. Tạo các clip từ danh sách media (ảnh/video) với smart processing
        media_clips = create_clips_from_media_files(source_media_paths, audio_duration, aspect_ratio_key, resolution)
        
        if not media_clips:
            logging.warning("Không có clip media nào được tạo. Sử dụng fallback.")
            # Tạo video với nền đen nếu không có media
            fallback_clip = ColorClip(
                size=resolution, 
                color=(0, 0, 0),  # Màu đen
                duration=audio_duration
            ).set_fps(24)
            media_clips = [fallback_clip]

        # 4. Ghép các clip đã được tạo
        final_video_segment = concatenate_videoclips(media_clips, method="compose")

        # 5. Đảm bảo duration của video khớp với audio
        if abs(final_video_segment.duration - audio_duration) > 0.1:
            final_video_segment = final_video_segment.set_duration(audio_duration)

        # 6. Kết hợp audio vào video clip
        final_video = final_video_segment.set_audio(audio_clip)
        
        # 7. Thêm thumbnail overlay nếu có đủ thông tin
        overlay_added = False
        if any([thumbnail_path, logo_path, description, date]):
            try:
                # Tạo thumbnail overlay cho 5 giây đầu
                thumbnail_overlay = create_thumbnail_overlay(
                    thumbnail_path=thumbnail_path,
                    logo_path=logo_path, 
                    description=description,
                    date=date,
                    target_resolution=resolution,
                    duration=min(THUMBNAIL_SHOW_DURATION, audio_duration)
                )
                
                # Composite overlay lên video
                final_video = CompositeVideoClip([final_video, thumbnail_overlay], size=resolution)
                overlay_added = True
                logging.info(f"Đã thêm thumbnail overlay (fill width) cho {min(THUMBNAIL_SHOW_DURATION, audio_duration):.1f} giây đầu")
                
            except Exception as e:
                logging.warning(f"Không thể thêm thumbnail overlay: {e}")
        
        if not overlay_added:
            logging.info("Không có thumbnail overlay được thêm vào video")
        
        # 8. Tạo thư mục output nếu chưa tồn tại
        os.makedirs(output_dir, exist_ok=True)
        output_path = os.path.join(output_dir, f"v{version}_{output_filename}")
        
        # 9. Ghi file video ra định dạng MP4
        logging.info(f"Đang ghi file video với version {version} ra: {output_path}")
        final_video.write_videofile(
            output_path,
            codec='libx264',        
            audio_codec='aac',      
            fps=24,                 
            threads=4,              
            preset='medium',        
            logger='bar',           
        )
        logging.info(f"Tạo video thành công cho phiên bản {version}!")
        
        # Giải phóng tài nguyên
        audio_clip.close()
        final_video_segment.close()
        final_video.close()
        for clip in media_clips:
            if hasattr(clip, 'close') and clip is not None: 
                clip.close()
            
        return output_path

    except FileNotFoundError as e:
        logging.error(f"Lỗi file: {e}")
        raise
    except ValueError as e:
        logging.error(f"Lỗi giá trị: {e}")
        raise
    except Exception as e:
        logging.error(f"Lỗi không xác định khi tạo video: {e}")
        import traceback
        logging.error(traceback.format_exc()) 
        raise

# --- HÀM CHÍNH ĐỂ TẠO NHIỀU PHIÊN BẢN VIDEO ---
def generate_multiple_video_versions(
    audio_path: str,
    source_media_paths: list[str], 
    aspect_ratio_key: str,
    num_versions: int = 1,
    base_filename: str = "news_video",
    output_dir: str = DEFAULT_SAVE_DIR,
    target_height: int = 1080,
    # Tham số mới cho thumbnail overlay
    thumbnail_path: str = None,
    logo_path: str = None,
    description: str = None,
    date: str = None
) -> list[str]:
    """
    Tạo N phiên bản video khác nhau với các kết hợp media (ảnh/video) ngẫu nhiên.
    Có thể thêm thumbnail overlay với logo và text trong 5 giây đầu.
    Thumbnail sẽ được scale để fill width (có thể hi sinh height).
    """
    if not audio_path or not os.path.exists(audio_path):
        raise FileNotFoundError("File audio không tồn tại hoặc đường dẫn bị thiếu.")
    
    if not source_media_paths:
        raise ValueError("Cần ít nhất một file media để tạo video.")
        
    if num_versions <= 0:
        raise ValueError("Số phiên bản phải lớn hơn 0.")

    generated_video_paths = []
    
    if aspect_ratio_key not in DEFAULT_ASPECT_RATIOS:
         raise ValueError(f"Tỷ lệ khung hình '{aspect_ratio_key}' không hỗ trợ. Hãy chọn trong: {list(DEFAULT_ASPECT_RATIOS.keys())}")
    
    valid_sources = [s for s in source_media_paths if os.path.exists(s)]
    
    if not valid_sources:
        raise ValueError("Không tìm thấy file media hợp lệ nào.")
    
    logging.info(f"Bắt đầu tạo {num_versions} phiên bản video...")
    logging.info(f"Target aspect ratio: {DEFAULT_ASPECT_RATIOS[aspect_ratio_key]}")
    logging.info("Chế độ xử lý: Video = smart_crop_to_fill, Ảnh = smart_fit_and_fill")
    
    # Log thông tin thumbnail overlay
    if any([thumbnail_path, logo_path, description, date]):
        logging.info("Thumbnail overlay sẽ được thêm với:")
        if thumbnail_path: logging.info(f"  - Thumbnail (fill width): {thumbnail_path}")
        if logo_path: logging.info(f"  - Logo: {logo_path}")
        if description: logging.info(f"  - Description (trong thumbnail): {description[:50]}...")
        if date: logging.info(f"  - Date (trong thumbnail): {date}")
        logging.info(f"  - Duration: {THUMBNAIL_SHOW_DURATION} giây đầu")
        logging.info("  - Thumbnail scaling: Fill width, crop height if needed")
    
    try:
        temp_audio_clip = AudioFileClip(audio_path)
        audio_duration = temp_audio_clip.duration
        temp_audio_clip.close()
    except Exception as e:
        raise FileNotFoundError(f"Không thể đọc file audio '{audio_path}': {e}")

    for i in range(num_versions):
        version_num = i + 1
        try:
            logging.info(f"\n--- ĐANG TẠO PHIÊN BẢN VIDEO THỨ {version_num} ---")
            output_filename = f"{base_filename}_v{version_num}.mp4"
            
            video_path = create_video_from_audio_and_media(
                audio_path=audio_path,
                source_media_paths=valid_sources, 
                aspect_ratio_key=aspect_ratio_key,
                output_filename=output_filename,
                version=version_num,
                output_dir=output_dir,
                target_height=target_height,
                # Truyền thông tin thumbnail overlay
                thumbnail_path=thumbnail_path,
                logo_path=logo_path,
                description=description,
                date=date
            )
            generated_video_paths.append(video_path)
            
        except FileNotFoundError as e:
            logging.error(f"Lỗi file ở phiên bản {version_num}: {e}. Bỏ qua phiên bản này.")
        except ValueError as e:
            logging.error(f"Lỗi giá trị ở phiên bản {version_num}: {e}. Bỏ qua phiên bản này.")
        except Exception as e:
            logging.error(f"Lỗi không xác định ở phiên bản {version_num}: {e}")
            import traceback
            logging.error(traceback.format_exc())
    
    logging.info(f"Hoàn tất tạo {len(generated_video_paths)} / {num_versions} phiên bản video.")
    return generated_video_paths


# --- KHỐI ĐỂ CHẠY THỬ NGHIỆM MODULE ---
if __name__ == '__main__':
    # Ví dụ sử dụng module để tạo video với thumbnail overlay
    # audio_file = "./generated_content/audio/podcast_3_1da3ae9d-df2a-400f-8168-b4976bc6e20b.wav"
    audio_file = "generated_content/audio/news_1_7022b2cb-b207-45c6-b24d-144e881996e9.wav"
    o = './public/u23-VietNam/media/'
    source_media = [o + 'output_00' + str(i) + '.mp4' for i in range(9)]
    source_media.extend(['public/u23-VietNam/media/u23-viet-nam-1-1753065357.jpg', 
                        'public/u23-VietNam/media/lich thi dau u23 viet nam.png',
                        'public/u23-VietNam/media/993135543_164183883u23-viet-nam.jpg'])
    
    # Thông tin thumbnail overlay
    thumbnail_img = "thumbnails/thumbnail1.png"
    logo_img = "logo.png"  # Đường dẫn logo
    desc_text = "U23 Việt Nam chuẩn bị cho giải đấu quan trọng"
    date_text = "2025-07-23"
    
    try:
        generated_videos = generate_multiple_video_versions(
            audio_path=audio_file,
            source_media_paths=source_media,
            aspect_ratio_key="doc",
            num_versions=1,
            base_filename="sports_news_video",
            output_dir=DEFAULT_SAVE_DIR,
            target_height=1080,
            # Thông tin thumbnail overlay
            thumbnail_path=thumbnail_img,
            logo_path=logo_img,
            description=desc_text,
            date=date_text
        )
        print("Các video đã được tạo thành công:", generated_videos)
    except Exception as e:
        logging.error(f"Lỗi khi tạo video: {e}")